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
再访问静态工厂方法注入的对象类型
静态工厂方法注入对象所注入的属性值：一个简单的类型
----------------------------------
实例工厂方法注入对象类型,也加了一个简单的属性
先访问实例工厂方法注入的简单类型
实例工厂方法注入对象之简单类型：实例工厂方法注入
再访问实例工厂方法注入的对象类型
实例工厂方法注入对象所注入的属性值：一个简单的类型