द्वितीय स्तर कॅशे कॉन्फिगर करत आहे

समवर्ती धोरणे

तुम्ही हायबरनेटमध्ये द्वितीय-स्तरीय कॅशिंग सक्षम केल्यानंतर, तुम्हाला हायबरनेटला समजावून सांगावे लागेल की आम्हाला कोणते घटक ऑब्जेक्ट कॅशे करायचे आहेत आणि कसे.

हे करण्यासाठी, हायबरनेटमध्ये अस्तित्व वर्गांसाठी एक विशेष भाष्य आहे - @Cache . उदाहरण:

@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)

हे भाष्य प्रत्येक एंटिटी घटकासाठी लिहिणे आवश्यक आहे ज्यासाठी आम्हाला द्वितीय स्तर कॅशे वापरायचा आहे. उदाहरण:

@Entity
@Table(name = "employee")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Employee {
    @Id
    private Integer id;
    private Set<Task> tasks;
}

हायबरनेटमध्ये कॅशे केलेल्या घटकासाठी 4 संभाव्य प्रवेश धोरणे आहेत जर ती वेगवेगळ्या थ्रेड्समधून प्रवेश केली असेल:

• फक्त वाचा
• वाचा लिहा
• नॉनस्ट्रिक्ट-वाचन-लिहा
• व्यवहार

केवळ वाचा . डेटा-योग्य समवर्ती धोरण जे कधीही बदलत नाही. हायबरनेट या वस्तू फक्त त्याच्या स्मृतीमध्ये संग्रहित करेल. ते फक्त संदर्भ डेटासाठी वापरा.

डेटाबेसमध्ये खूप माहिती साठवली जाते जी कधीही बदलत नाही. उदाहरणार्थ, सारणी केवळ जोडलेल्या परंतु कधीही बदललेल्या किंवा काढल्या जाणार्‍या घटनांची यादी ठेवते. जर तुम्हाला हायबरनेटद्वारे या सारणीसह कार्य करण्याची आवश्यकता असेल, तर केवळ-वाचनीय कॅशिंग धोरण तुमच्यासाठी अनुकूल असेल.

वाचा-लिहा (वाच-लिहा). ही रणनीती प्रामुख्याने वाचनीय डेटासाठी वापरा. तथापि, हायबरनेट हा डेटा बदलण्याच्या प्रयत्नांचा मागोवा घेईल, जरी ते फारच क्वचित असण्याची अपेक्षा करते.

तुम्हाला मुख्यतः त्या वस्तू कॅशे करणे आवश्यक आहे जे क्वचितच बदलतात आणि वारंवार वाचले जातात/ विनंती केली जातात. जर तुमच्याकडे अशा वस्तू असतील, तर तुम्हाला त्यांच्यासाठी वाचन-लेखन धोरण वापरण्याची आवश्यकता आहे.

नॉनस्ट्रिक्ट-वाचन-लिहा . ही रणनीती कॅशे आणि डेटाबेसमधील सुसंगततेची हमी देत ​​नाही. डेटा जवळजवळ कधीच बदलत नसल्यास आणि जुना डेटा होण्याची एक छोटीशी शक्यता ही गंभीर समस्या नसल्यास ही रणनीती वापरा.

वाचन-लिहा धोरणाच्या विपरीत, ही रणनीती असे गृहीत धरते की परिवर्तनीय डेटा वाचण्यासाठी लॉक केलेला नाही. यामुळे ऑब्जेक्ट एका ठिकाणी बदलला जाऊ शकतो, तर दुसऱ्या ठिकाणी, कोणीतरी त्याची जुनी आवृत्ती वाचत आहे.

उदाहरणार्थ, वापरकर्त्याने आपली टिप्पणी बदलली आहे, परंतु इतर वापरकर्ते अजूनही काही काळ त्याची जुनी आवृत्ती पाहतात. जर तुमच्यासाठी ही समस्या नसेल, तर नॉनस्ट्रिक्ट-वाच-लिहा धोरण वापरा.

व्यवहार . ही रणनीती प्रामुख्याने केवळ-वाचनीय डेटासाठी वापरा जिथे अद्यतनाच्या दुर्मिळ प्रसंगी समवर्ती व्यवहारांमध्ये जुना डेटा रोखणे महत्वाचे आहे.

कॅशेमध्ये डेटा संचयित करणे

दुसर्‍या लेव्हल कॅशेबद्दल आणखी एक महत्त्वाचा तपशील जो तुम्ही लक्षात ठेवला पाहिजे तो म्हणजे हायबरनेट तुमच्या वर्गातील वस्तू स्वतः साठवत नाही. हे स्ट्रिंग, संख्या इत्यादींच्या अॅरे म्हणून माहिती संग्रहित करते.

आणि ऑब्जेक्ट आयडेंटिफायर या माहितीसाठी पॉइंटर म्हणून काम करतो. वैचारिकदृष्ट्या, हे नकाशासारखे काहीतरी आहे, ज्यामध्ये ऑब्जेक्टची आयडी ही की आहे आणि डेटा अॅरे हे मूल्य आहे. आपण त्याची अशी कल्पना करू शकता:

1 -> { "Ivanov", 1, null , {1,2,5} }
2 -> { "Petrov", 2, null , {1,2,5} }
3 -> { "Sidorov", 3, null , {1,2,5} }

प्रत्येक ऑब्जेक्ट किती अतिरिक्त मेमरी घेते याचा विचार करता जे अतिशय वाजवी आहे.

वरील व्यतिरिक्त, तुम्ही हे लक्षात ठेवावे की तुमच्या एंटिटी क्लासचे अवलंबित्व देखील डीफॉल्टनुसार कॅशे केलेले नाहीत. उदाहरणार्थ, जर आपण वरील वर्गाचा विचार केला, कर्मचारी , नंतर आणताना, कार्ये संग्रह डेटाबेसमधून पुनर्प्राप्त केला जाईल , द्वितीय-स्तरीय कॅशेमधून नाही .

जर तुम्हाला अवलंबित्व देखील कॅशे करायचे असेल, तर वर्ग असा दिसला पाहिजे:

@Entity
@Table(name = "employee")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Employee {
    @Id
    private Integer id;

   @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
   private Set<Task> tasks;
}

आणि शेवटचा तपशील - द्वितीय-स्तरीय कॅशेमधून वाचन तेव्हाच होते जेव्हा इच्छित ऑब्जेक्ट प्रथम-स्तरीय कॅशेमध्ये सापडला नाही.

कॅशेमोड

हायबरनेट अतिशय लवचिक कॅशिंग व्यवस्थापनास अनुमती देते. तुम्ही प्रत्येक वैयक्तिक सत्रासाठी किंवा प्रत्येक डेटाबेस विनंतीसाठी कॅशे मोड सेट करू शकता.

असे पाच मोड आहेत:

• मिळवा
• दुर्लक्ष करा
• सामान्य
• पुट
• रिफ्रेश करा

खालील तक्ता त्यांच्या कार्याचे वर्णन करते:

सत्रासाठी कॅशे मोड सेट करण्याचे उदाहरण:

session.setCacheMode(CacheMode.GET);
Employee director = session.createQuery("from Employee where id = 4").uniqueResult();

आणि सत्र आणि विनंतीसाठी मोड सेट करण्याचे उदाहरण देखील:

session.setCacheMode(CacheMode.GET);
Query query = session.createQuery("from Employee where id = 4");
query.setCacheMode(CacheMode.IGNORE); // Ignore cache work for this request
Employee director = query.uniqueResult();