Spring的bean注入方式

Spring中依赖注入有三种注入方式：

一、构造器注入；

二、设值注入（setter方式注入）；

三、Feild方式注入（注解方式注入）。

 

一、构造器注入

     构造器注入顾名思义就是在程序组件中实现构造器，构造器可以是一个也可以是多个。废话不多说，直接上代码。

 

Java代码  

1. package cn.glzaction.service.impl;  
2.   
3. import java.util.List;  
4.   
5. import cn.glzaction.service.interfaces.PersonDaoIF;  
6. import cn.glzaction.service.interfaces.PersonServiceIF;  
7.   
8. public class PersonServiceBean implements PersonServiceIF{  
9.   
10. //自定义类  
11.     private PersonDaoIF personDaoBean;  
12. //String类型  
13.     private String name;  
14. //集合类型    
15.     private List list;  
16.       
17. //构造器     
18.     public PersonServiceBean(PersonDaoBean personDaoBean,String name,List list){  
19.         this.personDaoBean = personDaoBean;  
20.         this.name = name;  
21.         this.list = list;  
22.     }  
23. //方法，用于显示  
24.     public void display(){  
25.         personDaoBean.add();  
26.         System.out.println(name);  
27.         System.out.println(list);  
28.     }  
29. }  

 

 

上面的代码中构造器要注入三个参数，同时这三个参数也是三种不同的类型，自定义类、String类型，集合类型，其中自定义类PersonDaoBean 具体的实现我们这里就不累述了，因为这不是重点。下面我们再来看一下在Spring的配置文件中如何来配置。

 

Xml代码  

1. <bean id="personDao" class="cn.glzaction.service.impl.PersonDaoBean"></bean >  
2.   
3. <!--构造器方式注入-->  
4. <bean id="personService" class="cn.glzaction.service.impl.PersonServiceBean">  
5.     <constructor-arg index="0" type="cn.glzaction.service.impl.PersonDaoBean" ref="personDao"/>  
6.     <constructor-arg index="1" type="java.lang.String" value="glzaction"/>  
7.     <constructor-arg index="2" type="java.util.List">  
8.         <list>  
9.             <value>list1</value>  
10.             <value>list2</value>  
11.             <value>list3</value>  
12.         </list>  
13.     </constructor-arg>  
14. </bean>  

 

 

      java代码如何实现构造器我想大家一定都很清楚，否则的话就有点讲不过去了，呵呵，所以这里我也就不加以说明了，主要说一下上面的xml配置。id为“personDao”的bean是PersonServiceBean的私有属性，它的注入是采用无参构造器的注入方式注入的，这也不详细说明。主要说一下id为“personService”类的构造器注入。<coustructor-arg>是构造器标签元素，通过设定它的属性可以往构造器传递参数，index属性值表示要设定的参数在构造器形参中的索引顺序，例如上面的配置，list是第三个参数，所以它对应的索引为2，index是可选属性，所谓可选并不是说在任何情况下都可以不使用，要视具体情况而定，type为参数的类型，这个也是可选参数。还有两个很重要的属性就是ref和value，如果注入的是bean，就要使用ref，ref的值就是对应的bean。如果注入的是基本类型或者string类型就用value，直接将对应的值填入即可。

 

二、设值注入（setter方式注入）

设值注入就是通过setXxxx方法将bean注入到组件中，自定义类如下

 

Java代码  

1. package cn.glzaction.service.impl;  
2.   
3. import cn.glzaction.service.interfaces.PersonDaoIF;  
4. import java.util.*;  
5.   
6. public class PersonDaoBean implements PersonDaoIF {  
7.   
8.     private String name;  
9.       
10.     private Integer id;  
11.       
12.     private List list;  
13.       
14.     private Map map;  
15.       
16.     public void setName(String name) {  
17.         this.name = name;  
18.     }  
19.     public void setId(Integer id) {  
20.         this.id = id;  
21.     }  
22.     public void setList(List list) {  
23.         this.list = list;  
24.     }  
25.     public void setMap(Map map) {  
26.         this.map = map;  
27.     }  
28.   
29.     @Override  
30.     public void add() {  
31.         // TODO Auto-generated method stub  
32.         System.out.println(map);  
33.         System.out.println(list);  
34.         System.out.println(id);  
35.         System.out.println(name);  
36.     }  
37. }  

 

 

采用设置注入只要有setter方法即可，但是有时由于编程习惯也会讲getter方法引进，但是要清楚：设值注入与getter方法无关。这里还有一点需要注意，那就是能使用基本类型，如果非要使用基本类型的话就要使用其对应的包装类型，如上面使用的是Integer而不是int。Spring的xml配置如下：

 

Xml代码  

1. <bean id="personDao" class="cn.glzaction.service.impl.PersonDaoBean">  
2.     <property name="name" type="java.lang.String" value="glzaction"/>  
3.     <property name="id" type="java.lang.Integer" value="1"/>  
4.     <property name="list" type="java.util.List">  
5.         <list>  
6.             <value>list1</value>  
7.             <value>list2</value>  
8.             <value>list3</value>  
9.         </list>  
10.     </property>  
11.     <property name="map" type="java.util.Map">  
12.         <map>  
13.             <entry key="key1" value="value1"></entry>  
14.             <entry key="key2" value="value2"></entry>  
15.         </map>  
16.     </property>  
17. </bean>  

 设值注入采用的是<property>标签元素，其中的name属性对应的是要注入的变量名，type属性值对应的该变量的类型，可以是自定义类或者包装类型。value属性对应的是相应的值，还有一个ref属性，该属性值对应的是bean。

3，注解注入

1、古老的注入方式： 
实现类: 

Java代码  

1. /** 
2.  * @title UserServiceImpl.java 
3.  * @description UserService实现类 
4.  * @author cao_xhu 
5.  * @version 
6.  * @create_date Oct 30, 2009 
7.  * @copyright (c) CVIC SE 
8.  */  
9. public class UserServiceImpl implements UserService {  
10.   
11.     private UserDAO userDAO;  
12.   
13.     public void setUserDAO(UserDAO userDAO) {  
14.         this.userDAO = userDAO;  
15.     }  
16. ...  
17. }  

配置文件: 

Xml代码  

1. <bean id="userDAO" class="springlive.dao.impl.UserDAOImpl">  
2.     <property name="sessionFactory">  
3.         <ref local="sessionFactory" />  
4.     </property>  
5. </bean>  
6. <bean id="userServiceImpl"  
7.     class="springlive.service.impl.UserServiceImpl">  
8.     <property name="userDAO">  
9.         <ref local="userDAO" />  
10.     </property>  
11. </bean>  

2、使用注解的方式： 
2.1、Autowired注解 
<1>对成员变量注解 
实现类： 

Java代码  

1.     @Autowired  
2.     private IndustryDao industryDao;  
3. ...  
4.       

<2>set方法注解 

Java代码  

1. @Autowired  
2. public void setDao(IndustryDao industryDao)  
3. {  
4.     super.setDao(industryDao);  
5. }  

配置文件： 

Xml代码  

1. <!-- 使用 <context:annotation-config/> 简化配置  
2.   
3. Spring 2.1 添加了一个新的 context 的 Schema 命名空间，该命名空间对注释驱动、属性文件引入、加载期织入等功能提供了便捷的配置。我们知道注释本身是不会做任何事情的，它仅提供元数据信息。要使元数据信息真正起作用，必须让负责处理这些元数据的处理器工作起来。   
4.   
5. 而我们前面所介绍的 AutowiredAnnotationBeanPostProcessor 和 CommonAnnotationBeanPostProcessor 就是处理这些注释元数据的处理器。但是直接在 Spring 配置文件中定义这些 Bean 显得比较笨拙。Spring 为我们提供了一种方便的注册这些 BeanPostProcessor 的方式，这就是 <context:annotation-config/>。  
6.  -->  
7. <context:annotation-config />  
8.     <bean id="industryDao"  
9.         class="efs.sadapter.system.industry.dao.hibernate.HibernateIndustryDao" />  
10.     <bean id="industryService"  
11.         class="efs.sadapter.system.industry.service.impl.IndustryServiceImpl" />  

@Autowired可以对成员变量、方法和构造函数进行标注，来完成自动注入。 
@Autowired的标注位置不同，它们都会在Spring在初始化industryService这个bean时，自动装配industryDao这个属性，区别是：第一种实现中，Spring会直接将IndustryDao类型的唯一一个bean赋值给industryDao这个成员变量；第二种实现中，Spring会调用setDao方法来将IndustryDao类型的唯一一个bean装配到industryDao这个属性。 

2.2、@Qualifier 
@Autowired是根据类型进行自动注入的，如果spring配置文件中存在多个IndustryDao类型的bean时，或者不存在IndustryDao类型的bean，都会抛出异常。 
存在多个类型的实例时，按id注入@Qualifier("core.system.hibernateService") 

Java代码  

1. HibernateService hibernateService;  
2.   
3. @Autowired  
4. public void setHibernateService(@Qualifier("core.system.hibernateService")  
5. HibernateService hibernateService)  
6. {  
7.     this.hibernateService = hibernateService;  
8. }  

若不存在某类型的实例：告诉 Spring：在找不到匹配 Bean 时也不报错 

Java代码  

1. @Autowired(required = false)  
2.     public void setHibernateService(@Qualifier("core.system.hibernateService")  
3.     HibernateService hibernateService)  
4.     {  
5.         this.hibernateService = hibernateService;  
6.     }  

2.3、使用 JSR-250 的注解 
<1> @Resource 
spring支持@Resource、@PostConstruct以及@PreDestroyJSR-250的标准注解。 
@Resource可以按type注入，也可以按name注入。@Resource默认按byName自动注入。 
Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。 

@Resource装配顺序 
如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常 
如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常 
如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常 
如果既没有指定name，又没有指定type，则自动按照byName方式进行装配（见2）；如果没有匹配，则回退为一个原始类型（UserDao）进行匹配，如果匹配则自动装配； 
<2> @PostConstruct 和 @PreDestroy 
Spring 容器中的 Bean 是有生命周期的，Spring 允许在 Bean 在初始化完成后以及 Bean 销毁前执行特定的操作，您既可以通过实现 InitializingBean/DisposableBean 接口来定制初始化之后 / 销毁之前的操作方法，也可以通过 <bean> 元素的 init-method/destroy-method 属性指定初始化之后 / 销毁之前调用的操作方法。 
JSR-250 为初始化之后/销毁之前方法的指定定义了两个注释类，分别是 @PostConstruct 和 @PreDestroy，这两个注释只能应用于方法上。标注了 @PostConstruct 注释的方法将在类实例化后调用，而标注了 @PreDestroy 的方法将在类销毁之前调用。 

使用 @PostConstruct 和 @PreDestroy 注释的 Boss.java 

Java代码  

1. package com.baobaotao;  
2.   
3. import javax.annotation.Resource;  
4. import javax.annotation.PostConstruct;  
5. import javax.annotation.PreDestroy;  
6.   
7. public class Boss {  
8.     @Resource  
9.     private Car car;  
10.   
11.     @Resource(name = "office")  
12.     private Office office;  
13.   
14.     @PostConstruct  
15.     public void postConstruct1(){  
16.         System.out.println("postConstruct1");  
17.     }  
18.   
19.     @PreDestroy  
20.     public void preDestroy1(){  
21.         System.out.println("preDestroy1");   
22.     }  
23.     …  
24. }  

测试类代码: 

Java代码  

1. package com.baobaotao;  
2.   
3. import org.springframework.context.support.ClassPathXmlApplicationContext;  
4.   
5. public class AnnoIoCTest {  
6.   
7.     public static void main(String[] args) {  
8.         String[] locations = {"beans.xml"};  
9.         ClassPathXmlApplicationContext ctx =   
10.             new ClassPathXmlApplicationContext(locations);  
11.         Boss boss = (Boss) ctx.getBean("boss");  
12.         System.out.println(boss);  
13.         ctx.destroy();// 关闭 Spring 容器，以触发 Bean 销毁方法的执行  
14.     }  
15. }  

标注了 @PostConstruct 的 postConstruct1() 方法将在 Spring 容器启动时，创建 Boss Bean 的时候被触发执行，而标注了 @PreDestroy 注释的 preDestroy1() 方法将在 Spring 容器关闭前销毁 Boss Bean 的时候被触发执行。 

3、使用 @Component 
虽然我们可以通过 @Autowired 或 @Resource 在 Bean 类中使用自动注入功能，但是 Bean 还是在 XML 文件中通过 <bean> 进行定义 —— 也就是说，在 XML 配置文件中定义 Bean，通过 @Autowired 或 @Resource 为 Bean 的成员变量、方法入参或构造函数入参提供自动注入的功能。能否也通过注释定义 Bean，从 XML 配置文件中完全移除 Bean 定义的配置呢？答案是肯定的，我们通过 Spring 2.5 提供的 @Component 注释就可以达到这个目标了。 

下面，我们完全使用注释定义 Bean 并完成 Bean 之间装配： 
使用 @Component 注释的Woman.java 

Java代码  

1. @Component  
2. public class Woman{  
3.     …  
4. }  

使用 @Component 注释的Woman.java 

Java代码  

1. @Component  
2. public class Man{  
3.     …  
4. }  

这样，我们就可以在 Human类中通过 @Autowired 注入前面定义的 Woman和 Man Bean 了。 

Java代码  

1. @Component("human")  
2. public class Human{  
3.     @Autowired  
4.     private Woman woman;  
5.   
6.     @Autowired  
7.     private Man man;  
8.     …  
9. }  

一般情况下，Bean 都是 singleton 的，需要注入 Bean 的地方仅需要通过 byType 策略就可以自动注入了，所以大可不必指定 Bean 的名称。如果需要使用其它作用范围的 Bean，可以通过 @Scope 注释来达到目标: 

Java代码  

1. @Scope("prototype")  
2. @Component("human")  
3. public class Human{  
4.        …  
5. }  

在使用 @Component 注释后，Spring 容器必须启用类扫描机制以启用注释驱动 Bean 定义和注释驱动 Bean 自动注入的策略。Spring 2.5 对 context 命名空间进行了扩展，提供了这一功能，请看下面的配置： 

Xml代码  

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.     xmlns:context="http://www.springframework.org/schema/context"  
5.     xsi:schemaLocation="http://www.springframework.org/schema/beans   
6.  http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
7.  http://www.springframework.org/schema/context   
8.  http://www.springframework.org/schema/context/spring-context-2.5.xsd">  
9.     <context:component-scan base-package="springlive.learn.component "/>  
10. </beans>  

参考资料: 
使用 Spring 2.5 注释驱动的 IoC 功能http://www.ibm.com/developerworks/cn/java/j-lo-spring25-ioc/?ca=drs-tp0808