நிறுவனப் பொருள்களுடன் பணிபுரிதல்

4.1 பரிவர்த்தனைகள் மற்றும் தரவுத்தள ஒருமைப்பாடு

நூற்றுக்கணக்கான வெவ்வேறு வாடிக்கையாளர்களிடமிருந்து ஒவ்வொரு நிமிடமும் ஆயிரக்கணக்கான கோரிக்கைகளைப் பெறும்போது தரவுத்தளத்தின் இயல்பான செயல்பாட்டு முறை ஆகும். இந்த வழக்கில், வெவ்வேறு வினவல்களிலிருந்து ஒரே தரவு அணுகப்படும் போது சூழ்நிலைகள் அடிக்கடி எழுகின்றன.

குறைவாக அடிக்கடி, ஆனால், மீண்டும், அவ்வப்போது ஒரு கோரிக்கை ஒரு குறிப்பிட்ட வரியைப் படிக்கும் சூழ்நிலைகள் உள்ளன, அதே நேரத்தில் மற்றொரு கோரிக்கை அதை மாற்றுகிறது. பாதி மாறிவிட்ட ஒரு வரியை யாராவது படித்தால் என்ன நடக்கும் என்று கற்பனை செய்து பாருங்கள்? எதுவும் நன்றாக இல்லை.

இந்த பிரச்சனை பல வழிகளில் தீர்க்கப்படுகிறது. முதலில், மாறும் வரியை நீங்கள் பூட்டலாம். வாசிப்பதற்கும் எழுதுவதற்கும். இந்த முறை வேலை செய்கிறது, ஆனால் அடித்தளத்தின் வேகம் பெரிதும் பாதிக்கப்படுகிறது.

இரண்டாவது வழி, எழுதுவதற்கு மட்டுமே சரத்தை பூட்டுவது. இருப்பினும், ஓரளவு மாற்றியமைக்கப்பட்ட வரியை யாராவது படிக்க முயற்சிக்கும் போது இன்னும் சிக்கல் இருக்கும். முடிவு - கோடு ஓரளவு மாற்றப்படும் போது ஒரு சூழ்நிலை இருக்கக்கூடாது.

எனவே, அவர்கள் மூன்றாவது முறையைக் கொண்டு வந்தனர் - பரிவர்த்தனைகள். பரிவர்த்தனை என்பது அனைத்தும் ஒன்றாக அல்லது எதுவும் செய்யப்படாத செயல்களின் குழுவாகும். செயல்களின் ஒரு பகுதி நிகழ்த்தப்பட்ட சூழ்நிலை இருக்க முடியாது, மற்றும் இரண்டாவது பகுதி இல்லை. எல்லா மாற்றங்களையும் செய்ய முடியாவிட்டால், ஏற்கனவே செய்யப்பட்ட அனைத்து மாற்றங்களும் மீண்டும் சுருட்டப்படும்.

எந்தவொரு நவீன SQL சேவையகமும் பரிவர்த்தனைகளில் மட்டுமே தரவை மாற்ற உங்களை அனுமதிக்கிறது. நீங்கள் ஒரு பரிவர்த்தனையைத் திறந்து, எத்தனை டேபிள்களில் ஏதேனும் மாற்றங்களைச் செய்து, பரிவர்த்தனையைச் செய்யுங்கள். SQL சேவையகம் மாற்றங்களைச் செய்ய முயற்சிக்கிறது. எல்லாம் சரியாக இருந்தால், அவை பொதுவான தரவுத்தளத்தில் சேர்க்கப்படும். சிக்கல்கள் இருந்தால், அனைத்து மாற்றங்களும் ரத்து செய்யப்படும்.

ஹைபர்னேட் இந்த முன்னுதாரணத்தையும் பயன்படுத்துகிறது. அதனால்தான் முந்தைய விரிவுரையில், பணியாளர் பொருளை தரவுத்தளத்தில் சேமிக்க முயற்சிக்கும்போது, ​​​​முதலில் ஒரு பரிவர்த்தனை திறக்கப்பட்டது, சேமித்த பிறகு அது உறுதி செய்யப்பட்டது.

நாங்கள் இந்த தலைப்பை இன்னும் விரிவாகப் பார்ப்போம், ஆனால் இப்போதைக்கு, பரிவர்த்தனைகள் ஏன் தேவைப்படுகின்றன மற்றும் அவை பொதுவாக எங்கு பயன்படுத்தப்படுகின்றன என்பதை அறிந்து கொள்ளுங்கள்.

4.2 பொருட்களைப் பெறுதல்

தரவைப் பெறுவதற்கான கோரிக்கையை Hibernate செயல்படுத்தினால், பரிவர்த்தனையை வெளிப்படையாகத் திறக்க வேண்டிய அவசியமில்லை. இது பொருத்தமாக இருந்தால், ஹைபர்னேட் தானே இதைச் செய்யும்: இது அதன் அமைப்புகளையும், SQL சேவையகத்தின் அமைப்புகளையும் கொண்டுள்ளது.

தரவுத்தளத்துடன் எவ்வாறு செயல்படுவது என்பதை நாங்கள் பகுப்பாய்வு செய்வோம். அவற்றில் எளிமையானது ஒரு பொருளை அதன் ஐடி மூலம் பெறுவது . இதைச் செய்ய, அமர்வுget() பொருளின் முறையைப் பயன்படுத்தவும் . அத்தகைய கோரிக்கையின் பொதுவான வடிவம்:

Class Name = session.get(Class.class, ID);

உதாரணமாக:

public User getUserById(Integer id) {
    try (Session session = sessionFactory.openSession()) {
        User user = session.get(User.class, id);
        return user;
    }
}

4.3 பொருள்களைச் சேமித்தல் (சேர்த்தல்).

உங்கள் பொருளை தரவுத்தளத்தில் சேமிக்க விரும்பினால், ஒரு வினவல் SQL மட்டத்தில் செயல்படுத்தப்படும்செருகு. எனவே, உங்கள் செயல்கள் ஒரு தனி பரிவர்த்தனையாக செய்யப்பட வேண்டும். மேலும், நிலைத்தன்மைக்கு அமர்வுpersist() பொருளின் முறையைப் பயன்படுத்துவது நல்லது .

அத்தகைய கோரிக்கையின் பொதுவான வடிவம்:

session.persist(An object);

இந்த முறை persist()அடித்தளத்தை மட்டுமல்ல, பொருளையும் மாற்றுகிறது. விஷயம் என்னவென்றால், நாம் ஒரு பொருளை தரவுத்தளத்தில் சேர்க்கும்போது, ​​​​அதைச் சேர்ப்பதற்கு முன்பு இந்த பொருளுக்கு அதன் சொந்த ஐடி இன்னும் இல்லை . நுணுக்கங்கள் இருந்தாலும் சரி, பொதுவாக அப்படித்தான். பொருளைச் சேர்த்த பிறகு ஏற்கனவே ஒரு ஐடி உள்ளது .

public boolean saveUser(User user) {
    try (Session session = sessionFactory.openSession()) {
            Transaction transaction = session.beginTransaction();
            session.persist(user);
            transaction.commit();
            return true;
    }
    catch() {
    return false;
   	}
}

அமர்வு பொருள் save()இதேபோன்ற செயல்பாட்டைச் செய்யும் ஒரு முறையைக் கொண்டுள்ளது . save()முறை பழைய Hibernate தரநிலை மற்றும் முறை persist()JPA தரநிலை என்று தான் .

4.4 பொருட்களை நீக்குதல்

நீங்கள் ஏற்கனவே உள்ள பொருளை நீக்க விரும்பினால், அதைச் செய்வது மிகவும் எளிதானது. இதைச் செய்ய, அமர்வு பொருளுக்கு ஒரு சிறப்பு முறை உள்ளது - remove().

அத்தகைய கோரிக்கையின் பொதுவான வடிவம்:

session.remove(An object);

மற்றும், நிச்சயமாக, குறியீட்டை ஒரு எடுத்துக்காட்டுடன் எழுதுவோம்:

public boolean removeUser(User user) {
    try (Session session = sessionFactory.openSession()) {
            Transaction transaction = session.beginTransaction();
            session.remove(user);
            transaction.commit();
            return true;
    }
    catch() {
    return false;
   	}
}

ஏன் இது மிகவும் கடினம், நீங்கள் கேட்கிறீர்களா?

சரி, முதலில், தரவுத்தளத்தில் எந்த மாற்றமும் எப்போதும் வேறுபட்டது மற்றும் எப்போதும் வெளிப்படையான விளைவுகளை ஏற்படுத்தாது. இரண்டாவதாக, இந்த பொருள் அதனுடன் தொடர்புடைய குழந்தை பொருட்களைக் கொண்டிருக்கலாம். எனவே நீக்குதல் காட்சிகள் பெரும்பாலும் அற்பமானவை அல்ல.