【第三章】 DI 之 3.1.1 DI的配置使用 ——跟我学spring3

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. public class HelloImpl3 implements HelloApi {  

3.     private String message;  

4. private int 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.     public void sayHello() {  

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

13.     }  

14. }  

 

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

 

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

 

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

 

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

（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>  

16.    

17.    

 

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

 

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

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

 

java代码：

查看复制到剪贴板打印

1. @Test   

2. public void 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”打开就能够了，这个就留给你们作练习，本身配置而后测试一下。

 

5、你们已经会了构造器注入，那让咱们再看一下静态工厂方法注入和实例工厂注入吧，其实它们注入配置是彻底同样，在此咱们只示范一下静态工厂注入方式和实例工厂方式配置，测试就留给你们本身练习：

       （1）静态工厂类

 

java代码：

查看复制到剪贴板打印

1. //静态工厂类  

2. package cn.javass.spring.chapter3;  

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

4. public class DependencyInjectByStaticFactory {  

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

6.               return new 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. public class DependencyInjectByInstanceFactory {  

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

6.         return new HelloImpl3(message, index);  

7.     }  

8. }  

 

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

 

 

java代码：

查看复制到剪贴板打印

1. <bean id="instanceFactory"  

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

3.    

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. public class HelloImpl4 implements HelloApi {  

4.     private String message;  

5.     private int index;  

6. //setter方法  

7.     public void setMessage(String message) {  

8.         this.message = message;  

9.     }  

10.     public void setIndex(int index) {  

11.         this.index = index;  

12.     }  

13.     @Override  

14.     public void 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. public void 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”命名规范。