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

Question

मैं वसंत 3 सीख रहा हूँ और मैं कार्यक्षमता के पीछे समझ नहीं है <context:annotation-config>और <context:component-scan>।

मैं क्या पढ़ा है से वे अलग अलग संभाल करने लगते हैं एनोटेशन ( @Required, @Autowiredबनाम आदि @Component, @Repository, @Service, लेकिन यह भी से मैं क्या वे एक ही रजिस्टर पढ़ा है आदि) सेम पोस्ट प्रोसेसर वर्गों।

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

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

Comments

techidiocy.com/annotation-config-vs-component-scan-spring-core यहां शानदार विवरण दिया गया है

— VdeX

संक्षेप में: component-scanजब भी संभव हो उपयोग करें ।

— जेरी चिन

Answer 1

<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

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

सबसे पहले, सेम की तरह गुण bbbऔर cccसंपत्तियों को स्वाहा करता Aहै:

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" />

मेरा XML अब इसके लिए सरल हो गया है:

<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

ठीक है, यह गलत है! क्या हुआ? मेरी संपत्तियाँ क्यों स्वत: समाप्त नहीं हुईं?

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

<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 />

हम संदर्भ लोड करते हैं और परिणाम है ... कुछ भी नहीं। कोई फलियां नहीं बनती हैं, कोई फलियां नहीं हैं। कुछ भी तो नहीं!

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

लेकिन यह एक ऐसी समस्या नहीं होगी <context:component-scan>जिसके लिए काम करने के लिए "लक्ष्य" के लिए एक पैकेज को स्कैन कर सकते हैं। आइए XML एंट्री की सामग्री को निम्न प्रविष्टि में बदलें:

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

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

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

हम्म्म्म ... कुछ याद आ रहा है। क्यों?

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

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

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

<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>आवेदन के संदर्भ में पंजीकृत सभी बीन्स द्वारा लागू किए जाते हैं , यहां तक ​​कि 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 और @ सीन पैट्रिक फ्लॉयड की प्रतिक्रियाओं के साथ-साथ यह जानकारी आपको समझने की ज़रूरत है कि कैसे <context:annotation-config>और कैसे <context:component-scan>काम करना है।

Comments

उद्धरण: "<संदर्भ: एनोटेशन-कॉन्फ़िगरेशन /> छोड़ा जा सकता है अगर <संदर्भ: घटक-स्कैन> निर्दिष्ट किया गया है"। कभी एनोटेशन-कॉन्फ़िगरेशन का उपयोग क्यों करें? इसका अस्तित्व क्यों है?

— CodeClimber

बहुत बढ़िया जवाब! संक्षिप्त विवरण के साथ एक संक्षिप्त स्पष्ट उदाहरण जैसा कुछ भी नहीं है। एक बार में पूरी बात समझ लें।

— जिगीश

काश आपने पूरा स्प्रिंग मैनुअल लिखा होता! स्प्रिंग फ्रेमवर्क को भ्रमित करने से संबंधित किसी भी चीज़ के बारे में स्पष्टीकरण का सबसे अच्छा हिस्सा। धन्यवाद।

— 9

इतनी सरल और उत्कृष्ट व्याख्या। जवाब मिलने के अलावा मैंने चीजों को बताने का अच्छा तरीका भी सीख लिया :)

— अमीर अल

शुरुआत के लिए समझने के लिए आपकी लेखन शैली बहुत आसान है। मुझे आशा है कि आप मूल स्प्रिंग के बारे में एक किताब लिख सकते हैं। मैं इसे खरीदने का वादा करता हूं।

— पन्नाधाय

Answer 2

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

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

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

Comments

@ टोमसज़ लिंक डाउन :(

— आनंद

Answer 3

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

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

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

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

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

---

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

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

Comments

क्या घटक-स्कैन का उपयोग करना संभव है, लेकिन एनोटेशन-कॉन्फ़िगरेशन किसी तरह नहीं?

— कोरे तुगाय

एनोटेशन-कॉन्फिग = "गलत" संदर्भ में उपयोग करें: एनोटेशन-कॉन्फिग टैग।

— सारा

Answer 4

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

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

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

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

Comments

क्या आप कृपया आगे बता सकते हैं? अगर मैं उपयोग करता <context:component-scan>हूं तो मैं XML का उपयोग करके बीन की परिभाषा को ओवरराइड नहीं कर पाऊंगा?

— user938214097

@ user938214097 आप XML को सेम में या घटक स्कैनिंग के साथ एनोटेशन के माध्यम से परिभाषित कर सकते हैं

— सीन पैट्रिक फ्लोयड

क्या यह उपयोग करने के लिए पर्याप्त है <context:component-scan>? अगर मैं उपयोग नहीं करता तो क्या मैं कुछ ढीला कर सकता हूं <context:annotation-config>?

— user938214097

@ टॉमाज़ ने उत्तर दिया कि लगता है

— सीन पैट्रिक फ़्लॉइड

Answer 5

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

<context:annotation-config /> 

आपको केवल उन एनोटेशन का उपयोग करने में सक्षम करता है जो केवल सेम के गुणों और निर्माणकर्ताओं को वायर करने के लिए प्रतिबंधित हैं।

जहाँ तक

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

सब कुछ है कि सक्षम बनाता है <context:annotation-config />लकीर के फकीर जैसे का उपयोग कर के योग के साथ, कर सकते हैं .. @Component, @Service, @Repository। तो आप पूरे सेम तार कर सकते हैं और न केवल निर्माणकर्ताओं या संपत्तियों तक सीमित हो सकते हैं।

Answer 6

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

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

---

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

@Required सक्षम बनाता है RequiredAnnotationBeanPostProcessor प्रसंस्करण उपकरण
@Autowired सक्षम बनाता है AutowiredAnnotationBeanPostProcessorप्रसंस्करण उपकरण

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

---

@Repository, @Service और @Controller @Component हैं , और वे वर्ग स्तर को लक्षित करते हैं ।

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

XML को एनोटेशन में माइग्रेट करना

Answer 7

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

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

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

---

स्प्रिंग स्वचालित रूप से 'स्टीरियोटाइप्ड' वर्गों का पता लगाने और ApplicationContext के साथ संबंधित बीनडिफिनिशन को पंजीकृत करने की क्षमता प्रदान करता है।

की जावाडोक के अनुसार org.springframework.stereotype :

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

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

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

Answer 8

<context:annotation-config>

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

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

• एक्सएमएल: <bean>
• @ नोट: @ समुदाय, @ सेवा, @ सेवा, @ नियंत्रक
• JavaConfig: @Configuration, @Bean

अब उसके पास

<context:component-scan>

यह दो काम करता है:

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

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

बस इतना ही

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

<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>, डीआई को @Autowired के माध्यम से अपनी कक्षाओं में कॉन्फ़िगर किया गया है। इसका अर्थ है कि सेवाएँ अपने रिपॉजिटरी घटकों के लिए @Autowired का उपयोग करती हैं और रिपॉजिटरी JdbcTemplate, DataSource इत्यादि के लिए @Autowired का उपयोग करती हैं।

Comments

शानदार स्पष्टीकरण धन्यवाद। @ मैनुअल जॉर्डन

— BALS

Answer 9

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

के साथ प्रयास करें <context:component-scan base-package="..." annotation-config="false"/>, अपने विन्यास में @Service, @Repository, @Component ठीक काम करता है, लेकिन @ Autowired, @ संसाधन और @Inject नहीं है काम करते हैं।

यह साधन AutowiredAnnotationBeanPostProcessor सक्षम नहीं किया जाएगा और स्प्रिंग कंटेनर Autowiring एनोटेशन संसाधित नहीं करेंगे।

Comments

इसने मुझे यह समझने में मदद की कि <संदर्भ: घटक-स्कैन /> अंतर्निहित रूप से सक्षम करता है <संदर्भ: एनोटेशन-कॉन्फ़िगरेशन />; यह सेम परिभाषाओं के लिए स्कैन है और साथ ही इंजेक्शन की आवश्यकता है। मैंने एनोटेशन-कॉन्फिगरेशन = "गलत" के साथ प्रयोग किया, और इंजेक्शन तब तक काम नहीं किया जब तक कि मैं स्पष्ट रूप से <संदर्भ: एनोटेशन-कॉन्फिगरेशन> का उपयोग करके सेट नहीं करता। अंत में मेरी समझ पहले से बेहतर है!

— क्यूरियस माइंड

Answer 10

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

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

संक्षेप में:

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

Answer 11

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

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

@Component, @Service, @Repository,@Controller

<context:annotation-config />:

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

Answer 12

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

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

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

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

Answer 13

<context:annotation-config>:

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

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

यह स्प्रिंग कंटेनर को बताता है, जहां उन एनोटेट सेम को खोजना शुरू करना है। यहां वसंत बेस पैकेज के सभी उप पैकेजों की खोज करेगा।

Answer 14

आप वसंत संदर्भ स्कीमा फ़ाइल में अधिक जानकारी पा सकते हैं। निम्नलिखित वसंत-संदर्भ-4.3.xsd में है

<conxtext:annotation-config />

Activates various annotations to be detected in bean classes: Spring's @Required and
@Autowired, as well as JSR 250's @PostConstruct, @PreDestroy and @Resource (if available),
JAX-WS's @WebServiceRef (if available), EJB 3's @EJB (if available), and JPA's
@PersistenceContext and @PersistenceUnit (if available). Alternatively, you may
choose to activate the individual BeanPostProcessors for those annotations.

Note: This tag does not activate processing of Spring's @Transactional or EJB 3's
@TransactionAttribute annotation. Consider the use of the <tx:annotation-driven>
tag for that purpose.

<context:component-scan>

Scans the classpath for annotated components that will be auto-registered as
Spring beans. By default, the Spring-provided @Component, @Repository, @Service, @Controller, @RestController, @ControllerAdvice, and @Configuration stereotypes    will be detected.

Note: This tag implies the effects of the 'annotation-config' tag, activating @Required,
@Autowired, @PostConstruct, @PreDestroy, @Resource, @PersistenceContext and @PersistenceUnit
annotations in the component classes, which is usually desired for autodetected components
(without external configuration). Turn off the 'annotation-config' attribute to deactivate
this default behavior, for example in order to use custom BeanPostProcessor definitions
for handling those annotations.

Note: You may use placeholders in package paths, but only resolved against system
properties (analogous to resource paths). A component scan results in new bean definitions
being registered; Spring's PropertySourcesPlaceholderConfigurer will apply to those bean
definitions just like to regular bean definitions, but it won't apply to the component
scan settings themselves.

Answer 15

एक पूरक के रूप में, आप एनोटेशन तरीके @ComponentScanसे उपयोग करने के लिए उपयोग कर सकते हैं <context:component-scan>।

इसका वर्णन वसंत ऋतु में भी किया गया है

@Configuration कक्षाओं के साथ उपयोग के लिए घटक स्कैनिंग निर्देश कॉन्फ़िगर करता है। स्प्रिंग एक्सएमएल के तत्व के साथ समानांतर समर्थन प्रदान करता है।

एक बात ध्यान दें, यदि आप स्प्रिंग बूट का उपयोग कर रहे हैं, तो @Configuration और @ComponentScan को @SpringBootApplication एनोटेशन का उपयोग करके निहित किया जा सकता है।