Spring2.5学习之二----依赖注入

Key points
依赖注入的原理
依赖注入的方式---XML配置
依赖注入的方式---注解的方式
Java包装类的注入
Collection的注入


学习Spring 它的核心就是IOC和AOP。而IOC中实现Bean注入的实现方式之一就是DI（依赖注入）。

一 DI的原理
DI的基本原理：对象之间的依赖关系只会通过三种方式：构造函数参数，工厂方法的参数以及构造函数或工厂方法创建的对象属性设置。因此，容器的工作哦就是在创建Bean时注入所有的依赖关系。相对于由Bean自己控制其实例化,直接在构造器中指定依赖关系或者类似服务定位器(Service Locator)这三种自主控制依赖关系注入的方法，而控制权从根本上发生改变，即控制反转(Inverse of Controll)---IOC.
应用DI规则后，我们不用在关注对象之间的依赖关系，从而达到高层次的松耦合。DI有两种实现方式---Setter/getter方式（传值方式）和构造器方式(引用方式)。
下面就从XML配置和注解角度来介绍这两种方式。
二 DI的方式---XML配置
1. Setter/getter方法
下面是一个Sample：
1） beans.xml:

<bean id="personDao" class="com.spring.dao.impl.PersonDaoImpl"></bean>
		   <bean id="personService" class="com.spring.service.impl.PersonServiceBean" 
		   		scope="singleton" >
<property name=”personDao” ref=”personDao”/>
</bean>

2） PersonService.java

public interface PersonService {
			public  void save();
}

3） PersonServiceBean.java

public class PersonServiceBean implements PersonService{
	//all 需要注入的bean都在这里处理
	private PersonDao personDao;
	
public PersonServiceBean(){
		System.out.println("personServiceBean.constructor() is running.");
	}
	
	/**
	 * 使用getter/setter方法注入
	 * @return the personDao
	 */
	public PersonDao getPersonDao() {
		return personDao;
	}

	/**
	 * @param personDao the personDao to set
	 */
	//使用注解注入到setter方法上，等同于注解注入到Field上。
    //@Resource
	public void setPersonDao(PersonDao personDao) {
		this.personDao = personDao;
	}
	public void save(){
		System.out.println("Name:" +name);
		personDao.add();
	}
	@PostConstruct
	public void init(){
		System.out.println("PersonServiceBean.init() is running.");
	}
	
	@PreDestroy
	public void destory(){
		System.out.println("PersonServiceBean.destory() is running.");
	}
}

4） PersonDao.java

public interface PersonDao {
	public void add();
}

5） PersonDaoImpl.java

public class PersonDaoImpl implements PersonDao {
	public void add(){
		System.out.println("PersonDao.add() is running.");
	}
}

6） SpringTest.java(测试类)

public class SpringTest {

	/**
	 * @throws java.lang.Exception
	 */
	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}
	@Test public void instanceSpring(){
		AbstractApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
		PersonService personService = (PersonService)context.getBean("personService");
		personService.save();
		
		/**
		 * call destroy()
		 */
		context.close();
}
	
}

Console出现的Log：

personServiceBean.constructor() is running.
PersonServiceBean.init() is running.
Name:null
PersonDao.add() is running.

在这里，是采用一种外部注入的方式，我们还可以采用内部注入的方式来处理：
Beans.xml修改如下：

  

<bean id="personService" class="com.spring.service.impl.PersonServiceBean" 
		   		scope="singleton" >
<property name="personDao">
		   	    	<bean class="com.spring.dao.impl.PersonDaoImpl"/>
		   	    </property>
</bean>

2. 构造器注入
以下是一个Sample：
1） Beans.xml:

<bean id="personDao" class="com.spring.dao.impl.PersonDaoImpl"></bean>
		   <bean id="personService" class="com.spring.service.impl.PersonServiceBean" 
		   		scope="singleton" >
<!—使用构造函数注入-->
<constructor-arg index="0" type="com.spring.dao.PersonDao" ref="personDao"/>
<constructor-arg index="1" value="Jamson" />
</bean>

2） PersonService.java：同Setter方法注入
3） PersonServiceBean.java

public class PersonServiceBean implements PersonService{
	//all 需要注入的bean都在这里处理
	//使用注解方式注入，首先按名称查找，然后是按照类型查找
	//@Resource(name="personDao")
//	@Autowired
	private PersonDao personDao;
	
	public String name;
	public PersonServiceBean(){
		System.out.println("personServiceBean.constructor() is running.");
	}
	/**
	 * 使用构造器注入
	 * @param personDao
	 * @param name
	 */
	public PersonServiceBean(PersonDao personDao, String name) {
		this.personDao = personDao;
		this.name = name;
	}

//	/**
//	 * 使用getter/setter方法注入
//	 * @return the personDao
//	 */
//	public PersonDao getPersonDao() {
//		return personDao;
//	}
//
//	/**
//	 * @param personDao the personDao to set
//	 */
//	//使用注解注入到setter方法上，等同于注解注入到Field上。
//    //@Resource
//	public void setPersonDao(PersonDao personDao) {
//		this.personDao = personDao;
//	}
	public void save(){
		System.out.println("Name:" +name);
		personDao.add();
	}
	@PostConstruct
	public void init(){
		System.out.println("PersonServiceBean.init() is running.");
	}
	@PreDestroy
	public void destory(){
		System.out.println("PersonServiceBean.destory() is running.");
	}

//	/**
//	 * @return the name
//	 */
//	public String getName() {
//		return name;
//	}
//
//	/**
//	 * @param name the name to set
//	 */
//	public void setName(String name) {
//		this.name = name;
//	}

}
4） PersonDao.java：同Setter方法注入
5） PersonDaoImpl.java：同Setter方法注入
6） 测试类(SpringTest.java)：同上

Console出现的Log：

PersonServiceBean.init() is running.
Name:Jamson
PersonDao.add() is running.

三 DI的方式---注解的配置
自从Jdk5中引入Annotation类后，在EJB和Spring中得到广泛的使用，也越来越被开发者们在平时的应用中使用。主要是用在Field上的注入。在日常的应用开发中，一个项目中有很多的bean，如果使用XML文件配置，就会导致配置文件难以管理。使用注解注入的时候，能够使bean的配置文件内容不至于繁杂。
首先介绍下注解的两种方式:@Resource(javax.annotation.Resource)和@Autowired.
@Resource：首先按照名称去寻找当前的bean，如果找不到的话，那就以类型装配。
@Autowired:首先按照类型去寻找当前的bean, 如果找不到的话，那就以名称装配。
1. Resource
下面介绍一个Sample：
1) Beans.xml:

<bean id="personDao" class="com.spring.dao.impl.PersonDaoImpl"></bean>
		   <bean id="personService" class="com.spring.service.impl.PersonServiceBean" 
		   		scope="singleton"  init-method="init" destroy-method="destory"
		   		>

2) PersonService.java:同上。
3) PersonServiceBean.java

public class PersonServiceBean implements PersonService{
	//all 需要注入的bean都在这里处理
	//使用注解方式注入，首先按名称查找，然后是按照类型查找
	@Resource(name="personDao")
private PersonDao personDao;
	
	public String name="Jamson";
	public PersonServiceBean(){
		System.out.println("personServiceBean.constructor() is running.");
	}
	/**
	 * 使用构造器注入
	 * @param personDao
	 * @param name
	 */
	public PersonServiceBean(PersonDao personDao, String name) {
		this.personDao = personDao;
		this.name = name;
	}

//	/**
//	 * 使用getter/setter方法注入
//	 * @return the personDao
//	 */
//	public PersonDao getPersonDao() {
//		return personDao;
//	}

	/**
	 * @param personDao the personDao to set
	 */
	//使用注解注入到setter方法上，等同于注解注入到Field上。
//    @Resource
//	public void setPersonDao(PersonDao personDao) {
//		this.personDao = personDao;
//	}
	public void save(){
		System.out.println("Name:" +name);
		personDao.add();
	}
	@PostConstruct
	public void init(){
		System.out.println("PersonServiceBean.init() is running.");
	}
	
	@PreDestroy
	public void destory(){
		System.out.println("PersonServiceBean.destory() is running.");
	}
}

4) PersonDao.java:同上
5) PersonDaoService.java：同上
6) SpringTest.java：同上
2. Autowired
下面介绍一个Sample：
1) Beans.xml:

<bean id="personDao" class="com.spring.dao.impl.PersonDaoImpl"></bean>
		   <bean id="personService" class="com.spring.service.impl.PersonServiceBean" 
		   		scope="singleton"  init-method="init" destroy-method="destory"
		   		>

2) PersonService.java:同上。
3) PersonServiceBean.java

public class PersonServiceBean implements PersonService{
	//all 需要注入的bean都在这里处理
	//使用注解方式注入，首先按名称查找，然后是按照类型查找
	@Autowired
private PersonDao personDao;
	
	public String name="Jamson";
	public PersonServiceBean(){
		System.out.println("personServiceBean.constructor() is running.");
	}
	/**
	 * 使用构造器注入
	 * @param personDao
	 * @param name
	 */
	//public PersonServiceBean(PersonDao personDao, String name) {
		//this.personDao = personDao;
		//this.name = name;
	//}

	/**
	 * 使用getter/setter方法注入
	 * @return the personDao
	 */
	public PersonDao getPersonDao() {
		return personDao;
	}

	/**
	 * @param personDao the personDao to set
	 */
	//使用注解注入到setter方法上，等同于注解注入到Field上。
//    @Resource
	public void setPersonDao(PersonDao personDao) {
		this.personDao = personDao;
	}
	public void save(){
		System.out.println("Name:" +name);
		personDao.add();
	}
	@PostConstruct
	public void init(){
		System.out.println("PersonServiceBean.init() is running.");
	}
	
	@PreDestroy
	public void destory(){
		System.out.println("PersonServiceBean.destory() is running.");
	}

}
4) PersonDao.java:同上
5) PersonDaoService.java：同上
6) SpringTest.java：同上

Noted：所有的注解可以使用在Field上，也可以使用到Setter方法上，最后结果都是一样的。

四 Java基本类型的注入
   Java基本类型的注解可以参考二.2
   在beans.xml中配置如下:

<property name="name" value="Jamson"></property>

五 Collection的注入
   Collection的注入分为以下两步:
1. Beans.xml:

<property name="sets">
		   	    	<set>
		   	    		<value>set_1</value>
		   	    		<value>set_2</value>
		   	    	</set>	
		   	    </property>
		   	    
		   	    <property name="lists">
		   	    	<list>
		   	    		<value>list_1</value>
		   	    		<value>list_2</value>
		   	    	</list>
		   	    </property>
		   	    
		   	    <property name="properties">
		   	    	<props>
		   	    		<prop key="key_1">value_1</prop>
		   	    		<prop key="key_2">value_2</prop>
		   	    	</props>
		   	    </property>
		   	    
		   	    <property name="maps">
		   	    	<map>
		   	    		<entry key="map_1" value="value-1"/>
		   	    		<entry key="map_2" value="value-2"/>
		   	    	</map>
		   	    </property>

2. SpringTest.java:

		System.out.println("============Set is Starting===========");
		for(String value : personService.getSets()){
			System.out.println(value);
		}
		System.out.println("============List is Starting===========");
		for(String value: personService.getLists()){
			System.out.println(value);
		}
		System.out.println("============Properties is Starting===========");
		for(Object key: personService.getProperties().keySet()){
			System.out.println(key +"="+ personService.getProperties().getProperty((String)key));
		}
		System.out.println("============Map is Starting===========");
		for(String key: personService.getMaps().keySet()){
			System.out.println(key +"="+ personService.getMaps().get(key));
		}