मैं आपको नमस्कार करता हूं, हेब्र!
यह लेख उन लोगों के लिए उपयोगी होगा जिन्होंने पहले ही जावा सीखना शुरू कर दिया है और यहां तक कि जावा कोर को समझने में कुछ सफलता हासिल करने में कामयाब रहे, और अब मैंने स्प्रिंग शब्द सुना। और, शायद, एक बार भी नहीं: स्प्रिंग फ्रेमवर्क का ज्ञान, कम से कम, जावेदों के लिए कई रिक्तियों के विवरण में दिखाई देता है। यह लेख आपको पहले चरण पर चढ़ने में मदद करेगा: ऐसे लोकप्रिय ढांचे के सामान्य विचार को समझने के लिए।
दूर से शुरू करते हैं। नियंत्रण की एक ऐसी चीज है, जैसा कि नियंत्रण में, रूसी में - नियंत्रण का व्युत्क्रम, संक्षिप्त रूप में - IoC। IoC उन सिद्धांतों में से एक है जो हमारे कोड को ढीलेपन के करीब लाता है। आईओसी बाहरी घटकों के लिए हमारी जिम्मेदारियों के हिस्से का प्रतिनिधिमंडल है।
आईओसी दृष्टिकोण के विभिन्न कार्यान्वयन हैं, हम उनमें से एक में रुचि रखते हैं - निर्भरता इंजेक्शन, निर्भरता इंजेक्शन। यह क्या है, नाम खुद के लिए बोलता है, इसलिए मैं एक उदाहरण का उपयोग करके इसका खुलासा करने की कोशिश करूंगा। हम एक एप्लिकेशन लिख रहे हैं जो स्टोर की एक श्रृंखला के संचालन को स्वचालित करता है। क्लासेस शॉप (स्टोर) और सेलर (विक्रेता) हैं। क्लास सेलर के पास टाइप शॉप का एक क्षेत्र है - वह स्टोर जिसमें विक्रेता काम करता है। तो हमें लत से सामना करना पड़ता है: विक्रेता दुकान पर निर्भर है। अब चलिए इस बारे में सोचते हैं कि Shop ऑब्जेक्ट ऑब्जेक्ट में कैसे मिलता है? विकल्प हैं:
- विक्रेता के माध्यम से इसे लागू करें और तुरंत, विक्रेता को बनाते समय, उस स्टोर को निर्दिष्ट करें जिसमें वह काम करता है:
public class Seller { private Shop shop; public Seller(Shop shop) { this.shop = shop; } }
- एक सेटर बनाएँ और, उसकी कॉल का उपयोग करके, विक्रेता के लिए स्टोर सेट करें:
public class Seller { private Shop shop; public void setShop(Shop shop) { this.shop = shop; } }
सूचीबद्ध दो विधियां निर्भरता इंजेक्शन का कार्यान्वयन हैं। और अंत में, हम वसंत में आ गए: यह निर्भरता को इंजेक्ट करने का एक और तरीका प्रदान करता है।
आमतौर पर, वसंत कई अवसरों के लिए पुस्तकालयों की एक बहुत विस्तृत श्रृंखला है। जल्दी से वेब एप्लिकेशन बनाने के लिए स्प्रिंग एमवीसी है, और एप्लिकेशन में प्राधिकरण को लागू करने के लिए स्प्रिंग सिक्योरिटी, और डेटाबेस के साथ काम करने के लिए स्प्रिंग डेटा और भी बहुत कुछ। लेकिन स्प्रिंग आईओसी अकेला खड़ा है - यह वसंत का मूल प्रकार है जो हम जिस विषय का अध्ययन कर रहे हैं उसे लागू करते हैं - निर्भरता इंजेक्शन। स्प्रिंग आईओसी एक अन्य कारण से वसंत पुस्तकालयों के अध्ययन की शुरुआत में ध्यान देने योग्य है। जैसा कि आप अन्य प्रकार के वसंत के साथ व्यावहारिक कार्य की प्रक्रिया में देखेंगे, अन्य सभी स्प्रिंग्स के लिए स्प्रिंग आईओसी का उपयोग एक रूपरेखा के रूप में किया जाता है।
हम वसंत IoC के लिए अपना परिचय मुख्य शब्द: सेम के साथ शुरू करेंगे। सबसे सरल शब्दों में
बीन स्प्रिंग द्वारा बनाई गई एक क्लास ऑब्जेक्ट है जिसे फील्ड वैल्यू के रूप में किसी अन्य ऑब्जेक्ट में एम्बेड किया जा सकता है।
क्या आप अधिक जटिल शब्द चाहते हैं? और कृपया:
बीन एक क्लास ऑब्जेक्ट है, जो एक विशिष्ट व्यावसायिक फ़ंक्शन या आंतरिक स्प्रिंग फ़ंक्शन के साथ एक संपूर्ण कार्यक्रम तत्व है, जिसका जीवन चक्र बिन कंटेनर द्वारा नियंत्रित किया जाता है।
जैसा कि आप पहले से ही समझ चुके हैं, शॉप के लिए शॉप को लागू करने में सक्षम होने के लिए, शॉप को एक बिन बनना चाहिए। एप्लिकेशन को यह बताने के कई तरीके हैं कि किन वस्तुओं को सेम कहलाने का गौरवपूर्ण अधिकार है, ये सभी हमें ApplicationChtext की अवधारणा की ओर ले जाते हैं।
ApplicationContext वसंत का दिल है। एक नियम के रूप में, यह एप्लिकेशन ("उगता है") की शुरुआत में बनाया जाता है और बीन्स के जीवन चक्र को नियंत्रित करता है। इसलिए, इसे बिन कंटेनर भी कहा जाता है।
हम मुख्य बात पर पहुंच रहे हैं। हमें अपनी कक्षाओं को फिर से लिखने की क्या ज़रूरत है ताकि स्प्रिंग IoC और उसके ApplicationContext नौकर को विक्रेता वस्तु के लिए शॉप फ़ील्ड स्थानापन्न कर दें? इस तरह:
@Component public class Shop { }
@Component public class Seller { @Autowired private Shop shop; }
क्या यह सरल है? बहुत आसान! सुंदर ढंग से? यह है। यहाँ निम्नलिखित हुआ: घटक एनोटेशन ने स्प्रिंग को बताया कि जिस वर्ग ने एनोटेट किया वह एक बिन है। एनोटेशन ऑटोवार्ड ने स्प्रिंग को उस क्षेत्र में एक मूल्य का विकल्प देने के लिए कहा जिसे वह एनोटेट करता है। इस ऑपरेशन को इंजेक्शन कहा जाता है। क्या सही मूल्य प्रतिस्थापित किया जाएगा? इसके बारे में और बाद में, पहले, हम यह पता लगाएंगे कि सामान्य रूप से कक्षाएं कैसे बन जाती हैं।
हम पहले से ही जानते हैं कि आवेदन की शुरुआत में, सभी ApplicationContext सेम के संरक्षक को उठना होगा। वह एक ही बार में सभी डिब्बे बनाता है। लगभग सब कुछ। तथ्य यह है कि डिफ़ॉल्ट रूप से, किसी भी बीन का मूल्य सिंगलटन में इंट्रास्प्रेसिंग संपत्ति का दायरा होता है। Intraspringovoe, शब्द के शाब्दिक अर्थ में चूंकि वह एक एकल नहीं है। यह वसंत के लिए सिंगलटन है: जब संदर्भ उठाया जाता है, तो वसंत निर्दिष्ट वर्ग से बिल्कुल एक बिन ऑब्जेक्ट बनाएगा। यदि आप इस व्यवहार को बदलना चाहते हैं - कृपया, स्प्रिंग आपको बीन के निर्माण समय और उनकी संख्या को एक वर्ग के लिए नियंत्रित करने की अनुमति देता है, लेकिन अब इस बारे में नहीं है।
इसलिए, ApplicationContext को बढ़ाते समय सभी डिब्बे बनाए जाते हैं। आइए पता करें कि संदर्भ कहाँ रहता है और सबसे महत्वपूर्ण बात: यह कैसे निर्धारित करता है कि किन वर्गों से डिब्बे बनाने हैं। सरलता के लिए कई विकल्प हैं, हम उनमें से एक के बारे में बात करेंगे: एक्सएमएल फ़ाइल का उपयोग करके कॉन्फ़िगरेशन। इसका एक उदाहरण इस प्रकार है:
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:beans="http://www.springframework.org/schema/c" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <bean id="product" class="main.java.Product"></bean> <context:component-scan base-package="main"/> </beans>
यह फ़ाइल प्रदर्शित करती है कि सेम को दो तरीकों से कैसे बनाया जाए। पहले वाले का कहना है कि यह मैनुअल है। आप देखते हैं, कक्षा के एक संकेत के साथ एक
बीन टैग है। यह बीन है।
बीन टैग के साथ इस फाइल में पंजीकृत हर चीज से
बीन्स बनाए जाएंगे।
दूसरा तरीका कम क्रिया है। याद रखें, कक्षाओं में हम घटक एनोटेशन डालते हैं। इस एनोटेशन के साथ एनोटेट किए गए सभी वर्गों में से, सेम बनाए जाएंगे। इस लाइन के लिए धन्यवाद xml फ़ाइल से:
<context:component-scan base-package="main"/>
वह वसंत से कहती है: पूरे मुख्य पैकेज को स्कैन करें और सभी से कि घटक एनोटेशन (या अन्य एनोटेशन जो घटक के घटक हैं) पर खड़े होंगे, डिब्बे बनाएँ। कॉम्पैक्ट, है ना? हम सिर्फ यह कहते हैं कि किन पैकेजों में वे वर्ग होते हैं जिनसे फलियाँ बनती हैं, और इन कक्षाओं को एनोटेट करते हैं।
आप कोड की निम्नलिखित लाइन के साथ xml फ़ाइल का उपयोग करके संदर्भ बढ़ा सकते हैं:
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
जहाँ सेम। xml ऊपर उल्लिखित xml उपनाम का पथ है।
सेम के निर्माण के साथ पता लगा। विक्रेता बनाते समय स्प्रिंग शॉप को कैसे भरता है? संदर्भ उठाते समय, क्लास शॉप का एक बिन ऑब्जेक्ट बनाया जाता है। विक्रेता वर्ग का एक बिन ऑब्जेक्ट भी बनाया गया है; यह भी घटक द्वारा एनोटेट किया गया है। यह एक दुकान प्रकार है जो ऑटोवार्ड द्वारा एनोटेट किया गया है। ऑटोवेड एनोटेशन वसंत को बताता है: आपको इस क्षेत्र में बिन को इंजेक्ट करने की आवश्यकता है। हमारे मामले में, हमारे पास इस भूमिका के लिए केवल एक बिन उपयुक्त है, जो कि किस प्रकार के क्षेत्र से मेल खाता है: यह एक बिन - शॉप क्लास का एक उदाहरण है। आवश्यकतानुसार सेलर ऑब्जेक्ट में इसे इंजेक्ट किया जाएगा। मैं समझता हूं कि अब प्रश्न कीड़े की तरह चढ़ गए हैं: क्या होगा यदि स्प्रिंग वांछित बीन नहीं ढूंढता है, या कुछ उपयुक्त पाता है (विशेष रूप से यह विचार करते हुए कि आप इंटरफ़ेस के माध्यम से भी इंजेक्ट कर सकते हैं, और वर्ग द्वारा नहीं)। वसंत स्मार्ट है, लेकिन इसके लिए हमें उसी की आवश्यकता है। हमें या तो सिस्टम में एक बीन की आवश्यकता है जो प्रत्येक ऑटोवार्ड के लिए उपयुक्त है, या स्प्रिंग को इस तरह के संघर्षों में कार्य करने के लिए प्रशिक्षित करने के लिए (हम अब इस बारे में बात नहीं करते हैं, आप पहले से ही थक चुके हैं, अपने आप को तेज करें, लेख समाप्त हो रहा है)।
ध्यान दें कि सेलर भी एक बिन है। यदि यह एक बिन नहीं था, लेकिन नए के माध्यम से बनाया गया था, तो कुछ भी स्वचालित रूप से इसमें इंजेक्ट नहीं होगा।
शायद अब आप सोच रहे हैं कि ये सभी कठिनाइयां क्यों आवश्यक हैं। लेकिन कल्पना करें कि हमारा आवेदन 2 वर्गों का नहीं है, लेकिन परिमाण के बड़े और निर्भरता प्रबंधन के कई आदेश अब सबसे तुच्छ कार्य नहीं हैं।
शायद अब आप सोचते हैं कि वसंत कितना सुंदर, सरल और संक्षिप्त है जो आपको निर्भरता को लागू करने की अनुमति देता है। लेकिन कल्पना करें कि कुछ गलत हुआ और आपको एप्लिकेशन को डीबग करना होगा। और यह इतना आसान नहीं है ...
अंत में, संकेत के एक जोड़े:
- यदि आपने परियोजना को लागू किया है और अब नुकसान में हैं कि इसे देखने के लिए वसंत से बिन कैसे प्राप्त करें, तो यह करें:
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); Seller seller = (Seller) context.getBean(Seller.class);
यह बिन पाने का एक कानूनी तरीका है, हालांकि आधुनिक वास्तविकताओं में यह आमतौर पर नहीं किया जाता है। लेकिन एक केस स्टडी के लिए आप कर सकते हैं।
- चूंकि वसंत एक ढांचा है, इसलिए आपको इसे अपनी परियोजना में शामिल करने की आवश्यकता है। मैं मावेन का उपयोग करके एक एप्लिकेशन बनाता हूं और स्प्रिंग-कोर और स्प्रिंग-संदर्भ निर्भरता को pom.xml फ़ाइल में जोड़ता हूं।
स्प्रिंग IoC में बीन्स को बनाने, कॉन्फ़िगर करने और इंजेक्शन लगाने के जबरदस्त अवसर हैं। हमने हिमखंड की नोक के एक छोटे से हिस्से की जांच की, जो वसंत के साथ काम करने के तरीकों में से एक है, लेकिन मुझे आशा है कि हम इस पर एक तीव्र नज़र रखने में सक्षम थे और जो हो रहा है उसका एक सामान्य विचार प्राप्त कर सकते हैं।