spring中<context:annotation-config> 和<context:component-scan>详解及区别

谁践踏了优雅 2021-12-10 15:49 177阅读 0赞

我们一般在含有Spring的项目中，可能会看到配置项中包含这个配置节点<context:annotation-config>，这是一条向Spring容器中注册AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、*PersistenceAnnotationBeanPostProcesso和　*RequiredAnnotationBeanPostProcessor这四个组件。注册这4个BeanPostProcessor的作用，就是为了你的系统能够识别相应的注解。

如果想使用@ Resource 、@ PostConstruct、@ PreDestroy等注解就必须声明CommonAnnotationBeanPostProcessor。  
如果想使用@PersistenceContext注解，就必须声明PersistenceAnnotationBeanPostProcessor的Bean。  
如果想使用@Autowired注解，那么就必须事先在 Spring 容器中声明 AutowiredAnnotationBeanPostProcessor Bean。  
如果想使用 @Required的注解，就必须声明RequiredAnnotationBeanPostProcessor的Bean。

当然，如果我们不使用<context:annotation-config>，那么就可以在spring的xml配置文件中加入它们，如下面方式加入：

这样太麻烦了，还是用<context:annotation-config>方便。

<context:annotation-config>是用于激活那些已经在spring容器里注册过的bean（无论是通过xml的方式还是通过package sanning的方式）上面的注解。<context:annotation-config />仅能够在已经注册过的bean上面起作用。对于没有在spring容器中注册的bean，它并不能执行任何操作，不起任何作用。

使用<context:component-scan>可以替换掉<context:annotation-config />，<context:component-scan>除了具有<context:annotation-config />的功能之外，<context:component-scan>还可以在指定的package下扫描以及注册javabean 。还具有自动将带有@component,@service,@Repository等注解的对象注册到spring容器中的功能。

示例如下：

<context:annotation-config> 和 <context:component-scan>的区别 
    <context:annotation-config> 是用于激活那些已经在spring容器里注册过的bean（无论是通过xml的方式还是通过package sanning的方式）上面的注解。
    <context:component-scan>除了具有<context:annotation-config>的功能之外，<context:component-scan>还可以在指定的package下扫描以及注册javabean 。 
    下面我们通过例子来详细查看他们的区别，有三个class 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; 
      }
    }

在applicationContext.xml中加入下面的配置 :

加载applicationContext.xml配置文件，将得到下面的结果:
    
    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的方式，不过太过时了，下面通过注解的方式来简化我们的xml配置文件

下边看看怎么使用<context:annotation-config>和 <context:component-scan>
    
    首先，我们使用autowire的方式将对象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;
      }
    }

然后applicationContext.xml配置文件去除属性就简化为下面的样子了

当我们加载applicationContext.xml配置文件之后，将得到下面的结果：
    
    creating bean B: com.xxx.B@5e5a50
    creating bean C: com.xxx.C@54a328
    creating bean A: com.yyy.A@a3d4cf
    
    
    
    OK, ClassA中显然没有注入属性，结果是错误的的，究竟是因为什么呢？为什么我们的属性没有被注入进去呢？
    
    是因为注解本身并不能够做任何事情，它们只是最基本的组成部分，我们需要能够处理这些注解的处理工具来处理这些注解。

这就是<context:annotation-config> 所做的事情，用于激活那些已经在spring容器里注册过的bean
    
    我们将applicationContext.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"/>
    
    这回，当我们加载applicationContext.xml配置文件之后，将得到下面的结果：
    
    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
    
    结果正确了

但是如果我们将代码作如下修改

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

applicationContext.xml配置文件修改为：

<context:annotation-config />

当我们加载applicationContext.xml配置文件之后，却没有任何输出，这是为什么呢？
    
    那是因为<context:annotation-config />仅能够在已经在已经注册过的bean上面起作用。
    
    对于没有在spring容器中注册的bean，它并不能执行任何操作。
    
    但是不用担心，<context:component-scan>除了具有<context:annotation-config />的功能之外，还具有自动将带有@component,@service,@Repository等注解的对象注册到spring容器中的功能。
    
    我们将applicationContext.xml配置文件作如下修改：

<context:component-scan base-package="com.xxx"/>//此种写法正确
    
    <context:component-scan base-package="com.xxx.*"/>//此种写法错误，不能加通配符*

当我们加载applicationContext.xml的时候，会得到下面的结果：

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

这是什么原因呢？

是因为我们仅仅扫描了com.xxx包及其子包的类，而class  A是在com.yyy包下，所以就扫描不到了

下面我们在applicationContext.xml中把com.yyy也加入进来：

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

然后加载applicationContext.xml就会得到下面的结果：
    
    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
    
    
    
    哇，结果正确啦 ！
    
    回头看下我们的applicationContext.xml文件，已经简化为两行context:component-scan了，是不是很简单？
    
    
    
    那如果我们在applicationContext.xml手动加上下面的配置，
    
    也就是说既在applicationContext.xml中手动的注册了A的实例对象，同时，通过component-scan去扫描并注册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
    
    
    
    虽然class A并不是通过扫描的方式注册到容器中的 ，
    
    但是<context:component-scan> 所产生的的处理那些注解的处理器工具，会处理所有绑定到容器上面的bean，不管是通过xml手动注册的还是通过scanning扫描注册的。
    
    那么，如果我们通过下面的方式呢？我们既配置了<context:annotation-config />，又配置了<context:component-scan base-package="com.xxx" />，它们都具有处理在容器中注册的bean里面的注解的功能。会不会出现重复注入的情况呢？
    
    <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>同时存在的时候，前者会被忽略。
    
    也就是那些@autowire，@resource等注入注解只会被注入一次
    
    哪怕是你手动的注册了多个处理器，spring仍然只会处理一次：
    
    <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

参考：[https://blog.csdn.net/qq\_21439971/article/details/51462268][https_blog.csdn.net_qq_21439971_article_details_51462268]

[https://www.cnblogs.com/\_popc/p/3972212.html][https_www.cnblogs.com_popc_p_3972212.html]

[https://blog.csdn.net/u010081710/article/details/77187366][https_blog.csdn.net_u010081710_article_details_77187366]

[https_blog.csdn.net_qq_21439971_article_details_51462268]: https://blog.csdn.net/qq_21439971/article/details/51462268
[https_www.cnblogs.com_popc_p_3972212.html]: https://www.cnblogs.com/_popc/p/3972212.html
[https_blog.csdn.net_u010081710_article_details_77187366]: https://blog.csdn.net/u010081710/article/details/77187366