Spring2.5 IoC之bean的四种注入方式（转）

1、新建一个java工程名叫DI(依赖注入的意思)，加入commons-loggin.jar和spring.jar。注意下面的代码含义见其注释，这里就不再作解释。
2、整个工程测试完后spring配置文件beans.xml文件的代码如下：
Xml代码
<?xml version="1.0" encoding="gbk"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<!--构造器注入简单类型的参数-->
<bean name="cipb" class="com.iwtxokhtd.constructor.injection.bean.ConstructorInjectionPropertyBean">
<!--根据类型顺序来匹配,要指定type属性-->
<constructor-arg type="int" value="25"/>
<!--必须是java.lang.String，不能是String，否则会报异常-->
<constructor-arg type="java.lang.String" value="iwtxokhtd"/>
</bean>
<!--用索引可以避免多个同类型的情况,从0开始-->
<bean name="indexProsBean" class="com.iwtxokhtd.constructor.injection.bean.ConstructorInjectionPropertyBean">
<constructor-arg index="0" value="20"/>
<constructor-arg index="1" value="tujiyue"/>
</bean>

<!--构造器注入对象-->
<bean name="ciob" class="com.iwtxokhtd.constructor.injection.bean.ConstructorInjectionObjectBean">
<constructor-arg>
<ref bean="depentedBean"/>
</constructor-arg>
<constructor-arg type="java.lang.String" value="增加一个简单类型"/>
</bean>
<!--被依赖的bean,其属性也采用构造器注入-->
<bean name="depentedBean" class="com.iwtxokhtd.constructor.injection.bean.DepentedObjectConstructorBean">
<!--以下两个属性都是java.lang.String最好用index-->
<constructor-arg type="java.lang.String" value="属性一"/>
<!--下面这种写法与上相同-->
<constructor-arg type="java.lang.String">
<value>属性二</value>
</constructor-arg>
</bean>
<!--setter注入简单类型属性-->
<bean name="sipb" class="com.iwtxokhtd.setter.injection.bean.SetterInjectionPropertyBean">
<property name="id" value="1"/>
<!--这种写法与上一样-->
<property name="name">
<value>iwtxokhtd</value>
</property>
</bean>
<!--setter注入对象类型-->
<bean name="siob" class="com.iwtxokhtd.setter.injection.bean.SetterInjectionObjectBean">
<!--那个简单的类型-->
<property name="year" value="60"/>
<!--对象类型-->
<property name="dosb" ref="depentSetterBean"/>
<!--等价于上面的配置方式-->
<!--
<property name="dosb">
<ref bean="depentSetterBean"/>
</property>
-->
</bean>
<!--被信赖setter注入的对象-->
<bean name="depentSetterBean" class="com.iwtxokhtd.setter.injection.bean.DepentedObjectSetterBean">
<!--两个简单类型的属性-->
<property name="propertyOne" value="setter属性值一"/>
<property name="propertyTwo" value="setter属性值二"/>
</bean>
<!--静态工厂方法参数注入对象-->
<bean name="sfmob" class="com.iwtxokhtd.staticfactory.injection.bean.StaticFactoryMethodObjectBean"
factory-method="createInstance">
<!--语法规则依然是使用构造器注入方式-->
<constructor-arg ref="dfmob"/>
<!--还有一个简单的类型-->
<constructor-arg type="int" value="100"/>
<!--等价形式-->
<!--
<constructor-arg>
<ref bean="dfmob"/>
</constructor-arg>
-->
</bean>
<!--工厂方法依赖注入的对象-->
<bean name="dfmob" class="com.iwtxokhtd.staticfactory.injection.bean.DepentedFactoryMethodObjectBean">
<!--里面有一个简单类型的setter注入-->
<property name="one" value="一个简单的类型"/>
</bean>
<!--InstanceFactoryMethodObjectBean一定要有个默认的构造器-->
<bean name="ifmob" class="com.iwtxokhtd.instancefactory.injection.bean.InstanceFactoryMethodObjectBean"/>
<!--实例工厂方法参数注入对象-->
<bean name="ifmobtest"
factory-bean="ifmob" factory-method="createInstance">
<constructor-arg ref="dfmob"/>
<constructor-arg type="java.lang.String" value="实例工厂方法注入"/>
</bean>
</beans>

3、bean的四种注入方式
第一种注入方式：构造器注入
Java代码
/**
* 构造器注入属性Bean
*/
package com.iwtxokhtd.constructor.injection.bean;

/**
* @author Administrator
*
*/
public class ConstructorInjectionPropertyBean {

//简单类型，依赖的构造器属性
private int age;
private String name;
public ConstructorInjectionPropertyBean(int age, String name) {
this.age = age;
this.name = name;
}
//提供外部访问
public int getAge(){
return age;
}
public String getName(){
return name;
}


}

Java代码
/**
* 构造器注入对象bean
*/
package com.iwtxokhtd.constructor.injection.bean;

/**
* @author Administrator
*
*/
public class ConstructorInjectionObjectBean {

//依赖的对象
private DepentedObjectConstructorBean db;
//也提供一个简单的类型作测试
private String simple;

//注入到构造器中
public ConstructorInjectionObjectBean(DepentedObjectConstructorBean db,String simple) {
this.db = db;
this.simple=simple;
}
//提供外部访问
public DepentedObjectConstructorBean getDb() {
return db;
}
public String getSimple() {
return simple;
}


}

Java代码
/**
* 被信赖的对象bean
*/
package com.iwtxokhtd.constructor.injection.bean;

/**
* @author Administrator
*
*/
public class DepentedObjectConstructorBean {

private String paramOne;
private String paramTwo;
public DepentedObjectConstructorBean(String paramOne, String paramTwo) {
this.paramOne = paramOne;
this.paramTwo = paramTwo;
}
//提供外部访问
public String getParamOne() {
return paramOne;
}
public String getParamTwo() {
return paramTwo;
}


}

第二种注入方式：setter注入
Java代码
/**
* setter注入简单类型属性bean
*/
package com.iwtxokhtd.setter.injection.bean;

/**
* @author Administrator
*
*/
public class SetterInjectionPropertyBean {

//依赖的属性1
private int id;
private String name;
public int getId() {
return id;
}
//setter注入
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
//setter注入
public void setName(String name) {
this.name = name;
}
}

Java代码
/**
* setter注入对象类型bean
*/
package com.iwtxokhtd.setter.injection.bean;

/**
* @author Administrator
*
*/
public class SetterInjectionObjectBean {

//依赖setter注入的对象
private DepentedObjectSetterBean dosb;
//也提供一个简单的类型
private int year;

public DepentedObjectSetterBean getDosb() {
return dosb;
}

public void setDosb(DepentedObjectSetterBean dosb) {
this.dosb = dosb;
}

public int getYear() {
return year;
}

public void setYear(int year) {
this.year = year;
}

}

Java代码
/**
* 被依赖setter注入的对象bean
*/
package com.iwtxokhtd.setter.injection.bean;

/**
* @author Administrator
*
*/
public class DepentedObjectSetterBean {

//提供两个简单的类型，也用setter注入
private String propertyOne;
private String propertyTwo;
public String getPropertyOne() {
return propertyOne;
}
public void setPropertyOne(String propertyOne) {
this.propertyOne = propertyOne;
}
public String getPropertyTwo() {
return propertyTwo;
}
public void setPropertyTwo(String propertyTwo) {
this.propertyTwo = propertyTwo;
}

}

第三种注入方式：静态工厂方法参数注入
Java代码
/**
* 静态工厂方法构造注入参数
*/
package com.iwtxokhtd.staticfactory.injection.bean;

/**
* @author Administrator
*
*/
public class StaticFactoryMethodObjectBean {
//依赖静态工作方法注入的对象
private DepentedFactoryMethodObjectBean dsfmob;
//提供一个简单类型的属性
private int property;
//私有的构造器
private StaticFactoryMethodObjectBean(DepentedFactoryMethodObjectBean dsfmob,int property){
this.dsfmob=dsfmob;
this.property=property;
}
//静态工厂方法
public static StaticFactoryMethodObjectBean createInstance(DepentedFactoryMethodObjectBean dsfmob,int property){
StaticFactoryMethodObjectBean smob=new StaticFactoryMethodObjectBean(dsfmob,property);
return smob;
}
//提供外部访问
public DepentedFactoryMethodObjectBean getDsfmob() {
return dsfmob;
}
public int getProperty() {
return property;
}
}

Java代码
/**
* 被依赖静态工厂方法注入的对象
*/
package com.iwtxokhtd.staticfactory.injection.bean;

/**
* @author Administrator
*
*/
public class DepentedFactoryMethodObjectBean {

//提供一个简单的对象类型作为测试用
private String one;

public String getOne() {
return one;
}

//用setter注入
public void setOne(String one) {
this.one = one;
}
}

第四种注入方式：实例工厂方法参数注入
Java代码
/**
* 实例工厂方法构造注入对象bean
*/
package com.iwtxokhtd.instancefactory.injection.bean;

import com.iwtxokhtd.staticfactory.injection.bean.DepentedFactoryMethodObjectBean;

/**
* @author Administrator
*
*/
public class InstanceFactoryMethodObjectBean {

//依赖的对象
private DepentedFactoryMethodObjectBean dfmob;
//提供一个简单的类型
private String two;
//这个默认的空构造器不能少,否则bean会创建失败
private InstanceFactoryMethodObjectBean(){

}
//私有的构造器
private InstanceFactoryMethodObjectBean(DepentedFactoryMethodObjectBean dfmob,String two){
this.dfmob=dfmob;
this.two=two;
}
//实例工厂方法
public InstanceFactoryMethodObjectBean createInstance(DepentedFactoryMethodObjectBean dfmob,String two){
InstanceFactoryMethodObjectBean ifmob=new InstanceFactoryMethodObjectBean(dfmob,two);
return ifmob;
}
public DepentedFactoryMethodObjectBean getDfmob() {
return dfmob;
}
public String getTwo() {
return two;
}
}

客户端测试：
Java代码
/**
* 构造器注入测试类
*/
package com.iwtxokhtd.constructor.injection.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.iwtxokhtd.constructor.injection.bean.ConstructorInjectionObjectBean;
import com.iwtxokhtd.constructor.injection.bean.ConstructorInjectionPropertyBean;
import com.iwtxokhtd.instancefactory.injection.bean.InstanceFactoryMethodObjectBean;
import com.iwtxokhtd.setter.injection.bean.SetterInjectionObjectBean;
import com.iwtxokhtd.setter.injection.bean.SetterInjectionPropertyBean;
import com.iwtxokhtd.staticfactory.injection.bean.StaticFactoryMethodObjectBean;

/**
* @author Administrator
*
*/
public class InjectionTest {


public static void main(String[] args) {
ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
System.out.println("构造器注入属性,配置时指定type属性");
//取得bean
ConstructorInjectionPropertyBean cipb=(ConstructorInjectionPropertyBean)ac.getBean("cipb");
//打印注入的两个属性值
System.out.println("构造器注入属性之年龄："+cipb.getAge());
System.out.println("构造器注入属性之姓名："+cipb.getName());
//用索引设置属性值的方式
System.out.println("构造器注入属性,配置时指定index属性");
cipb=(ConstructorInjectionPropertyBean)ac.getBean("indexProsBean");
//打印注入的两个属性值
System.out.println("构造器注入属性换了索引之年龄："+cipb.getAge());
System.out.println("构造器注入属性换了索引之姓名："+cipb.getName());
System.out.println("----------------------------------");
System.out.println("构造器注入对象,也加了个简单类型");
ConstructorInjectionObjectBean ciob=(ConstructorInjectionObjectBean)ac.getBean("ciob");
System.out.println("先访问其注入的简单类型");
System.out.println("构造器注入对象之简单类型："+ciob.getSimple());
System.out.println("再访问其注入的对象类型");
System.out.println("其注入对象的第一个注入的属性值："+ciob.getDb().getParamOne());
System.out.println("其注入对象的第二个注入的属性值："+ciob.getDb().getParamTwo());
System.out.println("----------------------------------");
System.out.println("Setter方法注入简单类型属性");
SetterInjectionPropertyBean sipb=(SetterInjectionPropertyBean)ac.getBean("sipb");
System.out.println("setter注入简单类型属性id："+sipb.getId());
System.out.println("setter注入简单类型属性name："+sipb.getName());
System.out.println("----------------------------------");
System.out.println("Setter方法注入对象类型,也加了一个简单的属性");
SetterInjectionObjectBean siob=(SetterInjectionObjectBean)ac.getBean("siob");
System.out.println("先访问setter注入的简单类型");
System.out.println("setter注入对象之简单类型："+siob.getYear());
System.out.println("再访问setter注入的对象类型");
System.out.println("setter注入对象的第一个注入的属性值："+siob.getDosb().getPropertyOne());
System.out.println("setter注入对象的第二个注入的属性值："+siob.getDosb().getPropertyTwo());
System.out.println("----------------------------------");
System.out.println("静态工厂方法注入对象类型,也加了一个简单的属性");
StaticFactoryMethodObjectBean sfmob=(StaticFactoryMethodObjectBean)ac.getBean("sfmob");
System.out.println("先访问静态工厂方法注入的简单类型");
System.out.println("静态工厂方法注入对象之简单类型："+sfmob.getProperty());
System.out.println("再访问静态工厂方法注入的对象类型");
System.out.println("静态工厂方法注入对象所注入的属性值："+sfmob.getDsfmob().getOne());
System.out.println("----------------------------------");
System.out.println("实例工厂方法注入对象类型,也加了一个简单的属性");
InstanceFactoryMethodObjectBean ifmob=(InstanceFactoryMethodObjectBean)ac.getBean("ifmobtest");
System.out.println("先访问实例工厂方法注入的简单类型");
System.out.println("实例工厂方法注入对象之简单类型："+ifmob.getTwo());
System.out.println("再访问实例工厂方法注入的对象类型");
System.out.println("实例工厂方法注入对象所注入的属性值："+ifmob.getDfmob().getOne());
}

}

测试结果：请对照beans.xml文件来验证结果
构造器注入属性,配置时指定type属性
构造器注入属性之年龄：25
构造器注入属性之姓名：iwtxokhtd
构造器注入属性,配置时指定index属性
构造器注入属性换了索引之年龄：20
构造器注入属性换了索引之姓名：tujiyue
----------------------------------
构造器注入对象,也加了个简单类型
先访问其注入的简单类型
构造器注入对象之简单类型：增加一个简单类型
再访问其注入的对象类型
其注入对象的第一个注入的属性值：属性一
其注入对象的第二个注入的属性值：属性二
----------------------------------
Setter方法注入简单类型属性
setter注入简单类型属性id：1
setter注入简单类型属性name：iwtxokhtd
----------------------------------
Setter方法注入对象类型,也加了一个简单的属性
先访问setter注入的简单类型
setter注入对象之简单类型：60
再访问setter注入的对象类型
setter注入对象的第一个注入的属性值：setter属性值一
setter注入对象的第二个注入的属性值：setter属性值二
----------------------------------
静态工厂方法注入对象类型,也加了一个简单的属性
先访问静态工厂方法注入的简单类型
静态工厂方法注入对象之简单类型：100
再访问静态工厂方法注入的对象类型
静态工厂方法注入对象所注入的属性值：一个简单的类型
----------------------------------
实例工厂方法注入对象类型,也加了一个简单的属性
先访问实例工厂方法注入的简单类型
实例工厂方法注入对象之简单类型：实例工厂方法注入
再访问实例工厂方法注入的对象类型
实例工厂方法注入对象所注入的属性值：一个简单的类型