srping基础——DI（三）

1、依赖和依赖注入

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

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

　　

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

　　

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

　　

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

　　

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

　　

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

　　

　　它们关系的强弱顺序：泛化= 实现> 组合> 聚合> 关联> 依赖 

　　spring IoC容器依赖有两层含义：bean依赖容器和容器注入bean的依赖资源。

• bean依赖容器：这里的依赖是指容器负责创建bean，并管理bean的生命周期，正式由于容器来控制创建bean并注入依赖，也就是控制值被反转了，这也正式IoC名字的由来，此处的依赖指的是bean和容器之间的依赖关系。
• 容器注入bean的依赖资源：依赖资源可以是bean、外部文件、常量数据等，在Java中都反应为对象，并且有容器负责组装bean之间的依赖关系，此处的依赖指的是bean之间的关系可以认为是传统类与类之间的关联、组合、聚合关系。

2、为什么要依赖注入

• 动态替换bean依赖对象，程序更灵活：替换bean对象无需更改源文件，直接修改配置文件即可。
• 更好实践面向接口编程，代码更清晰：在bean中只需指定依赖对象的接口，接口定义依赖对象完成的功能，通过容器注入依赖实现。
• 更好实践优先使用组合，而不是继承：因为IoC容器采用注入依赖，也就是组合对象，从而更好的实现对象的组合。　
• 增加bean的复用性：依赖于对象组合，bean可复用且复用更简单
• 降低bean之间的耦合：由于我们完全面向接口编程，在代码中没有直接引用bean依赖实现，全部引用接口，而且不会显示创建依赖对象代码。
• 代码结构更清晰：要应用依赖注入，代码结构要按照规约方式进行书写，从而更好的应用一些最佳实践，因此代码结构更清晰。

　　如何设计好类结构才是关键，依赖注入只是装配对象的一种手段。上一篇我们已经了解了bean依赖容器，spring IoC容器注入依赖资源主要有以下三种形式：

　　构造器注入：就是容器实例化bean时注入那些依赖，通过在bean定义中指定构造器参数注入依赖，包括实例工厂方法参数注入依赖。

　　setter注入：通过setter方法注入依赖。

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

3、依赖注入具体配置

　　3.1 构造器注入：

　　　　3.1.1 使用构造器注入通过配置构造器参数实现，构造器参数就是依赖。除了构造器方式还有实例工厂，静态工厂可以进行构造器注入。

　　　　

　　　　构造器注入可以根据参数的索引注入，参数的类型注入或参数名注入（参数名注入有限制：编译程序时打开调试模式或在构造器上使用@ConstructorProperties注解指定参数名）

public class HelloImpl3 implements HelloApi {
 　　private String message;
　　 private int index;
　　 //@java.beans.ConstructorProperties({"message", "index"})
 　　public HelloImpl3(String message, int index) {
 　　　　this.message = message;
 　　　　this.index = index;
 　　}
 　　@Override
 　　public void sayHello() {
 　　System.out.println(index + ":" + message);
 }

<!-- 通过构造器参数索引方式依赖注入 -->
<bean id="byIndex" class="cn.javass.spring.chapter3.HelloImpl3">
　　<constructor-arg index="0" value="Hello World!"/>
 　 <constructor-arg index="1" value="1"/>
</bean>
<!-- 通过构造器参数类型方式依赖注入 -->
<bean id="byType" class="cn.javass.spring.chapter3.HelloImpl3">
   <constructor-arg type="java.lang.String" value="Hello World!"/>
   <constructor-arg type="int" value="2"/>
</bean>
<!-- 通过构造器参数名称方式依赖注入 -->
<bean id="byName" class="cn.javass.spring.chapter3.HelloImpl3">
   <constructor-arg name="message" value="Hello World!"/>
   <constructor-arg name="index" value="3"/>
</bean>

@Test
public void testConstructorDependencyInjectTest() {
　　BeanFactory beanFactory = new ClassPathXmlApplicationContext("chapter3/constructorDependencyInject.xml");
　　//获取根据参数索引依赖注入的Bean
　　HelloApi byIndex = beanFactory.getBean("byIndex", HelloApi.class);
　　byIndex.sayHello();
　　//获取根据参数类型依赖注入的Bean
　　HelloApi byType = beanFactory.getBean("byType", HelloApi.class);
　　byType.sayHello();
　　//获取根据参数名字依赖注入的Bean
　　HelloApi byName = beanFactory.getBean("byName", HelloApi.class);
　　byName.sayHello();
}

 　　　　3.1.2 静态工厂方法注入和实例工厂方法注入

<!--静态工厂方法-->
<bean id="byIndex" class="cn.javass.spring.chapter3.DependencyInjectByStaticFactory" factory-method="newInstance">
　　<constructor-arg index="0" value="Hello World!"/>
　　<constructor-arg index="1" value="1"/>
</bean>
<bean id="byType" class="cn.javass.spring.chapter3.DependencyInjectByStaticFactory" factory-method="newInstance">
　　<constructor-arg type="java.lang.String" value="Hello World!"/>
　　<constructor-arg type="int" value="2"/>
</bean>
<bean id="byName" class="cn.javass.spring.chapter3.DependencyInjectByStaticFactory" factory-method="newInstance">
　　<constructor-arg name="message" value="Hello World!"/>
　　<constructor-arg name="index" value="3"/>
</bean>
<!--实例工厂方法-->
<bean id="instanceFactory" class="cn.javass.spring.chapter3.DependencyInjectByInstanceFactory"/>
<bean id="byIndex" factory-bean="instanceFactory" factory-method="newInstance">
   <constructor-arg index="0" value="Hello World!"/>
　　<constructor-arg index="1" value="1"/>
</bean>
<bean id="byType" factory-bean="instanceFactory" factory-method="newInstance">
　　<constructor-arg type="java.lang.String" value="Hello World!"/>
　　<constructor-arg type="int" value="2"/>
</bean>
<bean id="byName" factory-bean="instanceFactory" factory-method="newInstance">
　　<constructor-arg name="message" value="Hello World!"/>
　　<constructor-arg name="index" value="3"/>
</bean> 

//静态工厂类
package cn.javass.spring.chapter3;
import cn.javass.spring.chapter2.helloworld.HelloApi;
public class DependencyInjectByStaticFactory {
　　public static HelloApi newInstance(String message, int index) {
　　return new HelloImpl3(message, index);
　　}
}
//实例工厂类
package cn.javass.spring.chapter3;
import cn.javass.spring.chapter2.helloworld.HelloApi;
public class DependencyInjectByInstanceFactory {
　　 public HelloApi newInstance(String message, int index) {
 　　return new HelloImpl3(message, index);
 　　}
}

 　　因为参数名需做额外配置，因此不建议使用根据参数名进行构造器注入

　　3.2 setter注入

　　setter注入，是通过构造器、静态工厂、实例工厂实例化好bean中，再调用bean类的setter方法注入依赖。

　　

<!-- 通过setter方式进行依赖注入 -->
 <bean id="bean" class="cn.javass.spring.chapter3.HelloImpl4">
 　　<property name="message" value="Hello World!"/>
 　　　　<property name="index">
 　　　　<value>1</value>
 　　</property>
 </bean>

package cn.javass.spring.chapter3;
import cn.javass.spring.chapter2.helloworld.HelloApi;
public class HelloImpl4 implements HelloApi {
 　　private String message;
 　　private int index;
　　//setter方法
 　　public void setMessage(String message) {
 　　this.message = message;
 　　}
 　　public void setIndex(int index) {
 　　this.index = index;
 　　}
 　　@Override
 　　public void sayHello() {
 　　System.out.println(index + ":" + message);
 　　}
}

@Test
public void testSetterDependencyInject() {
 　　BeanFactory beanFactory = new ClassPathXmlApplicationContext("chapter3/setterDependencyInject.xml");
 　　HelloApi bean = beanFactory.getBean("bean", HelloApi.class);
 　　bean.sayHello();
}

　　JavaBean本质就是一个pojo，具体有如下限制：

　　　　该类必须有公共的无惨构造器

　　　　属性为private访问级别

　　　　属性必要时通过一组setter和getter方法来访问

　　3.3 常量注入

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

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

　　　　以上两种方式都可以，从配置来看第一种更简洁，此处的value中指定的全是字符串，由spring容器将此字符串转换成属性所需的类型，如果转换出错则抛出相应的异常。spring容器目前能对各种基本类型把配置的字符串参数转换为所需的类型。

//测试类
public class BooleanTestBean {
 　　private boolean success;
 　　public void setSuccess(boolean success) {
 　　this.success = success;
 　　}
 　　public boolean isSuccess() {
 　　return success;
 　　}
}

<!-- boolean参数值可以用on/off -->
<bean id="bean2" class="cn.javass.spring.chapter3.bean.BooleanTestBean">
 <property name="success" value="on"/>
</bean>
<!-- boolean参数值可以用yes/no -->
<bean id="bean3" class="cn.javass.spring.chapter3.bean.BooleanTestBean">
 <property name="success" value="yes"/>
</bean>
<!-- boolean参数值可以用1/0 -->
<bean id="bean4" class="cn.javass.spring.chapter3.bean.BooleanTestBean">
 <property name="success" value="1"/>
</bean>

　　3.4 注入集合、数组和字典

　　　　spring IoC容器不仅能注入简单的数据类型，还能注入集合（Collection、Set、List）类型、数组类型、字典数据类型、Properties类型。

　　　　3.4.1 注入集合类型：

• List类型：需要使用list标签注入，其具体配置如下：

　　

<bean id="listBean" class="cn.javass.spring.chapter3.bean.ListTestBean">
 <property name="values">
 　　<list>
 　　　　<value>1</value>
 　　　　<value>2</value>
 　　　　<value>3</value>
 　　</list>
 </property>
</bean>

package cn.javass.spring.chapter3.bean;
import java.util.List;
public class ListTestBean {
 　　private List<String> values;
 　　public List<String> getValues() {
 　　　　return values;
 　　}
 　　public void setValues(List<String> values) {
 　　　　this.values = values;
 　　}
}
@Test
public void testListInject() {
 BeanFactory beanFactory = new ClassPathXmlApplicationContext("chapter3/listInject.xml");
　　ListTestBean listBean = beanFactory.getBean("listBean", ListTestBean.class);
　　System.out.println(listBean.getValues().size());
　　Assert.assertEquals(3, listBean.getValues().size());
}

• set类型：需要使用set标签来配置注入，其配置参数含义与list相同

<bean id="setBean" class="cn.javass.spring.chapter3.bean.SetTestBean">
　　<property name="values">
　　　　<set>
　　　　　　<value>1</value>
　　　　　　<value>2</value>
　　　　　　<value>3</value>
　　　　</set>
　　</property>
</bean>

package cn.javass.spring.chapter3.bean;
import java.util.Set;
public class SetTestBean {
 　　private Set<String> values;
 　　public void setValues(Set<String> values) {
 　　　　this.values = values;
 　　}
 　　public Set<String> getValues() {
 　　　　return values;
 　　}
}

• Collection类型：由于Collection类型是List和Set类型的基类型，所以使用list和set标签都可以进行注入，配置方式和以上配置方式相同。

　　　　3.4.2 注入数组类型

　　　　　　需要使用array标签来配置注入，其中标签属性“value-type”和“merge”与list标签含义完全相同。具体配置如下：

　　　　　　

　　　　3.4.3 注入字典类型：

　　　　　　字典类型是包含键值对数据的数据结构，需要使用map、entry标签来配置注入，其属性key-type和value-type分别指定键值数据类型，其含义同list标签相同。使用key、value字标签分别指定键值数据。具体配置如下：

　　　　　　

　　　　3.4.4 Properties注入：

　　　　　　spring能注入java.util.Properties类型数据，需要使用props标签来配置注入，键值类型必须是String，不能变。字标签<prop key=“键”>值<prop>来指定键值对，具体配置如下：