依赖注入IOC的解析

朱雀 2021-09-15 02:28 639阅读 0赞

Spring 能有效地组织J2EE应用各层的对象。不管是控制层的Action对象，还是业务层的Service对象，还是持久层的DAO对象，  
都可在Spring的 管理下有机地协调、运行。Spring将各层的对象以松耦合的方式组织在一起，Action对象无须关心Service对  
象的具体实现，Service对 象无须关心持久层对象的具体实现，各层对象的调用完全面向接口。当系统需要重构时，代码的改  
写量将大大减少。  
  
　　 上面所说的一切都得宜于Spring的核心机制，依赖注入。依赖注入让bean与bean之间以配置文件组织在一起，而不是以硬  
编码的方式耦合在一起。理解依赖注入。  
  
　　 依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。  
具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，  
在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，  
因此，称为控制反转;创建被调用者实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。  
  
spring的控制反转：把对象的创建、初始化、销毁等工作交给spring容器来做。由spring容器 控制对象的生命周期。

不管是依赖注入，还是控制反转，都说明Spring采用动态、灵活的方式来管理各种对象。对象与对象之间的具体实现互  
相透明。在理解依赖注入之前，看如下这个问题在各种社会形态里如何解决:一个人(Java实例，调用者)需要一把斧子(Java实  
例，被调用者)。  
  
　　 (1)原始社会里，几乎没有社会分工。需要斧子的人(调用者)只能自己去磨一把斧子(被调用者)。对应的情形为:Java程序  
里的调用者自己创建被调用者。  
  
　　 (2)进入工业社会，工厂出现。斧子不再由普通人完成，而在工厂里被生产出来，此时需要斧子的人(调用者)找到工厂，购  
买斧子，无须关心斧子的制造过程。对应Java程序的简单工厂的设计模式。  
  
　　 (3)进入“按需分配”社会，需要斧子的人不需要找到工厂，坐在家里发出一个简单指令:需要斧子。斧子就自然出现在他面前。  
对应Spring的依赖注入。  
  
　　 第一种情况下，Java实例的调用者创建被调用的Java实例，必然要求被调用的Java类出现在调用者的代码里。无法实现二者  
之间的松耦合。  
  
　   第二种情况下，调用者无须关心被调用者具体实现过程，只需要找到符合某种标准(接口)的实例，即可使用。此时调用的代  
码面向接口编程，可以让调用者和被调用者解耦，这也是工厂模式大量使用的原因。但调用者需要自己定位工厂，调用者与特定工  
厂耦合在一起。  
  
　   第三种情况下，调用者无须自己定位工厂，程序运行到需要被调用者时，系统自动提供被调用者实例。事实上，调用者和被调  
用者都处于Spring的管理下，二者之间的依赖关系由Spring提供。  
  
　   所谓依赖注入，是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部的注入。  
Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理。依赖注入通常有两种:

(哎，POJO知道是啥吗？不知道的话，看链接，如下：[POJO是什么，怎么理解，大师兄查了，看看吧。点我。][POJO])  
·设值注入。  
·构造注入。

一、设值注入。  
设值注入是指通过setter方法传入被调用者的实例。这种注入方式简单、直观，因而在Spring的依赖注入里大量使用。  
看下面代码：

**\[java\]**  [view plain][]   [copy][view plain]

1.  package com.fusionskye.ezsonar.model.configcenter;  
2.    
3.  //上面的这个包名和配置文件里面的bean类的class属性对应,要测试的话，自己修改成自己的  
4.    
5.  import org.springframework.context.ApplicationContext;  
6.  import org.springframework.context.support.FileSystemXmlApplicationContext;  
7.    
8.  /\*\* 定义Person接口 \*/  
9.  interface Person \{  
10.     void useAxe();  //Person接口里定义一个使用斧子的方法  
11. \}  
12.   
13. /\*\* 定义Axe(斧子英文Axe)接口 \*/  
14. interface Axe \{  
15.     String chop(); //Axe接口里有个砍(chop)的方法,原作里面是void，但是这里应该是返回String类型  
16. \}  
17.   
18. /\*\* 
19.  \* Person的实现类 
20.  \* Chinese实现Person接口 
21.  \*/  
22. class Chinese implements Person \{  
23.     /\*\* 面向Axe(斧子)接口编程，而不是具体的实现类 \*/  
24.     private Axe axe;  
25.   
26.     /\*\* 默认的构造器 \*/  
27.     public Chinese() \{ \}  
28.   
29.     /\*\* 
30.      \* 设值注入所需的setter方法 
31.      \* 在xml配置文件中要用到此属性，所以访问权限要public，不能不写 
32.      \*/  
33.     public void setAxe(Axe axe) \{ this.axe = axe; \}  
34.   
35.     /\*\* 实现Person接口的useAxe方法 \*/  
36.     public void useAxe() \{ System.out.println(axe.chop()); \}  
37. \}  
38.   
39. /\*\* 
40.  \* Axe的第一个实现类 StoneAxe 石斧 
41.  \*/  
42. class StoneAxe implements Axe \{  
43.   
44.     /\*\* 默认构造器 \*/  
45.     StoneAxe() \{ \}  
46.   
47.     /\*\* 实现Axe接口的chop方法 \*/  
48.     public String chop() \{ return "石斧砍柴好慢"; \}  
49. \}  
50.   
51. /\*\* 
52.  \* Axe的第二个实现类 SteelAxe 钢斧 
53.  \*/  
54. class SteelAxe implements Axe\{  
55.     /\*\* 默认构造器 \*/  
56.     public SteelAxe() \{ \}  
57.   
58.     /\*\* 实现Axe接口的chop方法 \*/  
59.     @Override  
60.     public String chop() \{  
61.         return "钢斧砍柴真快";  
62.     \}  
63. \}  
64. /\*\* 
65.  \* Created by lxk on 2016/9/14 
66.  \*/  
67. class Cmt \{  
68.     /\*\* 
69.      \* 对上面的有的public权限控制给省略是因为只在一个包下使用，所以就使得权限变成了包内权限，然后就直接不写 
70.      \*/  
71.     public static void main(String\[\] args) \{  
72.         Chinese chinese = new Chinese();  
73.         StoneAxe stoneAxe = new StoneAxe();  
74.         //设值注入是指通过setter方法传入被调用者的实例  
75.         //如上句的解释：具体的斧子对象不是由人来初始化,而是如上所述的设值注入。  
76.         chinese.setAxe(stoneAxe);  
77.   
78.         //上面的Chinese和石斧都是我们自己new的，要是在Spring容器，就由容器来初始化.  
79.         chinese.useAxe();  
80. //这里 示范了两种实现方式，上面的是自己手动的实现设值注入，下面的是spring里面根据配置文件来实现设值注入  
81.         System.out.println("---------下面是配置文件实现设置注入------------");  
82.         //因为是独立的应用程序，显式地实例化Spring的上下文。下面是启动spring容器代码：寻找配置文件实例化容器  
83.         ApplicationContext ctx = new FileSystemXmlApplicationContext("sss.xml");  
84.         //通过Person bean的id来获取bean实例，面向接口编程，因此  
85.         //此处强制类型转换为接口类型  
86.         Person p = (Person) ctx.getBean("chinese");  
87.         //直接执行Person的userAxe()方法。  
88.         p.useAxe();  
89.     \}  
90. \}

上面是Java的测试代码，下面是对应的配置文件，sss.xml文件，具体内容如下：

**\[html\]**  [view plain][]   [copy][view plain]

1.  <?xml version="1.0" encoding="UTF-8"?>  
2.  <beans xmlns="http://www.springframework.org/schema/beans"  
3.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">  
5.    
6.        
7.      <bean id="chinese" class="com.fusionskye.ezsonar.model.configcenter.Chinese">  
8.            
9.            
10.           
11.         <property name="axe" ref ="stoneAxe">  
12.         </property>  
13.     </bean>  
14.       
15.     <bean id="stoneAxe" class="com.fusionskye.ezsonar.model.configcenter.StoneAxe"/>  
16.   
17.       
18.     <bean id="steelAxe" class="com.fusionskye.ezsonar.model.configcenter.SteelAxe"/>  
19. </beans>  
20.   
21.   
22.   
23.

对于上述的配置文件，再有如下的多嘴几句，估计对小白(没有接受过正规Java学习,半路出家做Java的人)还是有用的.  
整个配置文件作用：以配置文件的形式把类放入到spring容器中。  
在<beans></beans>这个里面就相当于是整个spring的bean的大包，需要将什么类纳入到spring容器中，就得在这个里面进行声明。  
上面就是声明了三个类到这个spring容器里面，  
正规的项目的配置文件叫：ApplicationContext.xml 是个图标带羽毛状的文件。  
关于id和class的正规写法；  
id    是：类的第一个字母变成小写，其余不变。  
class 是：类的全名。

我觉得本大师兄的注释写的以及非常详细啦吧。

从配置文件中，可以看到Spring管理bean的灵巧性。bean与bean之间的依赖关系放在配置文件里组织，而不是写在代码里。通过配置  
文件的 指定，Spring能精确地为每个bean注入属性。因此，配置文件里的bean的class元素，不能仅仅是接口，而必须是真正的实现类。  
  
　　 Spring会自动接管每个bean定义里的property元素定义。Spring会在执行无参数的构造器后、创建默认的bean实例后，调用对应  
 的setter方法为程序注入属性值。property定义的属性值将不再由该bean来主动创建、管理，而改为被动接收Spring的注入。  
  
　　 每个bean的id属性是该bean的惟一标识，程序通过id属性访问bean，bean与bean的依赖关系也通过id属性完成。

下面上测试的结果，如下：

第一张图是，配置文件里面用的是石斧，代码里面自己new Chinese和stoneAxe的对象测试设置注入的结果。  
![20160915011002898][]

第二张图, 测试的结果，配置文件里面修改 使用钢斧bean，上面的没修改的执行结果，如下：

![20160915011130269][]

Person与Axe之间没有任何代码耦合关系，bean与bean之间的依赖关系由Spring管理。采用setter方法为目标bean注入属性的方式，称为设值注入。  
  
　　 业务对象的更换变得相当简单，对象与对象之间的依赖关系从代码里分离出来，通过配置文件动态管理。

二、 构造注入  
  
  
　　所谓构造注入，指通过构造函数来完成依赖关系的设定，而不是通过setter方法。对前面代码Chinese类做简单的修改，修改后的代码如下:

**\[java\]**  [view plain][]   [copy][view plain]

1.  /\*\* 
2.   \* Person的实现类 
3.   \* Chinese实现Person接口 
4.   \*/  
5.  class Chinese implements Person \{  
6.      /\*\* 面向Axe(斧子)接口编程，而不是具体的实现类 \*/  
7.      private Axe axe;  
8.    
9.      /\*\* 默认的构造器 \*/  
10.     public Chinese() \{ \}  
11.   
12.     /\*\* 构造注入所需的带参数的构造器 \*/  
13.     public Chinese(Axe axe) \{  
14.         this.axe = axe;  
15.     \}  
16.   
17.     /\*\* 实现Person接口的useAxe方法 \*/  
18.     public void useAxe() \{ System.out.println(axe.chop()); \}  
19. \}

此时无须Chinese类里的setAxe方法，构造Person实例时，Spring为Person实例注入所依赖的Axe实例。  
构造注入的配置文件也需做简单的修改，修改后的配置文件如下:

**\[html\]**  [view plain][]   [copy][view plain]

执行效果与使用steelAxe设值注入时的执行效果完全一样。

区别在于:创建Person实例中Axe属性的时机不同——设值注入是先创建一个默认的bean实例，  
然后调用对应的构造方法注入依赖关系。而构造注入则在创建bean实例时，已经完成了依赖关系的

[POJO]: http://blog.csdn.net/qq_27093465/article/details/52527270
[view plain]: https://blog.csdn.net/qq_27093465/article/details/52547290#
[20160915011002898]: /images/20210811/f9e21ea5ce2c4063b6d9986abff11588.png
[20160915011130269]: /images/20210811/46df52bc7a784275b96dca99a4fdcc85.png