स्क्रैच से स्प्रिंग फ्रेमवर्क एपीआई को लागू करना। शुरुआती के लिए वॉकथ्रू। भाग 1

स्प्रिंग फ्रेमवर्क समझने और सीखने के लिए सबसे जटिल रूपरेखाओं में से एक है। अधिकांश डेवलपर्स इसे व्यावहारिक कार्यों और Google के माध्यम से धीरे-धीरे सीखते हैं। यह दृष्टिकोण प्रभावी नहीं है, क्योंकि यह पूरी तस्वीर नहीं देता है और साथ ही यह महंगा है।

मैं आपको स्प्रिंग के अध्ययन के लिए मौलिक रूप से नए दृष्टिकोण की पेशकश करना चाहूंगा। यह इस तथ्य में शामिल है कि एक व्यक्ति विशेष रूप से तैयार किए गए ट्यूटोरियल की एक श्रृंखला के माध्यम से जाता है और स्वतंत्र रूप से वसंत के कार्यात्मक को लागू करता है। इस दृष्टिकोण की ख़ासियत यह है कि, वसंत के अध्ययन किए गए पहलुओं की 100% समझ के अलावा, यह जावा कोर (एनोटेशन, रिफ्लेक्शन, फाइल्स, जेनरिक) में भी बड़ी वृद्धि देता है।

लेख आपको एक अविस्मरणीय अनुभव देगा और आपको एक निर्णायक डेवलपर की तरह महसूस कराएगा। कदम से कदम, आप अपनी कक्षाओं को सेम बनाएंगे और उनके जीवन चक्र (एक वास्तविक वसंत में उसी तरह) को व्यवस्थित करेंगे। आपके द्वारा कार्यान्वित की जाने वाली कक्षाएं बीनफैक्टरी , कंपोनेंट , सर्विस , बीनपोस्टप्रोसेसर , बीननामवेयर , बीनफैक्टरीवेयर , इनिशियलाइज़िंग बीन , पोस्टकंस्ट्रक्ट , प्रीडेस्ट्रॉय , डिस्पोजेबल बीन , ऐप्लीकेशनटेक्स्ट , एप्लिकेशनलीस्टनर , कॉनटेक्स्टडोजेंट हैं ।

थोड़ा अपने बारे में

मेरा नाम यारोस्लाव है और मैं 4 साल के अनुभव के साथ जावा डेवलपर हूं। फिलहाल मैं ईपीएएम सिस्टम्स (एसपीबी) के लिए काम करता हूं, और मैं उन तकनीकों में गहराई से तल्लीन हूं जो हम उपयोग करते हैं। अक्सर मुझे वसंत से निपटना पड़ता है, और मैं इसमें कुछ बीच का मैदान देखता हूं जिसमें आप बढ़ सकते हैं (जावा हर कोई इतनी अच्छी तरह से जानता है, और बहुत विशिष्ट उपकरण और प्रौद्योगिकियां भी आ सकती हैं और जा सकती हैं)।

कुछ महीने पहले, मैंने स्प्रिंग प्रोफेशनल v5.0 सर्टिफिकेशन (कोर्स न लेकर) पास किया। उसके बाद, मैंने सोचा कि कैसे दूसरे लोगों को बसंत सिखाया जाए। दुर्भाग्य से, इस समय कोई प्रभावी शिक्षण पद्धति नहीं है। अधिकांश डेवलपर्स के पास रूपरेखा और इसकी विशेषताओं का बहुत सतही विचार है। वसंत स्रोतों को डीबग करना बहुत मुश्किल है और प्रशिक्षण के दृष्टिकोण से बिल्कुल प्रभावी नहीं है (मैं किसी भी तरह से इस पर शौकीन था)। 10 प्रोजेक्ट करें? हां, कहीं न कहीं आप अपने ज्ञान को गहरा कर सकते हैं और व्यावहारिक अनुभव प्राप्त कर सकते हैं, लेकिन "हुड के नीचे" का बहुत कुछ आपके सामने कभी नहीं खुलेगा। पढ़ें एक्शन में वसंत? शांत, लेकिन प्रयास में महंगा। मैंने इसे 40% काम किया है (प्रमाणन के लिए तैयारी के दौरान), लेकिन यह आसान नहीं था।

किसी चीज़ को अंत तक समझने का एकमात्र तरीका उसे स्वयं विकसित करना है। हाल ही में, मेरे पास यह विचार था कि आप एक दिलचस्प ट्यूटोरियल के माध्यम से किसी व्यक्ति का नेतृत्व कर सकते हैं जो इसके डीआई ढांचे के विकास की देखरेख करेगा। इसकी मुख्य विशेषता यह होगी कि एपीआई का अध्ययन होने वाले एपीआई के साथ होगा। इस दृष्टिकोण की अजीबता यह है कि वसंत की गहरी (बिना रिक्त स्थान) समझ के, एक व्यक्ति को जावा कोर में एक बड़ी मात्रा में अनुभव मिलेगा। सच कहूं, तो मैंने स्वयं लेख की तैयारी के दौरान वसंत और जावा कोर दोनों पर बहुत सी नई चीजें सीखीं। चलो विकसित करना शुरू करें!

खरोंच से परियोजना

तो, पहली बात यह है कि अपनी पसंदीदा आईडीई खोलें और खरोंच से एक परियोजना बनाएं। हम किसी भी मावेन या किसी तीसरे पक्ष के पुस्तकालयों से नहीं जुड़ेंगे। हम वसंत निर्भरता को भी नहीं जोड़ेंगे। हमारा लक्ष्य एक एपीआई विकसित करना है जो स्प्रिंग एपीआई के समान है, और इसे स्वयं लागू करें।

एक स्वच्छ परियोजना में, 2 मुख्य पैकेज बनाएं। पहला पैकेज आपके एप्लिकेशन ( com.kciray ), और इसके अंदर Main.java वर्ग है। दूसरा पैकेज org.springframework है। हां, हम मूल स्प्रिंग की पैकेज संरचना, उसकी कक्षाओं और उनके तरीकों के नाम की नकल करेंगे। इस तरह का एक दिलचस्प प्रभाव है - जब आप अपना खुद का कुछ बनाते हैं, तो आपका अपना सरल और समझ में आने लगता है। फिर, जब आप बड़ी परियोजनाओं में काम करते हैं, तो यह आपको प्रतीत होगा कि वहां सब कुछ आपके वर्कपीस के आधार पर बनाया गया है। यह दृष्टिकोण सिस्टम को समग्र रूप से समझने, उसमें सुधार करने, बग्स को ठीक करने, समस्याओं को हल करने, इत्यादि पर बहुत सकारात्मक प्रभाव डाल सकता है।

यदि आपको कोई समस्या है, तो आप यहां एक काम कर सकते हैं ।

एक कंटेनर बनाएँ

आरंभ करने के लिए, कार्य सेट करें। मान लीजिए कि हमारे पास 2 वर्ग हैं - ProductFacade और PromotionService । अब कल्पना करें कि आप इन वर्गों को एक-दूसरे से जोड़ना चाहते हैं, लेकिन इतना कि कक्षाएं स्वयं एक-दूसरे (पैटर्न DI) के बारे में नहीं जानते हैं। हमें एक अलग वर्ग की आवश्यकता है जो इन सभी वर्गों का प्रबंधन करेगा और उनके बीच निर्भरता का निर्धारण करेगा। चलो इसे एक कंटेनर कहते हैं। चलो Container वर्ग बनाएँ ... हालांकि नहीं, रुको! वसंत में एक भी कंटेनर वर्ग नहीं है। हमारे पास कई कंटेनर कार्यान्वयन हैं, और इन सभी कार्यान्वयनों को 2 प्रकारों - बिन कारखानों और संदर्भों में विभाजित किया जा सकता है। बिन कारखाना सेम बनाता है और उन्हें एक साथ जोड़ता है (निर्भरता इंजेक्शन, डीआई), और संदर्भ उसी के बारे में करता है, साथ ही यह कुछ अतिरिक्त सुविधाओं को जोड़ता है (उदाहरण के लिए, संदेशों का अंतर्राष्ट्रीयकरण)। लेकिन हमें अब इन अतिरिक्त कार्यों की आवश्यकता नहीं है, इसलिए हम बिन कारखाने के साथ काम करेंगे।

एक नया BeanFactory क्लास बनाएं और इसे BeanFactory पैकेज में डालें। इस क्लास के अंदर Map<String, Object> singletons स्टोर Map<String, Object> singletons जाता है, जिसमें बिन की id को बिन में ही मैप किया जाता है। इसमें Object getBean(String beanName) विधि जोड़ें, जो पहचानकर्ता द्वारा सेम को खींचता है।

 public class BeanFactory { private Map<String, Object> singletons = new HashMap(); public Object getBean(String beanName){ return singletons.get(beanName); } } 

कृपया ध्यान दें कि BeanFactory और FactoryBean दो अलग चीजें हैं। पहला बिन कारखाना (कंटेनर) है, और दूसरा बिन कारखाना है, जो कंटेनर के अंदर बैठता है और डिब्बे का उत्पादन भी करता है। फैक्ट्री के अंदर फैक्ट्री। यदि आप इन परिभाषाओं के बीच भ्रमित हैं, तो आपको याद हो सकता है कि अंग्रेजी में दूसरी संज्ञा अग्रणी है, और पहला एक विशेषण जैसा है। बीन फैक्ट्री में, मुख्य शब्द फैक्ट्री है, और फैक्ट्री बीन में बीन है।

अब, ProductService और PromotionsService कक्षाएं बनाएँ। ProductService डेटाबेस से उत्पाद लौटाएगा, लेकिन इससे पहले आपको यह जांचना होगा कि क्या इस उत्पाद पर कोई छूट (प्रचार) लागू होती है। ई-कॉमर्स में, रियायती कार्य को अक्सर एक अलग सेवा वर्ग (और कभी-कभी तृतीय-पक्ष वेब सेवा) को आवंटित किया जाता है।

 public class PromotionsService { } public class ProductService { private PromotionsService promotionsService; public PromotionsService getPromotionsService() { return promotionsService; } public void setPromotionsService(PromotionsService promotionsService) { this.promotionsService = promotionsService; } } 

अब हमें अपने कंटेनर ( BeanFactory ) को हमारी कक्षाओं का पता लगाने, उन्हें हमारे लिए बनाने और एक को दूसरे में इंजेक्ट करने की आवश्यकता है। new ProductService() तरह संचालन कंटेनर के अंदर स्थित होना चाहिए और डेवलपर के लिए किया जाना चाहिए। आइए सबसे आधुनिक दृष्टिकोण (कक्षा स्कैनिंग और एनोटेशन) का उपयोग करें। ऐसा करने के लिए, हमें @Component ( @Component org.springframework.beans.factory.stereotype ) के साथ @Component एनोटेशन बनाने की आवश्यकता है।

 @Retention(RetentionPolicy.RUNTIME) public @interface Component { } 

डिफ़ॉल्ट रूप से, एनोटेशन को मेमोरी में लोड नहीं किया जाता है जबकि प्रोग्राम चल रहा है ( RetentionPolicy.CLASS )। हमने एक नई अवधारण नीति ( RetentionPolicy.RUNTIME ) के माध्यम से इस व्यवहार को बदल दिया।

अब ProductService क्लासेज से पहले और @Component से पहले @Component जोड़ें।

 @Component public class ProductService { //... } @Component public class PromotionService { //... } 

हमें अपने पैकेज ( com.kciray ) BeanFactory स्कैन करने और इसमें उन कक्षाओं को खोजने की आवश्यकता है जो @Component द्वारा एनोटेट किए @Component । यह कार्य तुच्छ से दूर है। जावा कोर में कोई तैयार समाधान नहीं है , और हमें खुद एक बैसाखी बनाना होगा। इस बैसाखी के माध्यम से हजारों वसंत अनुप्रयोग घटक स्कैनिंग का उपयोग करते हैं। भयानक सत्य आपने जान लिया है। आपको ClassLoader से ClassLoader नाम निकालने ClassLoader और जांचना होगा ClassLoader वे ".class" के साथ समाप्त होते हैं या नहीं, और फिर उनका पूरा नाम बनाएँ और उसमें से क्लास ऑब्जेक्ट निकाल दें!

मैं आपको तुरंत चेतावनी देना चाहता हूं कि कई जाँच अपवाद होंगे, इसलिए उन्हें लपेटने के लिए तैयार रहें। लेकिन पहले, हम तय करना चाहते हैं कि हम क्या चाहते हैं। हम BeanFactory एक विशेष विधि जोड़ना चाहते हैं और इसे Main में कॉल करना चाहते हैं:

 //BeanFactory.java public class BeanFactory{ public void instantiate(String basePackage) { } } //Main.java BeanFactory beanFactory = new BeanFactory(); beanFactory.instantiate("com.kciray"); 

इसके बाद, हमें ClassLoader प्राप्त करने की आवश्यकता है। यह लोडिंग कक्षाओं के लिए जिम्मेदार है, और इसे काफी सरलता से निकाला जाता है:

 ClassLoader classLoader = ClassLoader.getSystemClassLoader(); 

आपने शायद पहले ही देखा है कि संकुल को एक बिंदु और एक स्लैश द्वारा फाइलों को अलग किया जाता है। हमें बैच पथ को फ़ोल्डर पथ में बदलने की आवश्यकता है, और List<URL> (आपके फ़ाइल सिस्टम में पथ जहाँ आप वर्ग फ़ाइलों की खोज कर सकते हैं) जैसी कुछ प्राप्त कर सकते हैं।

 String path = basePackage.replace('.', '/'); //"com.kciray" -> "com/kciray" Enumeration<URL> resources = classLoader.getResources(path); 

तो एक पल रुकिए! Enumeration<URL> List<URL> । यह सब क्या है? ओह, हॉरर, यह Iterator का पुराना पूर्वज है, जावा 1.0 के बाद से उपलब्ध है। यह वह विरासत है जिससे हमें निपटना है। यदि (सभी संग्रह इसे लागू करते हैं) का उपयोग करके Iterable माध्यम से चलना संभव है, तो Enumeration के मामले में आपको बाईपास करना होगा, while(resources.hasMoreElements()) और nextElement() । और फिर भी संग्रह से आइटम निकालने का कोई तरीका नहीं है। केवल 1996, केवल कट्टर। अरे हाँ, जावा 9 में उन्होंने Enumeration.asIterator() विधि जोड़ी है, इसलिए आप इसके माध्यम से काम कर सकते हैं।

आगे चलते हैं। हमें फ़ोल्डरों को निकालने और उनमें से प्रत्येक की सामग्री के माध्यम से काम करने की आवश्यकता है। URL को फ़ाइल में कनवर्ट करें, और फिर उसका नाम प्राप्त करें। यहां यह ध्यान दिया जाना चाहिए कि हम नेस्टेड पैकेज को स्कैन नहीं करेंगे ताकि कोड को जटिल न करें। यदि आप चाहें तो आप अपने कार्य को जटिल बना सकते हैं और पुनरावृत्ति कर सकते हैं।

 while (resources.hasMoreElements()) { URL resource = resources.nextElement(); File file = new File(resource.toURI()); for(File classFile : file.listFiles()){ String fileName = classFile.getName();//ProductService.class } } 

अगला, हमें एक्सटेंशन के बिना फ़ाइल नाम प्राप्त करने की आवश्यकता है। 2018 में यार्ड में, जावा ने कई वर्षों के लिए फ़ाइल I / O (NIO 2) विकसित किया है, लेकिन अभी भी फ़ाइल नाम से विस्तार को अलग नहीं कर सकता है। मुझे अपनी बाइक खुद बनानी होगी, क्योंकि हमने अपाचे कॉमन्स जैसे तीसरे पक्ष के पुस्तकालयों का उपयोग नहीं करने का फैसला किया। चलो पुराने दादा रास्ते का उपयोग करें lastIndexOf(".") :

 if(fileName.endsWith(".class")){ String className = fileName.substring(0, fileName.lastIndexOf(".")); } 

अगला, हम कक्षा के पूर्ण नाम का उपयोग करके वर्ग वस्तु प्राप्त कर सकते हैं (इसके लिए हम कक्षा के वर्ग को कहते हैं):

 Class classObject = Class.forName(basePackage + "." + className); 

ठीक है, अब हमारी कक्षाएं हमारे हाथों में हैं। इसके अलावा, यह केवल उन लोगों को उजागर करना है जिनके पास @Component टिप्पणी है:

 if(classObject.isAnnotationPresent(Component.class)){ System.out.println("Component: " + classObject); } 

भागो और जांच करो। कंसोल कुछ इस तरह होना चाहिए:

 Component: class com.kciray.ProductService Component: class com.kciray.PromotionsService 

अब हमें अपने सेम बनाने की जरूरत है। आपको new ProductService() तरह कुछ करने की आवश्यकता है, लेकिन प्रत्येक बीन के लिए हमारे पास अपनी कक्षा है। जावा में प्रतिबिंब हमें एक सार्वभौमिक समाधान प्रदान करता है (डिफ़ॉल्ट निर्माता कहा जाता है):

 Object instance = classObject.newInstance();//=new CustomClass() 

इसके बाद, हमें इस बीन को Map<String, Object> singletons में डालना होगा। ऐसा करने के लिए, बीन नाम (इसकी आईडी) चुनें। जावा में, हम कक्षाओं की तरह चर कहते हैं (केवल पहला अक्षर लोअरकेस है)। इस दृष्टिकोण को सेम पर भी लागू किया जा सकता है, क्योंकि वसंत एक जावा फ्रेमवर्क है! बिन नाम परिवर्तित करें ताकि पहला अक्षर छोटा हो, और इसे मानचित्र में जोड़ें:

 String beanName = className.substring(0, 1).toLowerCase() + className.substring(1); singletons.put(beanName, instance); 

अब सुनिश्चित करें कि सब कुछ काम करता है। कंटेनर को सेम बनाना होगा, और उन्हें नाम से पुनर्प्राप्त किया जाना चाहिए। कृपया ध्यान दें कि आपके instantiate() का नाम instantiate() विधि और classObject.newInstance(); विधि का नाम है classObject.newInstance(); एक आम जड़ है। इसके अलावा, instantiate() बीन के जीवन चक्र का हिस्सा है। जावा में, सब कुछ आपस में जुड़ा हुआ है!

 //Main.java BeanFactory beanFactory = new BeanFactory(); beanFactory.instantiate("com.kciray"); ProductService productService = (ProductService) beanFactory.getBean("productService"); System.out.println(productService);//ProductService@612 

org.springframework.beans.factory.stereotype.Service एनोटेशन को लागू करने का भी प्रयास करें। यह @Component के समान कार्य करता है, लेकिन इसे अलग तरह से कहा जाता है। पूरा बिंदु नाम में है - आप प्रदर्शित करते हैं कि कक्षा एक सेवा है, न कि केवल एक घटक। यह वैचारिक टाइपिंग जैसा कुछ है। वसंत प्रमाणीकरण में एक सवाल था "क्या एनोटेशन टकसाली हैं?" (सूचीबद्ध लोगों में से) तो, स्टीरियोटाइपिकल एनोटेशन वे हैं जो stereotype पैकेज में हैं।

गुण भरें

नीचे दिए गए आरेख को देखें, यह सेम के जीवन चक्र की शुरुआत को दर्शाता है। इससे पहले हमने जो किया वह इंस्टेंटिएट ( newInstance() माध्यम से सेम बनाना) है। अगला चरण सेम का क्रॉस-इंजेक्शन है (निर्भरता इंजेक्शन, यह नियंत्रण का उलटा भी है (IoC))। आपको सेम के गुणों के माध्यम से जाने और समझने की ज़रूरत है कि आपको कौन से गुणों को इंजेक्ट करने की आवश्यकता है। यदि आप productService.getPromotionsService() कॉल करते productService.getPromotionsService() , तो आपको null हो जाएगा, क्योंकि निर्भरता अभी तक नहीं जोड़ा गया है।



सबसे पहले, @Autowired पैकेज बनाएं और इसमें @Autowired एनोटेशन जोड़ें। विचार उन क्षेत्रों को चिह्नित करने का है जो इस एनोटेशन के साथ निर्भरताएं हैं।

 @Retention(RetentionPolicy.RUNTIME) public @interface Autowired { } 

इसके बाद, इसे संपत्ति में जोड़ें:

 @Component public class ProductService { @Autowired PromotionsService promotionsService; //... } 

अब हमें इन एनोटेशन BeanFactory खोजने और उन पर निर्भरता को इंजेक्ट करने के लिए हमारे BeanFactory को सिखाना होगा। इसके लिए एक अलग विधि जोड़ें, और इसे Main से कॉल करें:

 public class BeanFactory { //... public void populateProperties(){ System.out.println("==populateProperties=="); } } 

इसके बाद, हमें बस अपने सभी डिब्बे object.getClass().getDeclaredFields() मैप में जाने की ज़रूरत है, और प्रत्येक बिन के लिए उसके सभी फ़ील्ड्स ( object.getClass().getDeclaredFields() निजी क्षेत्रों सहित सभी फ़ील्ड्स को लौटाता है। और जाँच करें कि क्या क्षेत्र में @Autowired एनोटेशन है:

 for (Object object : singletons.values()) { for (Field field : object.getClass().getDeclaredFields()) { if (field.isAnnotationPresent(Autowired.class)) { } } } 

अगला, हमें एक बार सभी डिब्बे से गुजरने और उनके प्रकार को देखने की आवश्यकता है - अचानक यह वह प्रकार है जिसे हमारा बिन खुद लेना चाहता है। हाँ, हमें एक त्रि-आयामी चक्र मिलता है!

 for (Object dependency : singletons.values()) { if (dependency.getClass().equals(field.getType())) { } } 

इसके अलावा, जब हमें इसकी लत लग गई, तो हमें इसे इंजेक्ट करने की आवश्यकता है। पहली चीज़ जो आप सोच सकते हैं, वह है सीधे सीधे परावर्तन का उपयोग करके promotionsService क्षेत्र लिखना। लेकिन वसंत ऐसा काम नहीं करता है। आखिरकार, यदि फ़ील्ड में एक private संशोधक है, तो हमें पहले इसे public रूप से सेट करना होगा, फिर अपना मान लिखना होगा, फिर इसे फिर से private (अखंडता बनाए रखने के लिए) सेट करना होगा। एक बड़ी बैसाखी की तरह लगता है। एक बड़ी बैसाखी के बजाय, हम एक छोटी सी बैसाखी बनाते हैं (हम सेटर का नाम बनाएंगे और उसे कॉल करेंगे):

 String setterName = "set" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);//setPromotionsService System.out.println("Setter name = " + setterName); Method setter = object.getClass().getMethod(setterName, dependency.getClass()); setter.invoke(object, dependency); 

अब अपना प्रोजेक्ट चलाएं और यह सुनिश्चित करें कि जब null बजाय productService.getPromotionsService() कॉल किया जाए, तो हमारी सेम वापस आ जाएगी।

हमने जो लागू किया है वह प्रकार द्वारा इंजेक्शन है। नाम ( javax.annotation.Resource एनोटेशन) द्वारा एक इंजेक्शन भी है। यह इस क्षेत्र में भिन्न होता है कि क्षेत्र के प्रकार के बजाय, इसका नाम निकाला जाएगा, और इसके अनुसार - नक्शे से निर्भरता। यहां सब कुछ समान है, यहां तक ​​कि कुछ सरल में भी। मेरा सुझाव है कि आप प्रयोग करें और अपना बीन बनाएँ, और फिर इसे @Resource से @Resource और populateProperties() विधि का विस्तार करें।

हम सेम का समर्थन करते हैं जो उनके नाम के बारे में जानते हैं

ऐसे समय होते हैं जब आपको बिन के अंदर उसका नाम प्राप्त करने की आवश्यकता होती है। ऐसी आवश्यकता अक्सर उत्पन्न नहीं होती है, क्योंकि डिब्बे, संक्षेप में, एक दूसरे के बारे में नहीं जानना चाहिए और यह कि वे डिब्बे हैं। वसंत के पहले संस्करणों में, यह मान लिया गया था कि बीन एक POJO (प्लेन ओल्ड जावा ओब्जेक, अच्छा पुराना जावा ऑब्जेक्ट) है, और संपूर्ण कॉन्फ़िगरेशन एक्सएमएल फ़ाइलों में प्रदान किया गया है और कार्यान्वयन से अलग हो गया है। लेकिन हम इस कार्यक्षमता को लागू करते हैं, क्योंकि नाम इंजेक्शन बिन के जीवन चक्र का हिस्सा है।

हम कैसे जानते हैं कि कौन सा सेम जानना चाहता है कि उसका नाम क्या है और वह क्या नहीं चाहता है? पहली बात जो दिमाग में आती है वह है @InjectName का नया एनोटेशन बनाना और उसे @InjectName क्षेत्र में लाना। लेकिन यह समाधान बहुत सामान्य होगा और आपको कई बार अपने आप को पैर में गोली मारने की अनुमति देगा (इस एनोटेशन को अनुचित प्रकार के क्षेत्रों पर रखें (स्ट्रिंग नहीं), या एक ही कक्षा में कई क्षेत्रों में नाम इंजेक्ट करने का प्रयास करें)। एक और समाधान है, अधिक सटीक - एक सेटर विधि के साथ एक विशेष इंटरफ़ेस बनाने के लिए। इसे लागू करने वाले सभी डिब्बे अपना नाम प्राप्त करते हैं। BeanNameAware पैकेज में BeanNameAware क्लास बनाएं:

 public interface BeanNameAware { void setBeanName(String name); } 

इसके बाद, हमारी PromotionsService इसे लागू करें:

 @Component public class PromotionsService implements BeanNameAware { private String beanName; @Override public void setBeanName(String name) { beanName = name; } public String getBeanName() { return beanName; } } 

और अंत में, बीन कारखाने में एक नई विधि जोड़ें। यहां सब कुछ सरल है - हम अपने बिन-सिंगलटन के माध्यम से जाते हैं, जांचें कि क्या बिन हमारे इंटरफ़ेस को लागू करता है, और सेटर को कॉल करें:

 public void injectBeanNames(){ for (String name : singletons.keySet()) { Object bean = singletons.get(name); if(bean instanceof BeanNameAware){ ((BeanNameAware) bean).setBeanName(name); } } } 

चलाएं और सुनिश्चित करें कि सब कुछ काम करता है:

 BeanFactory beanFactory = new BeanFactory(); beanFactory.instantiate("com.kciray"); beanFactory.populateProperties(); beanFactory.injectBeanNames(); //... System.out.println("Bean name = " + promotionsService.getBeanName()); 

यह ध्यान दिया जाना चाहिए कि वसंत में अन्य समान इंटरफेस हैं। मेरा सुझाव है कि आप बीनफैक्टिववेयर इंटरफ़ेस को स्वयं लागू करें , जो सेम को बीन कारखाने का लिंक प्राप्त करने की अनुमति देता है। यह एक समान तरीके से लागू किया जाता है।

प्रारंभिक बीन्स

कल्पना करें कि आपके पास एक स्थिति है जहां आपको निर्भरता के इंजेक्शन लगाने के बाद कुछ कोड निष्पादित करने की आवश्यकता है (बिन गुण सेट हैं)। सरल शब्दों में, हमें बिन को खुद को शुरू करने की क्षमता देने की आवश्यकता है। वैकल्पिक रूप से, हम एक InitializingBean इंटरफ़ेस बना सकते हैं, और इसमें void afterPropertiesSet() विधि के हस्ताक्षर डाल सकते हैं। इस तंत्र का क्रियान्वयन ठीक वैसा ही है जैसा कि BeanNameAware इंटरफेस के लिए प्रस्तुत किया गया है, इसलिए समाधान स्पॉइलर के नीचे है। अभ्यास करें और इसे एक मिनट में स्वयं करें:

पोस्ट प्रोसेसर जोड़ना

पहले वसंत डेवलपर्स के स्थान पर खुद की कल्पना करें। आपका फ्रेमवर्क बढ़ रहा है और डेवलपर्स के बीच बहुत लोकप्रिय है, हर दिन मेल में एक या अन्य उपयोगी सुविधा जोड़ने के अनुरोध के साथ पत्र भेजे जाते हैं। यदि ऐसी प्रत्येक सुविधा के लिए आप अपना स्वयं का इंटरफ़ेस जोड़ते हैं और इसे बीन के जीवन चक्र में जांचते हैं, तो यह (जीवन चक्र) अनावश्यक जानकारी से भरा हो जाएगा। इसके बजाय, हम एक सार्वभौमिक इंटरफ़ेस बना सकते हैं जो आपको कुछ तर्क जोड़ने की अनुमति देता है (बिल्कुल किसी भी, चाहे वह एनोटेशन के लिए जाँच कर रहा हो, बिन को दूसरे बिन के साथ बदलना, कुछ विशेष गुणों को सेट करना, और इसी तरह)।

आइए इस इंटरफ़ेस के लिए क्या है, इसके बारे में सोचें। इसे फलियों की कुछ पोस्ट प्रोसेसिंग करने की आवश्यकता होती है, इसलिए इसे बीनपोस्टप्रोसेसर कहा जा सकता है। लेकिन हमें एक कठिन सवाल का सामना करना पड़ता है - तर्क का पालन कब किया जाना चाहिए? आखिरकार, हम इसे आरंभीकरण से पहले निष्पादित कर सकते हैं, लेकिन हम इसे बाद में निष्पादित कर सकते हैं। कुछ कार्यों के लिए, पहला विकल्प बेहतर है, दूसरों के लिए - दूसरा ... कैसे हो?

हम एक ही बार में दोनों विकल्पों को सक्षम कर सकते हैं। एक पोस्ट-प्रोसेसर दो लॉजिक्स, दो तरीकों को ले जाने दें। एक को इनिशियलाइज़ेशन से पहले ( afterPropertiesSet() मेथड) से पहले और दूसरे को बाद में निष्पादित किया जाता है। अब आइए खुद ही तरीकों के बारे में सोचें - उनके पास क्या पैरामीटर होना चाहिए? जाहिर है, Object bean ही ( Object bean ) होनी चाहिए। सुविधा के लिए, बीन के अलावा, आप इस बीन का नाम पास कर सकते हैं। आपको याद है कि बिन खुद ही इसके नाम के बारे में नहीं जानता है। और हम बीननेमवेयर इंटरफेस को लागू करने के लिए सभी बीन्स को मजबूर नहीं करना चाहते हैं। लेकिन, पोस्ट-प्रोसेसर स्तर पर, बीन नाम बहुत उपयोगी हो सकता है। इसलिए, हम इसे दूसरे पैरामीटर के रूप में जोड़ते हैं।

और सेम प्रसंस्करण करते समय क्या विधि वापस आनी चाहिए? चलो इसे बिन वापस ही करते हैं। यह हमें सुपर-लचीलापन देता है, क्योंकि एक बिन के बजाय, आप एक प्रॉक्सी ऑब्जेक्ट को पर्ची कर सकते हैं जो इसकी कॉल को लपेटता है (और सुरक्षा जोड़ता है)। या आप फिर से बिन को दोबारा बनाकर किसी अन्य वस्तु को पूरी तरह से वापस कर सकते हैं। डेवलपर्स को कार्रवाई की बहुत बड़ी स्वतंत्रता दी जाती है। नीचे डिज़ाइन किया गया इंटरफ़ेस का अंतिम संस्करण है:

 package org.springframework.beans.factory.config; public interface BeanPostProcessor { Object postProcessBeforeInitialization(Object bean, String beanName); Object postProcessAfterInitialization(Object bean, String beanName); } 

अगला, हमें अपने बीन कारखाने में सरल प्रोसेसर की एक सूची और नए लोगों को जोड़ने की क्षमता जोड़ने की आवश्यकता है। हाँ, यह एक नियमित ArrayList है।

 //BeanFactory.java private List<BeanPostProcessor> postProcessors = new ArrayList<>(); public void addPostProcessor(BeanPostProcessor postProcessor){ postProcessors.add(postProcessor); } 

अब initializeBeans विधि को बदलें ताकि यह पोस्ट-प्रोसेसर्स को ध्यान में रखे:

 public void initializeBeans() { for (String name : singletons.keySet()) { Object bean = singletons.get(name); for (BeanPostProcessor postProcessor : postProcessors) { postProcessor.postProcessBeforeInitialization(bean, name); } if (bean instanceof InitializingBean) { ((InitializingBean) bean).afterPropertiesSet(); } for (BeanPostProcessor postProcessor : postProcessors) { postProcessor.postProcessAfterInitialization(bean, name); } } } 

आइए एक छोटा पोस्ट प्रोसेसर बनाएं जो कॉल को कंसोल में बताता है और इसे हमारे बीन कारखाने में जोड़ता है:

 public class CustomPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) { System.out.println("---CustomPostProcessor Before " + beanName); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) { System.out.println("---CustomPostProcessor After " + beanName); return bean; } } 

 //Main.java BeanFactory beanFactory = new BeanFactory(); beanFactory.addPostProcessor(new CustomPostProcessor()); 

अब चलाएं और सुनिश्चित करें कि सब कुछ काम करता है। प्रशिक्षण कार्य के रूप में, एक पोस्ट प्रोसेसर बनाएं जो @PostConstruct (javax.annotation.PostConstruct) एनोटेशन @PostConstruct (javax.annotation.PostConstruct) प्रदान करेगा। यह इनिशियलाइज़ करने का एक वैकल्पिक तरीका प्रदान करता है (जावा में निहित है, वसंत में नहीं)। इसका सार यह है कि आप एनोटेशन को किसी विधि पर रखते हैं, और इस विधि को BEFORE मानक स्प्रिंग इनिशियलाइज़ेशन (इनिशियलाइज़िंगबोन) कहा जाएगा।

मैन्युअल रूप से सभी एनोटेशन और पैकेज (यहां तक ​​कि javax.annotation) बनाना सुनिश्चित करें, निर्भरता को कनेक्ट न करें! यह आपको स्प्रिंग कोर और इसके एक्सटेंशन (जेवैक्स सपोर्ट) के बीच का अंतर देखने और इसे याद रखने में मदद करेगा। यह भविष्य में एक शैली रखेगा।

आप इस तथ्य में दिलचस्पी लेंगे कि एक वास्तविक वसंत में एनोटेशन @PostConstructइस तरह से लागू किया जाता है, पोस्ट-प्रोसेसर कॉमननोटेशन बीनपोस्टप्रोसेसर के माध्यम से। लेकिन वहां झांकना मत, अपना कार्यान्वयन लिखो।

अंत में, मैं आपको void close()कक्षा में एक विधि जोड़ने BeanFactoryऔर दो और तंत्रों को काम करने की सलाह देता हूं । पहला एक एनोटेशन है @PreDestroy (javax.annotation.PreDestroy), जिसका उद्देश्य उन तरीकों के लिए है जिन्हें कंटेनर बंद होने पर बुलाया जाना चाहिए। दूसरा इंटरफ़ेस org.springframework.beans.factory.DisposableBeanहै जिसमें विधि शामिल है void destroy()। इस इंटरफ़ेस को निष्पादित करने वाले सभी डिब्बे स्वयं को नष्ट करने की क्षमता (मुक्त संसाधन, उदाहरण के लिए) होंगे।

पूर्ण बीन जीवनचक्र

इसलिए हमने बिन के पूर्ण जीवन चक्र को उसके आधुनिक रूप में लागू किया है। मुझे उम्मीद है कि यह दृष्टिकोण आपको इसे याद रखने में मदद करेगा।

हमारा पसंदीदा संदर्भ

प्रोग्रामर बहुत बार संदर्भ शब्द का उपयोग करते हैं, लेकिन हर कोई यह नहीं समझता है कि वास्तव में इसका क्या मतलब है। अब हम सब कुछ क्रम में रखेंगे। जैसा कि मैंने लेख की शुरुआत में उल्लेख किया है, संदर्भ कंटेनर का कार्यान्वयन है, साथ ही साथ BeanFactory। लेकिन, बुनियादी कार्यों (DI) के अलावा, यह अभी भी कुछ शांत सुविधाओं को जोड़ता है। इनमें से एक फीचर बिन्स के बीच ईवेंट भेजना और प्रोसेस करना है।

लेख बहुत बड़ा निकला और सामग्री को काट दिया जाने लगा, इसलिए मैंने संदर्भ जानकारी को स्पॉइलर के नीचे रख दिया।

निष्कर्ष

प्रारंभ में, मैंने अंग्रेजी में बाल्डुंग के लिए इस लेख की योजना बनाई, लेकिन तब मुझे लगा कि हेबे के दर्शक प्रशिक्षण के लिए इस दृष्टिकोण का सकारात्मक मूल्यांकन कर सकते हैं। अगर आपको मेरे विचार पसंद आए, तो लेख का समर्थन करना सुनिश्चित करें। यदि उसे 30 से अधिक की रेटिंग मिलती है, तो मैं जारी रखने का वादा करता हूं। लेख लिखते समय, मैंने वास्तव में स्प्रिंग कोर के ज्ञान को दिखाने की कोशिश की, जो सबसे अधिक बार उपयोग किया जाता है, और कोर स्प्रिंग 5.0 प्रमाणन प्रमाणन गाइड पर भी आधारित है । भविष्य में, ऐसे ट्यूटोरियल की मदद से आप पूरे प्रमाणीकरण को कवर कर सकते हैं और जावा डेवलपर्स के लिए वसंत को अधिक सुलभ बना सकते हैं।

अपडेट 05/10/2018

पत्र मेरे पास लगातार प्रश्न आते हैं "और जब निरंतरता, हम उसके लिए इंतजार कर रहे हैं।" लेकिन वहाँ बिल्कुल भी समय नहीं है, और अन्य व्यक्तिगत परियोजनाएं प्राथमिकता हैं। हालांकि, अगर आप में से किसी को वास्तव में यह विचार पसंद आया है, तो आप वसंत के संकीर्ण खंड का अध्ययन कर सकते हैं और एक निरंतरता लेख लिख सकते हैं। यदि आपके पास एक हब्र खाता नहीं है, तो मैं अपने खाते से एक लेख प्रकाशित कर सकता हूं या आपको एक आमंत्रण प्राप्त करने में मदद कर सकता हूं।

विषयों का वितरण:
स्प्रिंग कंटेनर - [उपयोगकर्ता नाम]
स्प्रिंग AOP - [उपयोगकर्ता नाम]
स्प्रिंग वेब - [उपयोगकर्ता नाम]
स्प्रिंग क्लाउड - [उपयोगकर्ता नाम]