Unterschied zwischen <context: annotation-config> und <context: component-scan>

Ich lerne Spring 3 und ich scheine die Funktionalität hinter <context:annotation-config>und nicht zu verstehen <context:component-scan>.

Von dem, was ich gelesen habe , scheinen sie anders zu behandeln Anmerkungen ( @Required, @Autowiredetc vs @Component, @Repository, @Serviceusw.), sondern auch von dem, was ich gelesen habe sie die gleichen registrieren Bean Postprozessor - Klassen.

Um mich noch mehr zu verwirren, gibt es ein annotation-config Attribut auf <context:component-scan>.

Kann jemand etwas Licht auf diese Tags werfen? Was ist ähnlich, was ist anders, wird eines von dem anderen abgelöst, sie ergänzen sich gegenseitig, brauche ich einen von beiden?

<context:annotation-config> wird verwendet, um Anmerkungen in Beans zu aktivieren, die bereits im Anwendungskontext registriert sind (unabhängig davon, ob sie mit XML oder durch Paketscanning definiert wurden).

<context:component-scan>kann auch tun, was <context:annotation-config>tut, aber <context:component-scan>auch Pakete scannen, um Beans im Anwendungskontext zu finden und zu registrieren.

Ich werde einige Beispiele verwenden, um die Unterschiede / Ähnlichkeiten zu zeigen.

Fängt sich mit einer Grundeinstellung von drei Bohnen vom Typ beginnen A, Bund Cmit Bund Cin injiziert werden 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; 
  }
}

Mit folgender XML-Konfiguration:

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

Das Laden des Kontexts erzeugt die folgende Ausgabe:

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

OK, dies ist die erwartete Ausgabe. Aber das ist Frühling im "alten Stil". Jetzt haben wir Anmerkungen, also lassen Sie uns diese verwenden, um das XML zu vereinfachen.

Lassen Sie uns zunächst die bbbund ccc-Eigenschaften auf Bean Awie folgt automatisch verdrahten :

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;
  }
}

Dadurch kann ich die folgenden Zeilen aus dem XML entfernen:

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

Mein XML ist jetzt so vereinfacht:

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

Wenn ich den Kontext lade, erhalte ich folgende Ausgabe:

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

OK, das ist falsch! Was ist passiert? Warum sind meine Immobilien nicht automatisch verdrahtet?

Nun, Anmerkungen sind eine nette Funktion, aber für sich genommen tun sie überhaupt nichts. Sie kommentieren nur Sachen. Sie benötigen ein Verarbeitungswerkzeug, um die Anmerkungen zu finden und etwas damit zu tun.

<context:annotation-config>zur Rettung. Dadurch werden die Aktionen für die Anmerkungen aktiviert, die auf den Beans gefunden werden, die im selben Anwendungskontext definiert sind, in dem sie selbst definiert sind.

Wenn ich mein XML in Folgendes ändere:

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

Wenn ich den Anwendungskontext lade, erhalte ich das richtige Ergebnis:

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

OK, das ist schön, aber ich habe zwei Zeilen aus dem XML entfernt und eine hinzugefügt. Das ist kein großer Unterschied. Die Idee mit Anmerkungen ist, dass es das XML entfernen soll.

Entfernen wir also die XML-Definitionen und ersetzen sie alle durch Anmerkungen:

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;
  }
}

Während wir im XML sind, behalten wir nur Folgendes bei:

<context:annotation-config />

Wir laden den Kontext und das Ergebnis ist ... Nichts. Es werden keine Bohnen erstellt, keine Bohnen werden automatisch verdrahtet. Nichts!

Das liegt daran, dass, wie ich im ersten Absatz sagte, die <context:annotation-config />einzige Funktion für Beans funktioniert , die im Anwendungskontext registriert sind. Da ich die XML-Konfiguration für die drei Beans entfernt habe, wurde keine Bean erstellt und es <context:annotation-config />gibt keine "Ziele", an denen gearbeitet werden kann.

Dies ist jedoch kein Problem, bei <context:component-scan>dem ein Paket nach "Zielen" durchsucht werden kann, an denen gearbeitet werden soll. Lassen Sie uns den Inhalt der XML-Konfiguration in den folgenden Eintrag ändern:

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

Wenn ich den Kontext lade, erhalte ich folgende Ausgabe:

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

Hmmmm ... etwas fehlt. Warum?

Wenn Sie sich die Klassen genau ansehen, hat die Klasse Aein Paket, com.yyyaber ich habe im <context:component-scan>zu verwendenden Paket angegeben, com.xxxdass dies meine AKlasse völlig verfehlt und nur abgeholt hat Bund Cwelche auf dem com.xxxPaket sind.

Um dies zu beheben, füge ich auch dieses andere Paket hinzu:

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

und jetzt bekommen wir das erwartete Ergebnis:

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

Und das ist es! Jetzt haben Sie keine XML-Definitionen mehr, sondern Anmerkungen.

Als letztes Beispiel, halten die kommentierten Klassen A, Bund Cund die folgenden auf die XML, was wir bekommen nach dem Kontext geladen?

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

Wir erhalten immer noch das richtige Ergebnis:

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

Auch wenn die Bean für die Klasse Anicht durch Scannen erhalten wird, werden die Verarbeitungswerkzeuge weiterhin <context:component-scan>auf alle im Anwendungskontext registrierten Beans angewendet , auch wenn Adiese manuell im XML registriert wurden.

Aber was ist, wenn wir das folgende XML haben, erhalten wir doppelte Beans, weil wir beide <context:annotation-config />und angegeben haben <context:component-scan>?

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

Nein, keine Duplikate. Wir erhalten wieder das erwartete Ergebnis:

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

Dies liegt daran, dass beide Tags dieselben Verarbeitungswerkzeuge registrieren ( <context:annotation-config />kann weggelassen werden, wenn dies <context:component-scan>angegeben ist), Spring jedoch dafür sorgt, dass sie nur einmal ausgeführt werden.

Selbst wenn Sie die Verarbeitungswerkzeuge mehrmals selbst registrieren, stellt Spring sicher, dass sie ihre Magie nur einmal ausführen. dieses 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" />

generiert weiterhin das folgende Ergebnis:

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

OK, das rappt es auf.

Ich hoffe, diese Informationen zusammen mit den Antworten von @Tomasz Nurkiewicz und @Sean Patrick Floyd sind alles, was Sie brauchen, um zu verstehen, wie <context:annotation-config>und wie <context:component-scan>.

Ich fand diese schöne Zusammenfassung, welche Anmerkungen von welchen Erklärungen aufgenommen werden. Wenn Sie es studieren, werden Sie feststellen, dass <context:component-scan/>eine Obermenge von Anmerkungen erkannt wird <context:annotation-config/>, die erkannt werden von :

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

Wie Sie sehen können <context:component-scan/>, werden die <context:annotation-config/> Funktionen für das Scannen von CLASSPATH-Komponenten und Java @ Configuration logisch erweitert .

Im Frühling können Sie zwei Dinge tun:

1. Autowiring von Bohnen
2. Autodiscovery von Bohnen

1. Autowiring
Normalerweise definieren Sie in applicationContext.xml Beans und andere Beans werden mit Konstruktor- oder Setter-Methoden verkabelt. Sie können Beans mithilfe von XML oder Anmerkungen verkabeln. Wenn Sie Anmerkungen verwenden, müssen Sie Anmerkungen aktivieren und <context:annotation-config />in applicationContext.xml hinzufügen . Dies vereinfacht die Struktur des Tags aus applicationContext.xml , da Sie Beans (Konstruktor oder Setter) nicht manuell verkabeln müssen. Sie können @AutowireAnnotation verwenden und die Beans werden nach Typ verdrahtet.

Ein Schritt vorwärts, um der manuellen XML-Konfiguration zu entkommen, ist

2. Autodiscovery
Autodiscovery vereinfacht das XML noch einen Schritt weiter, da Sie das <bean>Tag nicht einmal in applicationContext.xml hinzufügen müssen . Sie markieren einfach die spezifischen Beans mit einer der folgenden Anmerkungen, und Spring verbindet die markierten Beans und ihre Abhängigkeiten automatisch mit dem Spring-Container. Die Anmerkungen lauten wie folgt: @Controller , @Service , @Component , @Repository . Durch Verwenden <context:component-scan>und Zeigen des Basispakets erkennt Spring die Komponenten automatisch und verdrahtet sie mit dem Spring-Container.

Als Schlussfolgerung:

• <context:annotation-config />wird verwendet, um die Annotation @Autowired verwenden zu können
• <context:component-scan /> wird verwendet, um die Suche nach bestimmten Beans und den Versuch der automatischen Verdrahtung zu bestimmen.

<context:annotation-config> Aktiviert viele verschiedene Annotationen in Beans, unabhängig davon, ob sie in XML oder durch Scannen von Komponenten definiert sind.

<context:component-scan> dient zum Definieren von Beans ohne Verwendung von XML

Weitere Informationen finden Sie unter:

• 3.9. Annotationsbasierte Containerkonfiguration
• 3.10. Scannen von Klassenpfaden und verwaltete Komponenten

Der Unterschied zwischen den beiden ist wirklich einfach!.

<context:annotation-config /> 

Ermöglicht die Verwendung von Anmerkungen, die nur auf die Verkabelung von Eigenschaften und Konstruktoren von Beans beschränkt sind!.

Wohingegen

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

Ermöglicht alles, was zu <context:annotation-config />tun, mit Zusatz von mit Klischees zB .. @Component, @Service, @Repository. Sie können also ganze Bohnen verkabeln und sind nicht nur auf Konstruktoren oder Eigenschaften beschränkt!.

<context:annotation-config>: Scannen und Aktivieren von Anmerkungen für bereits registrierte Beans in Spring Config XML.

<context:component-scan>: Bohnenregistrierung +<context:annotation-config>

@Autowired und @Required sind Ziele Eigenschaftsniveau so Bohne im Frühjahr IOC vor der Verwendung dieser Zeichen registrieren soll. Um diese Annotationen zu aktivieren, müssen entweder die entsprechenden Beans registriert oder eingeschlossen werden <context:annotation-config />. dh <context:annotation-config />funktioniert nur mit registrierten Bohnen.

@Required aktiviert das RequiredAnnotationBeanPostProcessor Verarbeitungswerkzeug
@Autowired aktiviert das AutowiredAnnotationBeanPostProcessorVerarbeitungswerkzeug

Hinweis: Die Annotation selbst hat nichts zu tun. Wir benötigen ein Verarbeitungstool , eine Klasse darunter, die für den Kernprozess verantwortlich ist.

@Repository, @Service und @Controller sind @Component , und sie zielt auf Klassenebene .

<context:component-scan>Es scannt das Paket und findet und registriert die Beans. Es enthält die Arbeit von <context:annotation-config />.

Migrieren von XML zu Anmerkungen

Das <context:annotation-config>Tag weist Spring an, die Codebasis zu durchsuchen, um die Abhängigkeitsanforderungen der Klassen mit der Annotation @Autowired automatisch aufzulösen.

Spring 2.5 bietet außerdem Unterstützung für JSR-250-Annotationen wie @Resource, @PostConstruct und @ PreDestroy. Für die Verwendung dieser Annotationen müssen bestimmte BeanPostProcessors im Spring-Container registriert sein. Wie immer können diese als einzelne Bean-Definitionen registriert werden, sie können jedoch auch implizit registriert werden, indem das <context:annotation-config>Tag in die Federkonfiguration aufgenommen wird.

Entnommen aus der Spring-Dokumentation der annotationsbasierten Konfiguration

Spring bietet die Möglichkeit, 'stereotype' Klassen automatisch zu erkennen und entsprechende BeanDefinitions im ApplicationContext zu registrieren.

Laut javadoc von org.springframework.stereotype :

Stereotype sind Anmerkungen, die die Rolle von Typen oder Methoden in der Gesamtarchitektur angeben (eher auf konzeptioneller als auf Implementierungsebene). Beispiel: @Controller @Service @Repository usw. Diese sind für die Verwendung durch Tools und Aspekte vorgesehen (ein ideales Ziel für Pointcuts).

Um solche 'Stereotyp'-Klassen automatisch zu erkennen, ist ein <context:component-scan>Tag erforderlich.

Das <context:component-scan>Tag weist Spring außerdem an, den Code nach injizierbaren Beans unter dem angegebenen Paket (und allen zugehörigen Unterpaketen) zu durchsuchen.

<context:annotation-config>

Nur löst die @Autowiredund @QualiferAnmerkungen, das ist alles, es geht um die Injektion Abhängigkeit , Es gibt noch weitere Anmerkungen , die die gleiche Arbeit tun, denke ich , wie @Inject, aber alles über zu lösen DI durch Anmerkungen.

Beachten Sie, dass Sie auch dann, wenn Sie das <context:annotation-config>Element deklariert haben, Ihre Klasse als Bean deklarieren müssen. Denken Sie daran, dass wir drei Optionen zur Verfügung haben

• XML: <bean>
• @Annotationen: @Component, @Service, @Repository, @Controller
• JavaConfig: @Configuration, @Bean

Jetzt mit

<context:component-scan>

Es macht zwei Dinge:

• Es durchsucht alle mit @Component, @Service, @Repository, @Controller und @Configuration kommentierten Klassen und erstellt eine Bean
• Es macht den gleichen Job wie <context:annotation-config>.

Daher, wenn Sie deklarieren <context:component-scan>, ist es nicht mehr notwendig, auch <context:annotation-config>zu deklarieren .

Das ist alles

Ein häufiges Szenario war beispielsweise, nur eine Bean über XML zu deklarieren und den DI beispielsweise durch Anmerkungen aufzulösen

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

Wir haben nur die Beans deklariert, nichts über <constructor-arg>und <property>, der DI wird in ihren eigenen Klassen über @Autowired konfiguriert. Dies bedeutet, dass die Services @Autowired für ihre Repositorys-Komponenten und die Repositorys @Autowired für die JdbcTemplate-, DataSource- usw. Komponenten verwenden

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

Versuchen Sie es <context:component-scan base-package="..." annotation-config="false"/>in Ihrer Konfiguration mit @Service, @Repository, @Component , aber @ Autowired, @ Resource und @Inject funktionieren nicht.

Dies bedeutet, dass AutowiredAnnotationBeanPostProcessor nicht aktiviert wird und der Spring-Container die Autowiring-Anmerkungen nicht verarbeitet.

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

Der andere wichtige Punkt ist, dass context:component-scanimplizit die aufgerufen werden context:annotation-config, um die Annotationen auf Beans zu aktivieren. Wenn Sie context:component-scanAnnotationen nicht implizit für Sie aktivieren möchten , können Sie das Annotation-Config-Element von context:component-scanto weiter festlegen false.

Zusammenfassen:

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

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

Dies wird verwendet, um dem Container mitzuteilen, dass in meinem Paket Bean-Klassen vorhanden sind. Scannen Sie diese Bean-Klassen. Um Bean-Klassen nach Container über der Bean zu scannen, müssen wir eine der folgenden Stereo-Annotationen schreiben.

@Component, @Service, @Repository,@Controller

<context:annotation-config />::

Wenn wir das Bean-Tag nicht explizit in XML schreiben möchten, weiß der Container, ob in der Bean eine automatische Verkabelung vorhanden ist. Dies ist mithilfe von @AutowiredAnmerkungen möglich. Wir müssen dem Container mitteilen, dass in meiner Bohne eine automatische Verkabelung vorhanden ist context:annotation-config.

Ein <context:component-scan/>benutzerdefiniertes Tag registriert denselben Satz von Bean-Definitionen wie von, abgesehen von seiner Hauptverantwortung für das Scannen der Java-Pakete und das Registrieren von Bean-Definitionen aus dem Klassenpfad.

Wenn diese Registrierung von Standard-Bean-Definitionen aus irgendeinem Grund vermieden werden soll, müssen Sie dazu im Komponentenscan ein zusätzliches Attribut "annotation-config" angeben:

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

Referenz: http://www.java-allandsundry.com/2012/12/contextcomponent-scan-contextannotation.html

<context:annotation-config>::

Dies sagt Spring, dass ich kommentierte Bohnen als Frühlingsbohnen verwenden werde und diese durchverdrahtet würden @Autowired Annotation , anstatt in der XML-Datei für die Frühlingskonfiguration zu deklarieren.

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

Dies teilt Spring Container mit, wo mit der Suche nach diesen kommentierten Beans begonnen werden soll. Hier durchsucht spring alle Unterpakete des Basispakets.

Weitere Informationen finden Sie in der Spring-Kontextschemadatei. Folgendes ist in spring-context-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.

Als Ergänzung können Sie die Verwendung @ComponentScanals <context:component-scan>Annotation verwenden.

Es ist auch bei spring.io beschrieben

Konfiguriert Anweisungen zum Scannen von Komponenten für die Verwendung mit @ Configuration-Klassen. Bietet Unterstützung parallel zum Spring XML-Element.

Wenn Sie Spring Boot verwenden, können Sie @Configuration und @ComponentScan mithilfe der Annotation @SpringBootApplication implizieren.