Spring为什么Autowired注入的是接口

1. 1.Spring怎么知道注入哪个实现?  
2. As long as there is only a single implementation of the interface and that implementation is annotated with @Component with Spring’s component scan enabled, Spring framework can find out the (interface, implementation) pair. If component scan is not enabled, then you have to define the bean explicitly in your application-config.xml (or equivalent spring configuration file).   
3. 如果Spring配置了component scan，并且要注入的接口只有一个实现的话，那么spring框架可以自动将interface于实现组装起来。如果没有配置component scan，那么你必须在application-config.xml（或等同的配置文件）定义这个bean。  
4.   
5.   
6. 2.需要@Qualifier和@Resource注解吗?  
7. Once you have more than one implementation, then you need to qualify each of them and during auto-wiring, you would need to use the @Qualifier annotation to inject the right implementation, along with @Autowired annotation. If you are using @Resource (J2EE semantics), then you should specify the bean name using the name attribute of this annotation.   
8. 一旦一个接口有多个实现，那么就需要每个特殊化识别并且在自动装载过程中使用@Qualifier和@Autowired一起使用来标明。如果是使用@Resource注解，那么你应该使用resource中属性名称来标注@Autowired.  
9.   
10.   
11. 3.为什么@Autowired使用在interface上而不是实现类上？  
12. Firstly, it is always a good practice to code to interfaces in general. Secondly, in case of spring, you can inject any implementation at runtime. A typical use case is to inject mock implementation during testing stage.   
13. 首先，一般使用接口是很常用并且有益的变成技术。其次，在spring中，你可以在运行过程中注入各种实现。一个很经典的情况就是在测试阶段，注入模拟的实现类。   
14. interface IA   
15. {   
16. public void someFunction();   
17. }  
18.   
19.   
20. class B implements IA   
21. {   
22. public void someFunction()   
23. {   
24. //busy code block   
25. }   
26. public void someBfunc()   
27. {   
28. //doing b things   
29. }   
30. }  
31.   
32.   
33. class C implements IA   
34. {   
35. public void someFunction()   
36. {   
37. //busy code block   
38. }   
39. public void someCfunc()   
40. {   
41. //doing C things   
42. }   
43. }  
44.   
45.   
46. `class MyRunner   
47. {   
48. @Autowire   
49. @Qualifier(“b”)  
50. IA worker;  
51.   
52.   
53. ....  
54. worker.someFunction();  
55. }`   
56. Your bean configuration should look like this:  
57.   
58.   
59.   
60.   
61.   
62. Alternatively, if you enabled component scan on the package where these are present, then you should qualify each class with @Component as follows:  
63.   
64.   
65. interface IA   
66. {   
67. public void someFunction();   
68. }  
69.   
70.   
71. @Component(value="b")   
72. class B implements IA   
73. {   
74. public void someFunction()   
75. {   
76. //busy code block   
77. }   
78. public void someBfunc()   
79. {   
80. //doing b things   
81. }   
82. }  
83.   
84.   
85. @Component(value="c")   
86. class C implements IA   
87. {   
88. public void someFunction()   
89. {   
90. //busy code block   
91. }   
92. public void someCfunc()   
93. {   
94. //doing C things   
95. }   
96. }  
97.   
98.   
99. `@Component   
100. class MyRunner   
101. {   
102. @Autowire   
103. @Qualifier(“b”)  
104. IA worker;  
105.   
106.   
107. ....  
108. worker.someFunction();  
109. }`