Difference between <context:annotation-config> and <context:component-scan>

#1 楼

<context:annotation-config>用于激活已在应用程序上下文中注册的bean中的注释（无论它们是使用XML定义还是通过包扫描定义的。）<context:component-scan>也可以执行<context:annotation-config>的操作，但是<context:component-scan>还将包扫描到在应用程序上下文中查找并注册bean。

我将使用一些示例来展示差异/相似性。

让我们开始基本配置三个类型为A，B和C的bean，然后将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

OK ，这是预期的输出。但这是“旧风格”的春天。现在我们有了注释，因此让我们使用它们来简化XML。首先，让我们自动装配bean 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>来救援。这将激活对在定义自身的相同应用程序上下文中定义的bean上发现的注释的操作。

如果我将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中删除了两行并添加了一行。那不是很大的区别。带注释的想法是应该删除XML。

因此，让我们删除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;
  }
}

在XML中，我们仅保留以下内容：

<context:annotation-config />

我们加载上下文，结果是……什么都没有。没有创建bean，也没有自动装配bean。没什么！

这是因为，正如我在第一段中所述，<context:annotation-config />仅适用于在应用程序上下文中注册的bean。因为我删除了这三个bean的XML配置，所以没有创建bean，并且<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并将以下内容添加到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类的bean，<context:component-scan>仍会在应用程序上下文中对所有已注册的bean应用处理工具，即使对于已在XML中手动注册的A，也是如此。
但是如果我们有以下XML，会得到重复的bean，因为我们同时指定了<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>），但是Spring会负责运行它们

即使您多次注册处理工具，Spring仍将确保它们仅执行一次魔术；此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>的工作方式。

#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/>逻辑扩展了<context:annotation-config/>并使用CLASS扩展了q4312079q Java @Configuration功能。

#3 楼

Spring允许您做两件事：


自动装配beans
自动发现beans

1。自动装配
通常，在applicationContext.xml中，您定义Bean，而其他Bean则使用
构造器或setter方法进行接线。您可以使用XML或注释对bean进行接线。
如果使用注释，则需要激活注释，并且必须在applicationContext.xml中添加
<context:annotation-config />。这将简化applicationContext.xml中标记的
结构，因为您不必手动连接bean（构造函数或setter）。您可以使用@Autowire批注，并且将按类型对bean进行接线。

转义手动XML配置的第一步是

2。自动发现
自动发现将XML进一步简化了，因为您甚至不需要在applicationContext.xml中添加<bean>标记。您只需使用以下注释之一标记特定的bean，Spring就会自动将标记的bean及其依赖项连接到Spring容器中。注释如下：@ Controller，@ Service，@ Component，@ Repository。通过使用<context:component-scan>并指向基本包，Spring将自动发现并将组件连接到Spring容器中。


作为结论：



<context:annotation-config />用于能够使用
@Autowired注释

<context:component-scan />用于确定特定于Bean的搜索和自动装配尝试。
/>

#4 楼

<context:annotation-config>激活bean中的许多不同注解，无论它们是用XML定义还是通过组件扫描定义。 br />

3.10。类路径扫描和托管组件

#5 楼

<context:annotation-config>：在spring config xml中扫描和激活已注册的bean的注释。

<context:component-scan>：Bean注册+ <context:annotation-config>


@Autowired和@Required是目标属性级别因此，在使用这些注释之前，bean应该在spring IOC中注册。要启用这些注释，必须注册相应的bean或包含<context:annotation-config />。即<context:annotation-config />仅适用于已注册的bean。

@必需启用RequiredAnnotationBeanPostProcessor处理工具@Autowired启用AutowiredAnnotationBeanPostProcessor处理工具

注意：注释本身无能为力，我们需要处理工具，这是底层的类，负责核心流程。


@ Repository，@ Service和@Controller是@Component，它们以类级别为目标。

<context:component-scan>扫描软件包并查找并注册Bean，其中包括<context:annotation-config />完成的工作。

将XML迁移到注释

#6 楼

两者之间的区别真的很简单！。

<context:annotation-config /> 

使您能够使用仅限于连接属性和构造器的注解！。

在哪里

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

启用<context:annotation-config />可以做的所有事情，另外还使用构造型，例如@Component，@Service，@Repository。因此，您可以连接整个bean，而不仅限于构造函数或属性！

#7 楼

<context:annotation-config>标签告诉Spring扫描代码库以自动解决包含@Autowired注释的类的依赖关系要求。

Spring 2.5还添加了对JSR-250注释的支持，例如@ Resource，@ PostConstruct和@ PreDestroy。使用这些批注还需要在Spring容器内注册某些BeanPostProcessor。与往常一样，这些可以注册为单独的bean定义，但是也可以通过在Spring配置中包含<context:annotation-config>标记来隐式注册。

取自基于批注的Spring配置文档


Spring提供了自动检测“定型”类并使用ApplicationContext注册相应BeanDefinition的功能。

根据org.springframework.stereotype的javadoc：

刻板印象是表示类型或方法在整个体系结构中的作用的注释（在概念上而不是在实现上）。
示例：@Controller @Service @Repository等。
这些旨在供工具和方面使用（使切入点成为理想目标）。

要自动检测此类“定型”类，则需要<context:component-scan>标签。

<context:component-scan>标签还告诉Spring在指定的程序包（及其所有子程序包）下扫描代码以查找可注射的bean。

#8 楼

<context:annotation-config>

仅解析@Autowired和@Qualifer批注，仅此而已，它与依赖注入有关。还有其他批注执行相同的工作，我认为@Inject的工作方式相同，但所有这些都将通过批注解决DI。

请注意，即使您已经声明了<context:annotation-config>元素，也无论如何必须声明您的类如何成为Bean，请记住我们有三个可用的选项。


XML： <bean>
@Annotations：@ Component，@ Service，@ Repository，@ Controller
JavaConfig：@Configuration，@Bean

现在带有

<context:component-scan>

它有两件事：


它扫描所有带有
@ Component，@ Service，@ Repository，@ Controller和@Configuration注释的类。创建Bean
与<context:annotation-config>的作用相同。 />
常见的情况是例如声明onl ya bean通过XML并通过注释解析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" />

我们只声明了bean，与<context:component-scan>和<context:annotation-config>无关，DI是自己配置的通过@Autowired类。这意味着服务将@Autowired用于其存储库组件，而存储库将@Autowired用于JdbcTemplate，DataSource等。.components

#9 楼

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

尝试使用<context:component-scan base-package="..." annotation-config="false"/>，在您的配置@ Service，@ Repository，@ Component正常工作，但是@ Autowired，@ Resource和@Inject无法正常工作。

此意味着将不会启用AutowiredAnnotationBeanPostProcessor，并且Spring容器将不会处理Autowiring注释。

#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来激活bean上的注释。好吧，如果您不想让context:component-scan为您隐式激活注释，则可以继续将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 -->

#11 楼

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

这是用来告诉容器我的包中有Bean类，请扫描这些Bean类。为了按容器在Bean顶部扫描Bean类，我们必须编写一个立体声类型注释，如下所示。

：

如果我们不想用XML显式编写bean标签，那么容器如何知道bean中是否存在自动接线。通过使用@Component批注，这是可能的。我们必须通过@Service通知容器我的bean中有自动接线。

#12 楼

一个<context:component-scan/>自定义标记除了注册Java包并从类路径注册Bean定义的主要职责外，还注册了与Bean相同的Bean定义集。避免使用bean定义，方法是在component-scan中指定一个附加的“ annotation-config”属性，方法是：

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

参考：
http://www.java-allandsundry.com/2012/12/contextcomponent-scan-contextannotation.html

#13 楼

<context:annotation-config>：

这告诉Spring我将使用带注释的bean作为spring bean，并且这些将通过@Autowired注释进行连接，而不是在spring config xml文件中声明。

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

告诉Spring容器，从哪里开始搜索那些带注释的bean。在这里spring将搜索基本包的所有子包。

#14 楼

您可以在spring上下文模式文件中找到更多信息。
紧随其后的是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.

#15 楼

作为补充，您可以使用@ComponentScan以注释方式使用<context:component-scan>。

还将在spring.io中进行描述。


配置组件扫描指令以与
@Configuration类一起使用。提供与Spring XML的
元素并行的支持。要注意的一件事，如果您使用的是Spring Boot，则可以使用@SpringBootApplication隐含@Configuration和@ComponentScan。注解。