spring 注解的 跟 诠释及区别

<context:annotation-config> 和 <context:component-scan>的区别

Difference between <context:annotation-config> vs <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中.

 

[java] view plain copy

 print?

1. package com.xxx;  
2. public class B {  
3.   public B() {  
4.     System.out.println("creating bean B: " + this);  
5.   }  
6. }  
7.   
8. package com.xxx;  
9. public class C {  
10.   public C() {  
11.     System.out.println("creating bean C: " + this);  
12.   }  
13. }  
14.   
15. package com.yyy;  
16. import com.xxx.B;  
17. import com.xxx.C;  
18. public class A {   
19.   private B bbb;  
20.   private C ccc;  
21.   public A() {  
22.     System.out.println("creating bean A: " + this);  
23.   }  
24.   public void setBbb(B bbb) {  
25.     System.out.println("setting A.bbb with " + bbb);  
26.     this.bbb = bbb;  
27.   }  
28.   public void setCcc(C ccc) {  
29.     System.out.println("setting A.ccc with " + ccc);  
30.     this.ccc = ccc;   
31.   }  
32. }  

 

 

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

 

加载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配置文件

首先，咱们使用autowire的方式将对象bbb和ccc注入到A中：

 

 

[java] view plain copy

 print?

1. package com.yyy;  
2. import org.springframework.beans.factory.annotation.Autowired;  
3. import com.xxx.B;  
4. import com.xxx.C;  
5. public class A {   
6.   private B bbb;  
7.   private C ccc;  
8.   public A() {  
9.     System.out.println("creating bean A: " + this);  
10.   }  
11.   @Autowired  
12.   public void setBbb(B bbb) {  
13.     System.out.println("setting A.bbb with " + bbb);  
14.     this.bbb = bbb;  
15.   }  
16.   @Autowired  
17.   public void setCcc(C ccc) {  
18.     System.out.println("setting A.ccc with " + ccc);  
19.     this.ccc = ccc;  
20.   }  
21. }  

 

 

 

而后，咱们就能够从applicationContext.xml中移除下面的配置

 

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

 

移除以后，咱们的applicationContext.xml配置文件就简化为下面的样子了

 

<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@5e5a50
creating bean C: com.xxx.C@54a328
creating bean A: com.yyy.A@a3d4cf

 

OK, 结果是错误的的，到底是由于什么呢？为何咱们的属性没有被注入进去呢？

是由于注解自己并不可以作任何事情，它们只是最基本的组成部分，咱们须要可以处理这些注解的处理工具来处理这些注解

这就是<context:annotation-config> 所作的事情

咱们将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

 

OK, 结果正确了。

 

下面演示<context:annotation-config> 跟 <context:component-scan>区别：

可是若是咱们将代码做以下修改：

 

 

[java] view plain copy

 print?

1. package com.xxx;  
2. import org.springframework.stereotype.Component;  
3. @Component  
4. public class B {  
5.   public B() {  
6.     System.out.println("creating bean B: " + this);  
7.   }  
8. }  
9.   
10. package com.xxx;  
11. import org.springframework.stereotype.Component;  
12. @Component  
13. public class C {  
14.   public C() {  
15.     System.out.println("creating bean C: " + this);  
16.   }  
17. }  
18.   
19. package com.yyy;  
20. import org.springframework.beans.factory.annotation.Autowired;  
21. import org.springframework.stereotype.Component;  
22. import com.xxx.B;  
23. import com.xxx.C;  
24. @Component  
25. public class A {   
26.   private B bbb;  
27.   private C ccc;  
28.   public A() {  
29.     System.out.println("creating bean A: " + this);  
30.   }  
31.   @Autowired  
32.   public void setBbb(B bbb) {  
33.     System.out.println("setting A.bbb with " + bbb);  
34.     this.bbb = bbb;  
35.   }  
36.   @Autowired  
37.   public void setCcc(C ccc) {  
38.     System.out.println("setting A.ccc with " + ccc);  
39.     this.ccc = ccc;  
40.   }  
41. }  

 

 

 

 

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

 

当咱们加载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,com.yyy"/><context:component-scan base-package="com.xxx"/>

而后加载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 base-package="com.xxx,com.yyy"/><context:component-scan base-package="com.xxx"/>

 

了。

 

那若是咱们在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仍然只会处理一次：

 

[xml] view plain copy

 print?

1. <context:annotation-config />  
2. <context:component-scan base-package="com.xxx" />  
3. <bean id="aBean" class="com.yyy.A" />  
4. <bean id="bla" class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />  
5. <bean id="bla1" class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />  
6. <bean id="bla2" class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />  
7. <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