【Spring学习笔记】之【3.1DI的配置使用 一】

3.1.1  依赖和依赖注入

      传统应用程序设计中所说的依赖一般指“类之间的关系”，那先让我们复习一下类之间的关系：

泛化：表示类与类之间的继承关系、接口与接口之间的继承关系；

实现：表示类对接口的实现；

依赖：当类与类之间有使用关系时就属于依赖关系，不同于关联关系，依赖不具有“拥有关系”，而是一种“相识关系”，只在某个特定地方（比如某个方法体内）才有关系。

关联：表示类与类或类与接口之间的依赖关系，表现为“拥有关系”；具体到代码可以用实例变量来表示；

聚合：属于是关联的特殊情况，体现部分-整体关系，是一种弱拥有关系；整体和部分可以有不一样的生命周期；是一种弱关联；

组合：属于是关联的特殊情况，也体现了体现部分-整体关系，是一种强“拥有关系”；整体与部分有相同的生命周期，是一种强关联；

Spring IoC容器的依赖有两层含义：Bean依赖容器和容器注入Bean的依赖资源：

Bean依赖容器：也就是说Bean要依赖于容器，这里的依赖是指容器负责创建Bean并管理Bean的生命周期，正是由于由容器来控制创建Bean并注入依赖，也就是控制权被反转了，这也正是IoC名字的由来，此处的有依赖是指Bean和容器之间的依赖关系。

容器注入Bean的依赖资源：容器负责注入Bean的依赖资源，依赖资源可以是Bean、外部文件、常量数据等，在Java中都反映为对象，并且由容器负责组装Bean之间的依赖关系，此处的依赖是指Bean之间的依赖关系，可以认为是传统类与类之间的“关联”、“聚合”、“组合”关系。

为什么要应用依赖注入，应用依赖注入能给我们带来哪些好处呢？

动态替换Bean依赖对象，程序更灵活：替换Bean依赖对象，无需修改源文件：应用依赖注入后，由于可以采用配置文件方式实现，从而能随时动态的替换Bean的依赖对象，无需修改java源文件；

更好实践面向接口编程，代码更清晰：在Bean中只需指定依赖对象的接口，接口定义依赖对象完成的功能，通过容器注入依赖实现；

更好实践优先使用对象组合，而不是类继承：因为IoC容器采用注入依赖，也就是组合对象，从而更好的实践对象组合。

• 采用对象组合，Bean的功能可能由几个依赖Bean的功能组合而成，其Bean本身可能只提供少许功能或根本无任何功能，全部委托给依赖Bean，对象组合具有动态性，能更方便的替换掉依赖Bean，从而改变Bean功能；

• 而如果采用类继承，Bean没有依赖Bean，而是采用继承方式添加新功能，，而且功能是在编译时就确定了，不具有动态性，而且采用类继承导致Bean与子Bean之间高度耦合，难以复用。

增加Bean可复用性：依赖于对象组合，Bean更可复用且复用更简单；

降低Bean之间耦合：由于我们完全采用面向接口编程，在代码中没有直接引用Bean依赖实现，全部引用接口，而且不会出现显示的创建依赖对象代码，而且这些依赖是由容器来注入，很容易替换依赖实现类，从而降低Bean与依赖之间耦合；

代码结构更清晰：要应用依赖注入，代码结构要按照规约方式进行书写，从而更好的应用一些最佳实践，因此代码结构更清晰。

从以上我们可以看出，其实依赖注入只是一种装配对象的手段，设计的类结构才是基础，如果设计的类结构不支持依赖注入，Spring IoC容器也注入不了任何东西，从而从根本上说“如何设计好类结构才是关键，依赖注入只是一种装配对象手段”。

前边IoC一章我们已经了解了Bean依赖容器，那容器如何注入Bean的依赖资源，Spring IoC容器注入依赖资源主要有以下两种基本实现方式：

构造器注入：就是容器实例化Bean时注入那些依赖，通过在在Bean定义中指定构造器参数进行注入依赖，包括实例工厂方法参数注入依赖，但静态工厂方法参数不允许注入依赖；

setter注入：通过setter方法进行注入依赖；

方法注入：能通过配置方式替换掉Bean方法，也就是通过配置改变Bean方法 功能。

我们已经知道注入实现方式了，接下来让我们来看看具体配置吧。

3.1.2  构造器注入

      使用构造器注入通过配置构造器参数实现，构造器参数就是依赖。除了构造器方式，还有静态工厂、实例工厂方法可以进行构造器注入。如图3-1所示：

图3-1 实例化

构造器注入可以根据参数索引注入、参数类型注入或Spring3支持的参数名注入，但参数名注入是有限制的，需要使用在编译程序时打开调试模式（即在编译时使用“javac –g:vars”在class文件中生成变量调试信息，默认是不包含变量调试信息的，从而能获取参数名字，否则获取不到参数名字）或在构造器上使用@ConstructorProperties（java.beans.ConstructorProperties）注解来指定参数名。

首先让我们准备测试构造器类HelloImpl3.java，该类只有一个包含两个参数的构造器：

java代码：

查看 复制到剪贴板 打印

1. package cn.javass.spring.chapter3.helloworld;  

2. publicclass HelloImpl3 implements HelloApi {  

3. private String message;  

4. privateint index;  

5. //@java.beans.ConstructorProperties({"message", "index"})

6. public HelloImpl3(String message, int index) {  

7. this.message = message;  

8. this.index = index;  

9.    }  

10. @Override

11. publicvoid sayHello() {  

12.        System.out.println(index + ":" + message);  

13.    }  

14. }  

一、根据参数索引注入，使用标签“<constructor-arg index="1" value="1"/>”来指定注入的依赖，其中“index”表示索引，从0开始，即第一个参数索引为0，“value”来指定注入的常量值，配置方式如下：

二、根据参数类型进行注入，使用标签“<constructor-arg type="java.lang.String" value="Hello World!"/>”来指定注入的依赖，其中“type”表示需要匹配的参数类型，可以是基本类型也可以是其他类型，如“int”、“java.lang.String”，“value”来指定注入的常量值，配置方式如下：

三、根据参数名进行注入，使用标签“<constructor-arg name="message" value="Hello World!"/>”来指定注入的依赖，其中“name”表示需要匹配的参数名字，“value”来指定注入的常量值，配置方式如下：

四、让我们来用具体的例子来看一下构造器注入怎么使用吧。

（1）首先准备Bean类，在此我们就使用“HelloImpl3”这个类。

（2）有了Bean类，接下来要进行Bean定义配置，我们需要配置三个Bean来完成上述三种依赖注入测试，其中Bean ”byIndex”是通过索引注入依赖；Bean ”byType”是根据类型进行注入依赖；Bean ”byName”是根据参数名字进行注入依赖，具体配置文件（resources/chapter3/ constructorDependencyInject.xml）如下：

java代码：

查看 复制到剪贴板 打印

1. <!-- 通过构造器参数索引方式依赖注入 -->  

2. <bean id="byIndex"class="cn.javass.spring.chapter3.HelloImpl3">  

3. <constructor-arg index="0" value="Hello World!"/>  

4.    <constructor-arg index="1" value="1"/>  

5. </bean>  

6. <!-- 通过构造器参数类型方式依赖注入 -->  

7. <bean id="byType"class="cn.javass.spring.chapter3.HelloImpl3">  

8.   <constructor-arg type="java.lang.String" value="Hello World!"/>  

9.   <constructor-arg type="int" value="2"/>  

10. </bean>  

11. <!-- 通过构造器参数名称方式依赖注入 -->  

12. <bean id="byName"class="cn.javass.spring.chapter3.HelloImpl3">  

13.   <constructor-arg name="message" value="Hello World!"/>  

14.   <constructor-arg name="index" value="3"/>  

15. </bean>  

（3）配置完毕后，在测试之前，因为我们使用了通过构造器参数名字注入方式，请确保编译时class文件包含“变量信息”，具体查看编译时是否包含“变量调试信息”请右击项目，在弹出的对话框选择属性；然后在弹出的对话框选择“Java Compiler”条目，在“Class 文件 生成”框中选择“添加变量信息到Class文件（调试器使用）”，具体如图3-2：

图3-2 编译时打开“添加变量信息选项”

（4）接下来让我们测试一下配置是否工作，具体测试代码（cn.javass.spring.chapter3. DependencyInjectTest）如下：

java代码：

查看 复制到剪贴板 打印

1. @Test

2. publicvoid testConstructorDependencyInjectTest() {        

3. BeanFactory beanFactory =  new ClassPathXmlApplicationContext("chapter3/constructorDependencyInject.xml");  

4. //获取根据参数索引依赖注入的Bean

5. HelloApi byIndex = beanFactory.getBean("byIndex", HelloApi.class);  

6. byIndex.sayHello();  

7. //获取根据参数类型依赖注入的Bean

8. HelloApi byType = beanFactory.getBean("byType", HelloApi.class);  

9. byType.sayHello();  

10. //获取根据参数名字依赖注入的Bean

11. HelloApi byName = beanFactory.getBean("byName", HelloApi.class);  

12. byName.sayHello();  

13. }  

      通过以上测试我们已经会基本的构造器注入配置了，在测试通过参数名字注入时，除了可以使用以上方式，还可以通过在构造器上添加@java.beans.ConstructorProperties({"message", "index"})注解来指定参数名字，在HelloImpl3构造器上把注释掉的“ConstructorProperties”打开就可以了，这个就留给大家做练习，自己配置然后测试一下。

五、大家已经会了构造器注入，那让我们再看一下静态工厂方法注入和实例工厂注入吧，其实它们注入配置是完全一样，在此我们只示范一下静态工厂注入方式和实例工厂方式配置，测试就留给大家自己练习：

      （1）静态工厂类

java代码：

查看 复制到剪贴板 打印

1. //静态工厂类

2. package cn.javass.spring.chapter3;  

3. import cn.javass.spring.chapter2.helloworld.HelloApi;  

4. publicclass DependencyInjectByStaticFactory {  

5. publicstatic HelloApi newInstance(String message, int index) {  

6. returnnew HelloImpl3(message, index);  

7.       }  

8. }  

       静态工厂类Bean定义配置文件（chapter3/staticFactoryDependencyInject.xml）

java代码：

查看 复制到剪贴板 打印

1. <bean id="byIndex"

2. class="cn.javass.spring.chapter3.DependencyInjectByStaticFactory" factory-method="newInstance">  

3. <constructor-arg index="0" value="Hello World!"/>  

4. <constructor-arg index="1" value="1"/>  

5. </bean>  

6. <bean id="byType"

7. class="cn.javass.spring.chapter3.DependencyInjectByStaticFactory" factory-method="newInstance">  

8. <constructor-arg type="java.lang.String" value="Hello World!"/>  

9.       <constructor-arg type="int" value="2"/>  

10. </bean>  

11. <bean id="byName"

12. class="cn.javass.spring.chapter3.DependencyInjectByStaticFactory" factory-method="newInstance">  

13.       <constructor-arg name="message" value="Hello World!"/>  

14.       <constructor-arg name="index" value="3"/>  

15. </bean>  

（2）实例工厂类

java代码：

查看 复制到剪贴板 打印

1. //实例工厂类

2. package cn.javass.spring.chapter3;  

3. import cn.javass.spring.chapter2.helloworld.HelloApi;  

4. publicclass DependencyInjectByInstanceFactory {  

5. public HelloApi newInstance(String message, int index) {  

6. returnnew HelloImpl3(message, index);  

7.    }  

8. }  

       实例工厂类Bean定义配置文件（chapter3/instanceFactoryDependencyInject.xml）

java代码：

查看 复制到剪贴板 打印

1. <bean id="instanceFactory"

2. class="cn.javass.spring.chapter3.DependencyInjectByInstanceFactory"/>  

4. <bean id="byIndex"

5. factory-bean="instanceFactory"  factory-method="newInstance">  

6.    <constructor-arg index="0" value="Hello World!"/>  

7.       <constructor-arg index="1" value="1"/>  

8. </bean>  

9. <bean id="byType"

10. factory-bean="instanceFactory" factory-method="newInstance">  

11. <constructor-arg type="java.lang.String" value="Hello World!"/>  

12. <constructor-arg type="int" value="2"/>  

13. </bean>  

14. <bean id="byName"

15. factory-bean="instanceFactory" factory-method="newInstance">  

16. <constructor-arg name="message" value="Hello World!"/>  

17. <constructor-arg name="index" value="3"/>  

18. </bean>  

      （3）测试代码和构造器方式完全一样，只是配置文件不一样，大家只需把测试文件改一下就可以了。还有一点需要大家注意就是静态工厂方式和实例工厂方式根据参数名字注入的方式只支持通过在class文件中添加“变量调试信息”方式才能运行，ConstructorProperties注解方式不能工作，它只对构造器方式起作用，不建议使用根据参数名进行构造器注入。

3.1.3  setter注入

      setter注入，是通过在通过构造器、静态工厂或实例工厂实例好Bean后，通过调用Bean类的setter方法进行注入依赖，如图3-3所示：

图3-3 setter注入方式

      setter注入方式只有一种根据setter名字进行注入：

      知道配置方式了，接下来先让我们来做个简单例子吧。

（1）准备测试类HelloImpl4，需要两个setter方法“setMessage”和“setIndex”：

java代码：

查看 复制到剪贴板 打印

1. package cn.javass.spring.chapter3;  

2. import cn.javass.spring.chapter2.helloworld.HelloApi;  

3. publicclass HelloImpl4 implements HelloApi {  

4. private String message;  

5. privateint index;  

6. //setter方法

7. publicvoid setMessage(String message) {  

8. this.message = message;  

9.    }  

10. publicvoid setIndex(int index) {  

11. this.index = index;  

12.    }  

13. @Override

14. publicvoid sayHello() {  

15.        System.out.println(index + ":" + message);  

16.    }  

17. }  

      （2）配置Bean定义，具体配置文件（resources/chapter3/setterDependencyInject.xml）片段如下：

java代码：

查看 复制到剪贴板 打印

1. <!-- 通过setter方式进行依赖注入 -->  

2.    <bean id="bean"class="cn.javass.spring.chapter3.HelloImpl4">  

3.        <property name="message" value="Hello World!"/>  

4.        <property name="index">  

5.            <value>1</value>  

6.        </property>  

7.    </bean>  

（3）该写测试进行测试一下是否满足能工作了，其实测试代码一点没变，变的是配置：

java代码：

查看 复制到剪贴板 打印

1. @Test

2. publicvoid testSetterDependencyInject() {  

3.    BeanFactory beanFactory =  

4. new ClassPathXmlApplicationContext("chapter3/setterDependencyInject.xml");  

5.   HelloApi bean = beanFactory.getBean("bean", HelloApi.class);  

6.    bean.sayHello();  

7. }  

      知道如何配置了，但Spring如何知道setter方法？如何将值注入进去的呢？其实方法名是要遵守约定的，setter注入的方法名要遵循“JavaBean getter/setter 方法命名约定”：

      JavaBean：是本质就是一个POJO类，但具有一下限制：

        该类必须要有公共的无参构造器，如public HelloImpl4() {}；

属性为private访问级别，不建议public，如private String message;

属性必要时通过一组setter（修改器）和getter（访问器）方法来访问；

setter方法，以“set” 开头，后跟首字母大写的属性名，如“setMesssage”,简单属性一般只有一个方法参数，方法返回值通常为“void”;

        getter方法，一般属性以“get”开头，对于boolean类型一般以“is”开头，后跟首字母大写的属性名，如“getMesssage”，“isOk”；

        还有一些其他特殊情况，比如属性有连续两个大写字母开头，如“URL”,则setter/getter方法为：“setURL”和“getURL”，其他一些特殊情况请参看“Java Bean”命名规范。

3.1.4  注入常量

      注入常量是依赖注入中最简单的。配置方式如下所示：

java代码：

查看 复制到剪贴板 打印

1. <property name="message" value="Hello World!"/>  

2. 或  

3. <property name="index"><value>1</value></property><span class="Apple-style-span" style="font-size: 14px; white-space: normal; background-color: #ffffff;"> </span>  

      以上两种方式都可以，从配置来看第一种更简洁。注意此处“value”中指定的全是字符串，由Spring容器将此字符串转换成属性所需要的类型，如果转换出错，将抛出相应的异常。

Spring容器目前能对各种基本类型把配置的String参数转换为需要的类型。

注：Spring类型转换系统对于boolean类型进行了容错处理，除了可以使用“true/false”标准的Java值进行注入，还能使用“yes/no”、“on/off”、“1/0”来代表“真/假”，所以大家在学习或工作中遇到这种类似问题不要觉得是人家配置错了，而是Spring容错做的非常好。

java代码：

查看 复制到剪贴板 打印

1. 测试类  

2. publicclass BooleanTestBean {  

3. privateboolean success;  

4. publicvoid setSuccess(boolean success) {  

5. this.success = success;  

6.    }  

7. publicboolean isSuccess() {  

8. return success;  

9.    }  

10. }  

11. 配置文件（chapter3/booleanInject.xml）片段：  

12. <!-- boolean参数值可以用on/off -->  

13. <bean id="bean2"class="cn.javass.spring.chapter3.bean.BooleanTestBean">  

14.    <property name="success" value="on"/>  

15. </bean>  

16. <!-- boolean参数值可以用yes/no -->  

17. <bean id="bean3"class="cn.javass.spring.chapter3.bean.BooleanTestBean">  

18.    <property name="success" value="yes"/>  

19. </bean>  

20. <!-- boolean参数值可以用1/0 -->  

21. <bean id="bean4"class="cn.javass.spring.chapter3.bean.BooleanTestBean">  

22.    <property name="success" value="1"/>  

23. </bean>  

3.1.5    注入Bean ID

用于注入Bean的ID，ID是一个常量不是引用，且类似于注入常量，但提供错误验证功能，配置方式如下所示：

java代码：

查看 复制到剪贴板 打印

1. <property name="id"><idref bean="bean1"/></property>  

java代码：

查看 复制到剪贴板 打印

1. <property name="id"><idref local="bean2"/></property>  

两种方式都可以，上述配置本质上在运行时等于如下方式

java代码：

查看 复制到剪贴板 打印

1. <bean id="bean1"class="……"/>  

2. <bean id="idrefBean1"class="……">  

3. <property name="id" value ="bean1"/>  

4. </bean>  

第二种方式（<idref bean="bean1"/>）可以在容器初始化时校验被引用的Bean是否存在，如果不存在将抛出异常，而第一种方式（<idref local="bean2"/>）只有在Bean实际使用时才能发现传入的Bean的ID是否正确，可能发生不可预料的错误。因此如果想注入Bean的ID，推荐使用第二种方式。

接下来学习一下如何使用吧：

首先定义测试Bean：

java代码：

查看 复制到剪贴板 打印

1. package cn.javass.spring.chapter3.bean  

2. publicclass IdRefTestBean {  

3. private String id;  

4. public String getId() {  

5. return id;  

6.    }  

7. publicvoid setId(String id) {  

8. this.id = id;  

9.    }  

10. }  

其次定义配置文件（chapter3/idRefInject.xml）：

java代码：

查看 复制到剪贴板 打印

1. <bean id="bean1"class="java.lang.String">  

2. <constructor-arg index="0" value="test"/>  

3. </bean>  

4. <bean id="bean2"class="java.lang.String">  

5.    <constructor-arg index="0" value="test"/>  

6. </bean>  

java代码：

查看 复制到剪贴板 打印

1. <bean id="idrefBean1"class="cn.javass.spring.chapter3.bean.IdRefTestBean">  

2.        <property name="id"><idref bean="bean1"/></property>  

3. </bean>  

4. <bean id="idrefBean2"class="cn.javass.spring.chapter3.bean.IdRefTestBean">  

5.    <property name="id"><idref local="bean2"/></property>  

6. </bean>  

      从配置中可以看出，注入的Bean的ID是一个java.lang.String类型，即字符串类型，因此注入的同样是常量，只是具有校验功能。

<idref bean="……"/>将在容器初始化时校验注入的ID对于的Bean是否存在，如果不存在将抛出异常。

<idref local="……"/>将在XML解析时校验注入的ID对于的Bean在当前配置文件中是否存在，如果不存在将抛出异常，它不同于<idref bean="……"/>，<idref local="……"/>是校验发生在XML解析式而非容器初始化时，且只检查当前配置文件中是否存在相应的Bean。

转载于:https://blog.51cto.com/zhaohaibo/1284592