@Transactional में अलगाव और प्रसार पैरामीटर

स्प्रिंग के @Transactional एनोटेशन में, दो महत्वपूर्ण पैरामीटर डेटाबेस लेनदेन के व्यवहार को परिभाषित करते हैं: अलगाव और प्रसार . यह लेख बताता है कि कब और क्यों आपको उनके डिफ़ॉल्ट मानों को समायोजित करने पर विचार करना चाहिए।

प्रचार

प्रचार परिभाषित करता है कि लेनदेन एक दूसरे से कैसे संबंधित हैं। सामान्य विकल्पों में शामिल हैं:

• आवश्यक: किसी मौजूदा लेनदेन के भीतर कोड चलाता है या यदि कोई मौजूद नहीं है तो एक नया बनाता है।
• REQUIRES_NEW: किसी भी मौजूदा लेन-देन को निलंबित करते हुए हमेशा एक नया लेन-देन बनाता है।

डिफ़ॉल्ट मूल्य: आवश्यक

अलगाव

अलगाव लेनदेन के बीच डेटा अनुबंध को परिभाषित करता है। यह अन्य लेनदेन द्वारा किए गए डेटा परिवर्तनों में दृश्यता के स्तर को निर्दिष्ट करके कुछ डेटा विसंगतियों को रोकता है। प्रमुख अलगाव स्तर हैं:

• READ_UNCOMMITTED: गंदे पढ़ने के खिलाफ कोई सुरक्षा नहीं।
• Serializable: सबसे मजबूत अलगाव, कोई डेटा टकराव सुनिश्चित नहीं करना।

डिफ़ॉल्ट मान: के आधार पर भिन्न होता है डेटाबेस (उदाहरण के लिए, MariaDB के लिए REPEATABLE_READ)

वास्तविक दुनिया का उदाहरण

गंदी रीड के मुद्दे पर विचार करें, जहां एक लेनदेन किसी अन्य लेनदेन द्वारा किए गए अप्रतिबद्ध परिवर्तनों को पढ़ सकता है। &&&]

थ्रेड 1 थ्रेड 2 | | लिखें(x) | | | | पढ़ें(x) | | रोलबैक | | | मान (x) अब गंदा (गलत) है

                                       Thread 1          Thread 2
                                               |              |
                                             Write(x)           |
                                               |              |
                                               |             Read(x)
                                               |              |
                                             Rollback           |
                                                 |             |
                                                   Value (x) is now dirty (incorrect)

इस परिदृश्य में, गंदे पढ़ने को रोकने के लिए, आप अलगाव स्तर को

READ_COMMITTED और प्रसार स्तर को आवश्यक. यह संयोजन सुनिश्चित करता है कि लेन-देन केवल वही डेटा पढ़ता है जो अन्य लेन-देन द्वारा किया गया है। हमेशा एक नए लेन-देन के अंतर्गत चलता है, यह सुनिश्चित करते हुए कि अन्य समवर्ती कार्यों द्वारा किया गया कोई भी परिवर्तन इसमें हस्तक्षेप नहीं करता है निष्पादन:

@Transactional(प्रसार=प्रचार.REQUIRES_NEW) सार्वजनिक शून्य प्रदान सेवा() { रेपो1.retrieveFoo(); रेपो2.retrieveFoo(); }

लेनदेन व्यवहार का परीक्षण

विभिन्न प्रसार स्तरों के व्यवहार को सत्यापित करने के लिए, आप जावा परीक्षण का उपयोग कर सकते हैं:

@Transactional(propagation=Propagation.REQUIRES_NEW)
public void provideService() {
    repo1.retrieveFoo();
    repo2.retrieveFoo();
}

REQUIRES_NEW के साथ,

fooService.provideService()

को वापस नहीं लिया जाएगा क्योंकि यह एक अलग लेनदेन के भीतर संचालित होता है।

आवश्यक

 के साथ, सब कुछ वापस ले लिया जाएगा।