दिलचस्प पोस्ट
Android ImageView स्केलिंग और समस्या का अनुवाद करना .NET इंटिजर बनाम Int16? इनलाइन फ़ंक्शन बनाम प्रीप्रोसेसर मैक्रोज़ खिड़कियों के रूपों में स्पलैश स्क्रीन को कैसे बनाया जाए? गिट धक्का का उपयोग करके एक प्रोजेक्ट को परिनियोजित करें कैसे जाँचें कि क्या PHP सरणी सहायक या अनुक्रमिक है? Java में JSON ऑब्जेक्ट को पार्स करना प्रॉपर्टी वैल्यू के अनुसार कस्टम ऑब्जेक्ट की सरणी को सॉर्ट करने के लिए स्विफ्ट कैसे करें जावा 256-बिट एईएस पासवर्ड आधारित एन्क्रिप्शन एसक्यूएल एकाधिक प्रवेश बयान Iframe load पूर्ण ईवेंट कैप्चर करें क्या एक एंड्रॉइड ऐप सीधे ऑनलाइन मैसेज डेटाबेस से कनेक्ट हो सकता है? Python का उपयोग करके दूरस्थ रूप से एक प्रक्रिया को कैसे निष्पादित करें ब्राउज़र के पसंदीदा / बुकमार्क को जावास्क्रिप्ट से जोड़ें लेकिन सभी ब्राउज़रों के लिए (मेरा Chrome में काम नहीं करता है)? प्रत्येक श्रेणी के लिए शीर्ष 10 रिकॉर्ड चुनें

संदर्भ के बीच का अंतर: एनोटेशन-कॉन्फिग> बनाम <संदर्भ: घटक-स्कैन>

मैं स्प्रिंग 3 सीख रहा हूं और मुझे <context:annotation-config> और <context:component-scan> पीछे कार्यशीलता को समझने में प्रतीत नहीं होता।

मैंने जो पढ़ा है, वह अलग-अलग टिप्पणियों (@ अनिवार्य, @ एटोवैरेट आदि बनाम @ कॉमोनेंट, रिप्इसरी, @ सर्विस आदि) को संभालने लगते हैं, लेकिन मैंने जो भी पढ़ा है वे उसी बीन पोस्ट प्रोसेसर वर्गों को पंजीकृत करते हैं।

मुझे और भी भ्रमित करने के लिए, <context:component-scan> पर एक annotation-config विशेषता है

क्या कोई इन टैग पर कुछ प्रकाश डाला सकता है? क्या समान है, जो अलग है, दूसरे के द्वारा अधिग्रहित किया जाता है, वे एक-दूसरे को पूरा करते हैं, मुझे उनमें से एक की आवश्यकता है, दोनों?

वेब के समाधान से एकत्रित समाधान "संदर्भ के बीच का अंतर: एनोटेशन-कॉन्फिग> बनाम <संदर्भ: घटक-स्कैन>"

<context:annotation-config> का उपयोग पहले से ही अनुप्रयोग संदर्भ में पंजीकृत बीन्स में एनोटेशन सक्रिय करने के लिए किया जाता है (कोई बात नहीं अगर वे एक्सएमएल या पैकेज स्कैनिंग द्वारा परिभाषित होते हैं)

<context:component-scan> यह भी कर सकता है कि <context:annotation-config> करता है लेकिन <context:component-scan> भी अनुप्रयोग संदर्भ में बीजों की खोज और रजिस्टर करने के लिए संकुल स्कैन करता है।

मैं अंतर / समानता दिखाने के लिए कुछ उदाहरणों का उपयोग करूँगा

चलो A , B और C के तीन बीन्स की मूलभूत व्यवस्था से शुरू करें, जिसमें B और C को A में इंजेक्ट किया गया।

 package com.xxx; public class B { public B() { System.out.println("creating bean B: " + this); } } package com.xxx; public class C { public C() { System.out.println("creating bean C: " + this); } } package com.yyy; import com.xxx.B; import com.xxx.C; public class A { private B bbb; private C ccc; public A() { System.out.println("creating bean A: " + this); } public void setBbb(B bbb) { System.out.println("setting A.bbb with " + bbb); this.bbb = bbb; } public void setCcc(C ccc) { System.out.println("setting A.ccc with " + ccc); this.ccc = ccc; } } 

निम्नलिखित XML विन्यास के साथ:

 <bean id="bBean" class="com.xxx.B" /> <bean id="cBean" class="com.xxx.C" /> <bean id="aBean" class="com.yyy.A"> <property name="bbb" ref="bBean" /> <property name="ccc" ref="cBean" /> </bean> 

संदर्भ लोड करने से निम्नलिखित आउटपुट उत्पन्न होते हैं:

 creating bean B: com.xxx.B@c2ff5 creating bean C: com.xxx.C@1e8a1f6 creating bean A: com.yyy.A@1e152c5 setting A.bbb with com.xxx.B@c2ff5 setting A.ccc with com.xxx.C@1e8a1f6 

ठीक है, यह अपेक्षित आउटपुट है लेकिन यह "पुरानी शैली" स्प्रिंग है अब हमारे पास एनोटेशन हैं इसलिए एक्सएमएल को सरल बनाने के लिए उनको इस्तेमाल कर सकते हैं।

सबसे पहले, बीन A बीबी और ccc गुणों को ऑटोवॉयर करने की सुविधा देता है:

 package com.yyy; import org.springframework.beans.factory.annotation.Autowired; import com.xxx.B; import com.xxx.C; public class A { private B bbb; private C ccc; public A() { System.out.println("creating bean A: " + this); } @Autowired public void setBbb(B bbb) { System.out.println("setting A.bbb with " + bbb); this.bbb = bbb; } @Autowired public void setCcc(C ccc) { System.out.println("setting A.ccc with " + ccc); this.ccc = ccc; } } 

यह मुझे XML से निम्न पंक्तियों को निकालने की अनुमति देता है:

 <property name="bbb" ref="bBean" /> <property name="ccc" ref="cBean" /> 

मेरी एक्सएमएल अब इस पर सरलीकृत है:

 <bean id="bBean" class="com.xxx.B" /> <bean id="cBean" class="com.xxx.C" /> <bean id="aBean" class="com.yyy.A" /> 

जब मैं संदर्भ को लोड करता हूं, तो मुझे निम्न आउटपुट मिलता है:

 creating bean B: com.xxx.B@5e5a50 creating bean C: com.xxx.C@54a328 creating bean A: com.yyy.A@a3d4cf 

ठीक है, यह गलत है! क्या हुआ? क्यों नहीं मेरे गुणों autowired हैं?

अच्छी तरह से, एनोटेशन एक अच्छी सुविधा है लेकिन स्वयं द्वारा वे कुछ भी नहीं करते हैं। वे सामान की व्याख्या करते हैं एनोटेशन ढूंढने और उनके साथ कुछ करने के लिए आपको प्रोसेसिंग टूल की आवश्यकता है।

<context:annotation-config> बचाव के लिए यह उस एनोटेशन के कार्यों को सक्रिय करता है जो इसे उसी एप्लिकेशन संदर्भ में परिभाषित बीन्स पर पाता है जहां खुद परिभाषित किया जाता है।

अगर मैं अपनी XML को इस पर बदलता हूं:

 <context:annotation-config /> <bean id="bBean" class="com.xxx.B" /> <bean id="cBean" class="com.xxx.C" /> <bean id="aBean" class="com.yyy.A" /> 

जब मैं अनुप्रयोग संदर्भ को लोड करता हूँ तो मुझे उचित परिणाम मिलता है:

 creating bean B: com.xxx.B@15663a2 creating bean C: com.xxx.C@cd5f8b creating bean A: com.yyy.A@157aa53 setting A.bbb with com.xxx.B@15663a2 setting A.ccc with com.xxx.C@cd5f8b 

ठीक है, ये अच्छा है, लेकिन मैंने XML से दो पंक्तियाँ निकाल दी हैं और एक जोड़ दिया है। यह बहुत बड़ा अंतर नहीं है एनोटेशन के साथ विचार यह है कि इसे एक्सएमएल को निकालना चाहिए।

तो आइए एक्सएमएल परिभाषाओं को हटा दें और उनको एनोटेशन के साथ बदलें:

 package com.xxx; import org.springframework.stereotype.Component; @Component public class B { public B() { System.out.println("creating bean B: " + this); } } package com.xxx; import org.springframework.stereotype.Component; @Component public class C { public C() { System.out.println("creating bean C: " + this); } } package com.yyy; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import com.xxx.B; import com.xxx.C; @Component public class A { private B bbb; private C ccc; public A() { System.out.println("creating bean A: " + this); } @Autowired public void setBbb(B bbb) { System.out.println("setting A.bbb with " + bbb); this.bbb = bbb; } @Autowired public void setCcc(C ccc) { System.out.println("setting A.ccc with " + ccc); this.ccc = ccc; } } 

एक्सएमएल में रहते हुए हम केवल इसे ही रखते हैं:

 <context:annotation-config /> 

हम संदर्भ लोड करते हैं और नतीजा है … कुछ भी नहीं। कोई सेम नहीं बनाई जाती है, कोई बीन्स autowired हैं कुछ भी तो नहीं!

ऐसा इसलिए है क्योंकि, जैसा कि मैंने पहले पैराग्राफ में कहा था, <context:annotation-config /> केवल आवेदन संदर्भ में पंजीकृत बीन्स पर काम करता है। क्योंकि मैंने तीन बीन्स के लिए एक्सएमएल कॉन्फ़िगरेशन हटाया है, वहां कोई बीन नहीं है और <context:annotation-config /> पर काम करने के लिए कोई "लक्ष्य" नहीं है

लेकिन यह <context:component-scan> लिए एक समस्या नहीं होगी, जो काम करने के लिए "लक्ष्य" के लिए एक पैकेज को स्कैन कर सकता है। चलिए एक्सएमएल कॉन्फ़िग की सामग्री को निम्नलिखित प्रविष्टि में बदलते हैं:

 <context:component-scan base-package="com.xxx" /> 

जब मैं संदर्भ को लोड करता हूं, तो मुझे निम्न आउटपुट मिलता है:

 creating bean B: com.xxx.B@1be0f0a creating bean C: com.xxx.C@80d1ff 

हम्म्म … कुछ याद आ रही है क्यूं कर?

यदि आप कक्षा में com.yyy , तो क्लास A में पैकेज com.yyy लेकिन मैंने <context:component-scan> पैकेज com.xxx का उपयोग करने के लिए निर्दिष्ट किया है, इसलिए यह पूरी तरह से मेरी कक्षा को चूक गया और केवल B और C उठाया com.xxx पैकेज पर हैं com.xxx

इसे ठीक करने के लिए, मैं यह अन्य पैकेज भी जोड़ता हूं:

 <context:component-scan base-package="com.xxx,com.yyy" /> 

और अब हमें अपेक्षित परिणाम प्राप्त होता है:

 creating bean B: com.xxx.B@cd5f8b creating bean C: com.xxx.C@15ac3c9 creating bean A: com.yyy.A@ec4a87 setting A.bbb with com.xxx.B@cd5f8b setting A.ccc with com.xxx.C@15ac3c9 

और बस! अब आपके पास एक्सएमएल परिभाषा अब नहीं है, आपके पास एनोटेशन हैं

अंतिम उदाहरण के रूप में, A , B और C एनोटेटेड क्लासेस को रखने और निम्नलिखित को XML में जोड़ना, संदर्भ को लोड करने के बाद हमें क्या मिलेगा?

 <context:component-scan base-package="com.xxx" /> <bean id="aBean" class="com.yyy.A" /> 

हम अभी भी सही परिणाम प्राप्त करते हैं:

 creating bean B: com.xxx.B@157aa53 creating bean C: com.xxx.C@ec4a87 creating bean A: com.yyy.A@1d64c37 setting A.bbb with com.xxx.B@157aa53 setting A.ccc with com.xxx.C@ec4a87 

यहां तक ​​कि अगर कक्षा A लिए बीन स्कैनिंग द्वारा प्राप्त नहीं किया गया है, तो प्रसंस्करण उपकरण अभी भी <context:component-scan> सभी संदर्भों में दर्ज किए गए बीन्स पर <context:component-scan> लागू होते हैं, यहां तक ​​कि A लिए भी जो मैन्युअल रूप से XML में पंजीकृत था।

लेकिन अगर हमारे पास निम्नलिखित एक्सएमएल है, तो क्या हम बीन्स दोहराएंगे क्योंकि हमने <context:annotation-config /> और <context:component-scan> निर्दिष्ट किया है?

 <context:annotation-config /> <context:component-scan base-package="com.xxx" /> <bean id="aBean" class="com.yyy.A" /> 

नहीं, कोई दोहराव नहीं, हम फिर से अपेक्षित परिणाम प्राप्त करते हैं:

 creating bean B: com.xxx.B@157aa53 creating bean C: com.xxx.C@ec4a87 creating bean A: com.yyy.A@1d64c37 setting A.bbb with com.xxx.B@157aa53 setting A.ccc with com.xxx.C@ec4a87 

ऐसा इसलिए क्योंकि दोनों टैग एक ही प्रसंस्करण औजार ( <context:annotation-config /> को छोड़ दिया जा सकता है यदि <context:component-scan> निर्दिष्ट है) को दर्ज किया जाता है, लेकिन स्प्रिंग केवल एक बार उन्हें चलाने का ख्याल रखता है

यहां तक ​​कि अगर आप प्रसंस्करण उपकरण स्वयं कई बार रजिस्टर करते हैं, तो वसंत अभी भी सुनिश्चित कर लेगा कि वे केवल एक बार जादू करते हैं; यह XML:

 <context:annotation-config /> <context:component-scan base-package="com.xxx" /> <bean id="aBean" class="com.yyy.A" /> <bean id="bla" class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" /> <bean id="bla1" class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" /> <bean id="bla2" class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" /> <bean id="bla3" class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" /> 

अभी भी निम्न परिणाम उत्पन्न करेगा:

 creating bean B: com.xxx.B@157aa53 creating bean C: com.xxx.C@ec4a87 creating bean A: com.yyy.A@25d2b2 setting A.bbb with com.xxx.B@157aa53 setting A.ccc with com.xxx.C@ec4a87 

ठीक है, यह रैप के बारे में है

मुझे उम्मीद है कि @Tomasz Nurkiewicz और @Sean Patrick Floyd से प्रतिक्रियाओं के साथ इस जानकारी को आपको समझना होगा कि कैसे <context:annotation-config> और <context:component-scan> काम

मुझे इस अच्छा सारांश का पता चला है कि कौन से घोषणाएं उठाई गई हैं इसे पढ़ कर आप पाएंगे कि <context:component-scan/> <context:annotation-config/> द्वारा मान्यता प्राप्त एनोटेशन के एक सुपरसेट को पहचानता है, अर्थात्:

  • @Component , @Service , @Repository @Service , @Repository , @Endpoint
  • @Configuration , @Bean , @Lazy @Scope , @Order @Primary , @Profile @DependsOn , @Import , @ImportResource @Import , @ImportResource @Import , @ImportResource @Import , @ImportResource

जैसा कि आप देख सकते हैं <context:component-scan/> तार्किक रूप से विस्तारित होता है <context:annotation-config/> CLASSPATH घटक स्कैनिंग और जावा @ कॉन्फ़िगरेशन सुविधाओं के साथ।

स्प्रिंग आपको दो चीजों को करने की अनुमति देता है:

  1. सेम के आटोवरिंग
  2. सेम की ऑटोडिविक्स

1. ऑटोवायरिंग
आमतौर पर applicationContext.xml में आप बीन्स को परिभाषित करते हैं और अन्य बीन्स कन्स्ट्रक्टर या सेटर विधियों के माध्यम से वायर्ड होते हैं। आप बीन्स एक्सएमएल या एनोटेशन का इस्तेमाल कर सकते हैं। यदि आप एनोटेशन का उपयोग करते हैं, तो आपको एनोटेशन सक्रिय करने की आवश्यकता होती है और आप को <context:annotation-config /> applicationContext.xml में जोड़ना होगा। यह applicationContext.xml से टैग की संरचना को आसान बना देगा, क्योंकि आपको मैन्युअल रूप से वायर सेम (कन्स्ट्रक्टर या सेटर) की आवश्यकता नहीं होगी। आप @Autowire एनोटेशन का उपयोग कर सकते हैं और बीन्स प्रकार से वायर्ड होंगे।

मैन्युअल XML कॉन्फ़िगरेशन से बचने के लिए एक कदम आगे है

2. ऑटोोडिविविर
ऑटोोडिविविटी एक्सएमएल को एक कदम आगे बढ़ाना है, इस अर्थ में कि आपको भी <bean> tag को applicationContext.xml में जोड़ने की ज़रूरत नहीं है आप केवल निम्नलिखित भाषणों में से एक के साथ विशिष्ट सेम को चिह्नित करते हैं और वसंत स्वचालित रूप से चिह्नित बीन्स और उनकी निर्भरताओं को वसंत कंटेनर में तार करेंगे। टिप्पणियां इस प्रकार हैं: @ नियंत्रक , @ सेवा , @ कंपनेन्ट , @ रिपोजिटरी<context:component-scan> का उपयोग करके और आधार पैकेज की ओर इशारा करते हुए, स्प्रिंग स्प्रिंग कंटेनर में घटकों को स्वतः खोज और तार देगा।


एक निष्कर्ष के रूप में:

  • <context:annotation-config /> @ एटोवायर एनोटेशन का उपयोग करने में सक्षम होने के लिए उपयोग किया जाता है
  • <context:component-scan /> विशिष्ट बीन्स की खोज और ऑटोॉवेयर के प्रयास का निर्धारण करने के लिए उपयोग किया जाता है।

<context:annotation-config> सेम में कई अलग <context:annotation-config> अलग एनोटेशन सक्रिय करता है, चाहे वे एक्सएमएल में परिभाषित हों या घटक स्कैनिंग के माध्यम से।

<context:component-scan> एक्सएमएल का उपयोग किए बिना सेम को परिभाषित करने के लिए है

अधिक जानकारी के लिए, पढ़ें:

  • 3.9। टिप्पणी-आधारित कंटेनर कॉन्फ़िगरेशन
  • 3.10। कक्षापाथ स्कैनिंग और प्रबंधित घटक

दोनों के बीच अंतर वास्तव में सरल है!

 <context:annotation-config /> 

वे एनोटेशन का उपयोग करने के लिए सक्षम हैं जो केवल मिक्स्डिंग वायरिंग अप गुणों और कन्स्ट्रक्टरों तक सीमित हैं!

जहाँ तक

 <context:component-scan base-package="org.package"/> 

ऐसी सभी चीजों को सक्षम करता है, जो <context:annotation-config /> कर सकते हैं, @Component का उपयोग करने के अतिरिक्त उदाहरण के लिए। @Component , @Service , @Repository तो आप पूरे सेम को तार कर सकते हैं और कंसल्टर्स या गुणों तक सीमित नहीं हैं!

tl; डॉ
<context:annotation-config> : स्प्रिंग कॉन्फिग xml में पहले से पंजीकृत बीन्स के लिए स्कैन और सक्रिय एनोटेशन।

<context:component-scan> : बीन पंजीकरण + <context:annotation-config>


@ एटोवॉल्ड और @ अनिवार्य हैं संपत्ति के स्तर का लक्ष्य है इसलिए बीन को इन एनोटेशनों का उपयोग करने से पहले वसंत आईओसी में पंजीकरण करना चाहिए। इन एनोटेशन को सक्षम करने के लिए या तो संबंधित बीन्स को पंजीकृत करना है या इसमें शामिल हैं <context:annotation-config /> यानी <context:annotation-config /> पंजीकृत बीन्स के साथ ही काम करता है

@ अनिवार्य RequiredAnnotationBeanPostProcessor सक्षमताविज्ञानबीनपोस्ट प्रोसेसर प्रोसेसिंग टूल को सक्षम करता है
@ऑटोवर्थ सक्षम हो जाता है AutowiredAnnotationBeanPostProcessor प्रसंस्करण उपकरण

नोट: एनोमेशन खुद कुछ भी नहीं करने के लिए, हमें प्रोसेसिंग टूल की आवश्यकता है, जो कि नीचे की श्रेणी है, कोर प्रोसेस के लिए ज़िम्मेदार है।


@ रेजोजीटरी, @ सेवा और @ नियंत्रक @ घटक हैं , और वे वर्ग के स्तर को लक्षित करते हैं

<context:component-scan> यह पैकेज को स्कैन करता है और बीन्स को ढूंढ और पंजीकृत करता है, और इसमें <context:annotation-config /> द्वारा किया गया कार्य शामिल है

<context:annotation-config> टैग स्प्रिंग को बताता है कि "ऑटोटेयर एनोटेशन वाले वर्गों की निर्भरता आवश्यकताओं को स्वचालित रूप से हल करने के लिए कोडबेस को स्कैन करने के लिए।

स्प्रिंग 2.5 जेएसआर -250 एनोटेशन जैसे कि @ रिसोर्स, पोस्ट कॉन्स्ट्रस्ट, और @ प्रीडेस्टॉय के लिए समर्थन भी जोड़ता है। इन एनोटेशनों का उपयोग करने के लिए यह भी आवश्यक है कि कुछ बीनपोस्ट प्रोसेसर्स स्प्रिंग कंटेनर के भीतर पंजीकृत हों हमेशा की तरह, इन्हें व्यक्तिगत बीन की परिभाषा के रूप में पंजीकृत किया जा सकता है, लेकिन इन्हें वसंत विन्यास में <context:annotation-config> टैग भी शामिल करके निहित दर्ज किया जा सकता है

एनोटेशन आधारित कॉन्फ़िगरेशन के वसंत प्रलेखन से लिया गया


स्प्रिंग स्वतः 'टकसाली' वर्गों का पता लगाने और ApplicationContext के साथ संबंधित BeanDefinitions दर्ज करने की क्षमता प्रदान करता है।

Org.springframework.stereotype के javadoc के अनुसार:

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

इस तरह के 'स्टीरियोटाइप' कक्षाओं को स्वत: पता लगाने के लिए, <context:component-scan> टैग आवश्यक है।

<context:component-scan> टैग स्प्रिंग को बताता है कि पैकेज (और उसके सभी उपपैकेजों) के अंतर्गत इनजेक्लेबल बीन्स के लिए कोड को स्कैन करने के लिए निर्दिष्ट है

 <context:annotation-config> 

केवल @Autowired और @Qualifer एनोटेशन को हल करता है, सब कुछ, निर्भरता इंजेक्शन के बारे में, अन्य एनोटेशन हैं जो एक ही काम करते हैं, मुझे लगता है कि कैसे @ इंजेक्ट, लेकिन सभी एनोटेशन के माध्यम से DI को हल करने के लिए।

जागरूक रहें, तब भी जब आपने <context:annotation-config> तत्व घोषित किया है , तो आपको अपनी कक्षा घोषित करनी होगी कि कैसे बीन वैसे भी, याद रखें कि हमारे पास तीन उपलब्ध विकल्प हैं

  • एक्सएमएल: <bean>
  • @ एनोटेशन: @Component, @Service, @Repository, @Controller
  • JavaConfig: @ बीन

अब उसके पास

 <context:component-scan> 

यह दो बातें करता है:

  • यह @Component, @Service, @Repository, @Controller और @ कॉन्फ़िगरेशन के साथ एनोटेट की गई सभी कक्षाओं को स्कैन करता है और एक बीन बनाएं
  • यह वही काम करता है कि कैसे <context:annotation-config> करता है

इसलिए अगर आप <context:component-scan> को घोषित करते हैं, तो आवश्यक नहीं है कि <context:annotation-config> भी घोषित करें।

बस इतना ही

एक सामान्य परिदृश्य उदाहरण के लिए केवल एक्सएमएल के माध्यम से एक बीन घोषित करता था और उदाहरण के लिए, एनोटेशन के माध्यम से DI को हल करता था

 <bean id="serviceBeanA" class="com.something.CarServiceImpl" /> <bean id="serviceBeanB" class="com.something.PersonServiceImpl" /> <bean id="repositoryBeanA" class="com.something.CarRepository" /> <bean id="repositoryBeanB" class="com.something.PersonRepository" /> 

हमने केवल बीन्स घोषित किया है, <constructor-arg> और <property> बारे में कुछ भी नहीं है, डी को स्वयं के वर्गों में @ एटोवायर के द्वारा कॉन्फ़िगर किया गया है। इसका अर्थ है कि उनके रिपोजिटरीज़ घटकों के लिए सेवाओं का उपयोग @ एटोवायर और रिपॉजिटरीज, जेडीबीसी टेम्पलेट, डाटासॉर्स इत्यादि के लिए एटोवायर @ उपयोग करते हैं।

 <context:component-scan /> implicitly enables <context:annotation-config/> 

<context:component-scan base-package="..." annotation-config="false"/> , अपने सेवा @ सेवा, @ रिपोजिटरी में, @Component, ठीक काम करता है, लेकिन @ Autowired , @ संसाधन और @ इंजेक्शन काम नहीं करता है

इसका मतलब यह है कि ऑटोवायर एनएनेटेशनबीनपोस्ट प्रोसेसर सक्षम नहीं होगा और स्प्रिंग कंटेनर ऑटोवर्जिंग एनोटेशन पर प्रक्रिया नहीं करेगा।

 <context:annotation-config/> <!-- is used to activate the annotation for beans --> <context:component-scan base-package="xyMyClass" /> <!-- is for the Spring IOC container to look for the beans in the base package. --> 

नोट करने के लिए अन्य महत्वपूर्ण बिंदु यह है कि context:component-scan सम्मिलित रूप से context:annotation-config कॉल करता context:annotation-config बीन्स पर एनोटेशन को सक्रिय करने के लिए context:annotation-config । ठीक है, अगर आप context:component-scan नहीं चाहते हैं context:component-scan आपके लिए एनोटेशन सक्रिय करने के लिए context:component-scan करें, तो आप context:component-scan के एनोटेशन-कॉन्फ़िग तत्व को सेट कर सकते हैं context:component-scan करने के लिए false

संक्षेप में:

 <context:annotation-config/> <!-- activates the annotations --> <context:component-scan base-package="xyMyClass" /> <!-- activates the annotations + register the beans by looking inside the base-package --> 

एक <context:component-scan/> कस्टम टैग, बीन परिभाषाओं का एक ही सेट रजिस्टर्ड करता है, जावापालक स्कैनिंग और क्लासपाथ से बीन की परिभाषा को पंजीकृत करने की प्राथमिक जिम्मेदारी के अलावा, द्वारा किया जाता है।

यदि किसी कारण से डिफ़ॉल्ट बीन परिभाषाओं का पंजीकरण टाला जाना है, तो ऐसा करने का तरीका घटक-स्कैन में एक अतिरिक्त "एनोटेशन-कॉन्फ़िग" विशेषता को निर्दिष्ट करना है, इस प्रकार से:

 <context:component-scan basePackages="" annotation-config="false"/> 

संदर्भ: http://www.java-allandsundry.com/2012/12/contextcomponent-scan-contextannotation.html

<context:component-scan base-package="package name" /> :

यह कंटेनर को बताने के लिए उपयोग किया जाता है कि मेरे पैकेज में बीन कक्षाएं उन बीन वर्गों को स्कैन करती हैं। सेम के शीर्ष पर कंटेनर द्वारा बीन वर्गों को स्कैन करने के लिए हमें निम्नलिखित में से एक स्टीरियो टाइप एनोटेशन लिखना होगा

@Component , @Component , @Service , @Repository

<context:annotation-config /> :

अगर हम बीन टैग को स्पष्ट रूप से एक्सएमएल में लिखना नहीं चाहते हैं तो कंटेनर कैसे जानता है कि बीन में ऑटो वायरिंग है @Autowired एनोटेशन का उपयोग करके यह संभव है हमें कंटेनर को सूचित करना होगा कि context:annotation-config मेरी बीन में ऑटो ताररहित है context:annotation-config

संदर्भ: एनोटेशन-config:

यह स्प्रिंग को बताता है कि मैं गनो का स्प्रिंग बीन एडन के रूप में एनोएटेड सेम का इस्तेमाल करता हूं, जो स्प्रिंग कॉन्फिग एक्सएमएल फाइल में घोषित करने के बजाय उन लोगों को @ एटाओयर एनोटेशन के माध्यम से वायर्ड किया जाएगा।

संदर्भ: घटक-स्कैन बेस-पैकेज = "com.test …": यह स्प्रिंग कंटेनर कहता है, जहां उन एनोटेटेड बीन्स की खोज शुरू करना है यहां वसंत के सभी उप पैकेजों को शुष्क किया जाएगा