Spring2.5 IoC之bean的四种注入方式(实践篇)

1、新建一个java工程名叫DI(依赖注入的意思)，加入commons-loggin.jar和spring.jar。注意下面的代码含义见其注释，这里就不再作解释。

2、整个工程测试完后spring配置文件beans.xml文件的代码如下：

Xml代码

1. <?xml version="1.0" encoding="gbk"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.        xsi:schemaLocation="http://www.springframework.org/schema/beans   
5.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">  
6.    <!--构造器注入简单类型的参数-->  
7.    <bean name="cipb" class="com.iwtxokhtd.constructor.injection.bean.ConstructorInjectionPropertyBean">  
8.       <!--根据类型顺序来匹配,要指定type属性-->  
9.       <constructor-arg type="int" value="25"/>  
10.       <!--必须是java.lang.String，不能是String，否则会报异常-->  
11.       <constructor-arg type="java.lang.String" value="iwtxokhtd"/>  
12.    </bean>  
13.    <!--用索引可以避免多个同类型的情况,从0开始-->  
14.     <bean name="indexProsBean" class="com.iwtxokhtd.constructor.injection.bean.ConstructorInjectionPropertyBean">  
15.       <constructor-arg index="0" value="20"/>  
16.       <constructor-arg index="1" value="tujiyue"/>  
17.    </bean>  
18.      
19.    <!--构造器注入对象-->  
20.    <bean name="ciob" class="com.iwtxokhtd.constructor.injection.bean.ConstructorInjectionObjectBean">  
21.      <constructor-arg>  
22.         <ref bean="depentedBean"/>  
23.      </constructor-arg>  
24.      <constructor-arg type="java.lang.String" value="增加一个简单类型"/>  
25.    </bean>  
26.     <!--被依赖的bean,其属性也采用构造器注入-->  
27.    <bean name="depentedBean" class="com.iwtxokhtd.constructor.injection.bean.DepentedObjectConstructorBean">  
28.      <!--以下两个属性都是java.lang.String最好用index-->  
29.      <constructor-arg type="java.lang.String" value="属性一"/>  
30.      <!--下面这种写法与上相同-->  
31.      <constructor-arg type="java.lang.String">  
32.         <value>属性二</value>  
33.      </constructor-arg>  
34.    </bean>  
35.    <!--setter注入简单类型属性-->  
36.    <bean name="sipb" class="com.iwtxokhtd.setter.injection.bean.SetterInjectionPropertyBean">  
37.      <property name="id" value="1"/>  
38.      <!--这种写法与上一样-->  
39.      <property name="name">  
40.         <value>iwtxokhtd</value>  
41.      </property>  
42.    </bean>  
43.    <!--setter注入对象类型-->  
44.    <bean name="siob" class="com.iwtxokhtd.setter.injection.bean.SetterInjectionObjectBean">  
45.     <!--那个简单的类型-->  
46.     <property name="year" value="60"/>  
47.     <!--对象类型-->  
48.     <property name="dosb" ref="depentSetterBean"/>  
49.     <!--等价于上面的配置方式-->  
50.     <!--   
51.     <property name="dosb">  
52.      <ref bean="depentSetterBean"/>  
53.     </property>  
54.     -->  
55.    </bean>  
56.    <!--被信赖setter注入的对象-->  
57.    <bean name="depentSetterBean" class="com.iwtxokhtd.setter.injection.bean.DepentedObjectSetterBean">  
58.     <!--两个简单类型的属性-->  
59.     <property name="propertyOne" value="setter属性值一"/>  
60.     <property name="propertyTwo" value="setter属性值二"/>  
61.    </bean>  
62.    <!--静态工厂方法参数注入对象-->  
63.    <bean name="sfmob" class="com.iwtxokhtd.staticfactory.injection.bean.StaticFactoryMethodObjectBean"  
64.     factory-method="createInstance">  
65.      <!--语法规则依然是使用构造器注入方式-->  
66.      <constructor-arg ref="dfmob"/>  
67.      <!--还有一个简单的类型-->  
68.      <constructor-arg type="int" value="100"/>  
69.      <!--等价形式-->  
70.      <!--   
71.      <constructor-arg>  
72.       <ref bean="dfmob"/>  
73.      </constructor-arg>  
74.      -->  
75.    </bean>  
76.    <!--工厂方法依赖注入的对象-->  
77.    <bean name="dfmob" class="com.iwtxokhtd.staticfactory.injection.bean.DepentedFactoryMethodObjectBean">  
78.      <!--里面有一个简单类型的setter注入-->  
79.      <property name="one" value="一个简单的类型"/>  
80.    </bean>  
81.    <!--InstanceFactoryMethodObjectBean一定要有个默认的构造器-->  
82.     <bean name="ifmob"  class="com.iwtxokhtd.instancefactory.injection.bean.InstanceFactoryMethodObjectBean"/>  
83.    <!--实例工厂方法参数注入对象-->  
84.    <bean name="ifmobtest"    
85.    factory-bean="ifmob" factory-method="createInstance">        
86.      <constructor-arg ref="dfmob"/>  
87.      <constructor-arg type="java.lang.String" value="实例工厂方法注入"/>  
88.    </bean>  
89. </beans>  

<?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代码

1. /**  
2.  * 构造器注入属性Bean  
3.  */  
4. package com.iwtxokhtd.constructor.injection.bean;   
5.   
6. /**  
7.  * @author Administrator  
8.  *  
9.  */  
10. public class ConstructorInjectionPropertyBean {   
11.   
12.     //简单类型，依赖的构造器属性   
13.     private int age;   
14.     private String name;   
15.     public ConstructorInjectionPropertyBean(int age, String name) {   
16.         this.age = age;   
17.         this.name = name;   
18.     }   
19.     //提供外部访问   
20.     public int getAge(){   
21.         return age;   
22.     }   
23.     public String getName(){   
24.         return name;   
25.     }   
26.        
27.        
28. }  

/** * 构造器注入属性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代码

1. /**  
2.  * 构造器注入对象bean  
3.  */  
4. package com.iwtxokhtd.constructor.injection.bean;   
5.   
6. /**  
7.  * @author Administrator  
8.  *  
9.  */  
10. public class ConstructorInjectionObjectBean {   
11.   
12.     //依赖的对象   
13.     private DepentedObjectConstructorBean db;   
14.     //也提供一个简单的类型作测试   
15.     private String simple;   
16.        
17.     //注入到构造器中   
18.     public ConstructorInjectionObjectBean(DepentedObjectConstructorBean db,String simple) {   
19.         this.db = db;   
20.         this.simple=simple;   
21.     }   
22.     //提供外部访问   
23.     public DepentedObjectConstructorBean getDb() {   
24.         return db;   
25.     }   
26.     public String getSimple() {   
27.         return simple;   
28.     }   
29.        
30.        
31. }  

/** * 构造器注入对象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代码

1. /**  
2.  * 被信赖的对象bean  
3.  */  
4. package com.iwtxokhtd.constructor.injection.bean;   
5.   
6. /**  
7.  * @author Administrator  
8.  *  
9.  */  
10. public class DepentedObjectConstructorBean {   
11.   
12.     private String paramOne;   
13.     private String paramTwo;   
14.     public DepentedObjectConstructorBean(String paramOne, String paramTwo) {   
15.         this.paramOne = paramOne;   
16.         this.paramTwo = paramTwo;   
17.     }   
18.     //提供外部访问   
19.     public String getParamOne() {   
20.         return paramOne;   
21.     }   
22.     public String getParamTwo() {   
23.         return paramTwo;   
24.     }   
25.        
26.        
27. }  

/** * 被信赖的对象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代码

1. /**  
2.  * setter注入简单类型属性bean  
3.  */  
4. package com.iwtxokhtd.setter.injection.bean;   
5.   
6. /**  
7.  * @author Administrator  
8.  *  
9.  */  
10. public class SetterInjectionPropertyBean {   
11.   
12.     //依赖的属性1   
13.     private int id;   
14.     private String name;   
15.     public int getId() {   
16.         return id;   
17.     }   
18.     //setter注入   
19.     public void setId(int id) {   
20.         this.id = id;   
21.     }   
22.     public String getName() {   
23.         return name;   
24.     }   
25.     //setter注入   
26.     public void setName(String name) {   
27.         this.name = name;   
28.     }   
29. }  

/** * setter注入简单类型属性bean */package com.iwtxokhtd.setter.injection.bean;/** * @author Administrator * */public class SetterInjectionPropertyBean {//依赖的属性1private 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代码

1. /**  
2.  * setter注入对象类型bean  
3.  */  
4. package com.iwtxokhtd.setter.injection.bean;   
5.   
6. /**  
7.  * @author Administrator  
8.  *  
9.  */  
10. public class SetterInjectionObjectBean {   
11.   
12.     //依赖setter注入的对象   
13.     private DepentedObjectSetterBean dosb;   
14.     //也提供一个简单的类型   
15.     private int year;   
16.   
17.     public DepentedObjectSetterBean getDosb() {   
18.         return dosb;   
19.     }   
20.   
21.     public void setDosb(DepentedObjectSetterBean dosb) {   
22.         this.dosb = dosb;   
23.     }   
24.   
25.     public int getYear() {   
26.         return year;   
27.     }   
28.   
29.     public void setYear(int year) {   
30.         this.year = year;   
31.     }   
32.        
33. }  

/** * 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代码

1. /**  
2.  * 被依赖setter注入的对象bean  
3.  */  
4. package com.iwtxokhtd.setter.injection.bean;   
5.   
6. /**  
7.  * @author Administrator  
8.  *  
9.  */  
10. public class DepentedObjectSetterBean {   
11.   
12.     //提供两个简单的类型，也用setter注入   
13.     private String propertyOne;   
14.     private String propertyTwo;   
15.     public String getPropertyOne() {   
16.         return propertyOne;   
17.     }   
18.     public void setPropertyOne(String propertyOne) {   
19.         this.propertyOne = propertyOne;   
20.     }   
21.     public String getPropertyTwo() {   
22.         return propertyTwo;   
23.     }   
24.     public void setPropertyTwo(String propertyTwo) {   
25.         this.propertyTwo = propertyTwo;   
26.     }   
27.        
28. }  

/** * 被依赖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代码

1. /**  
2.  * 静态工厂方法构造注入参数  
3.  */  
4. package com.iwtxokhtd.staticfactory.injection.bean;   
5.   
6. /**  
7.  * @author Administrator  
8.  *  
9.  */  
10. public class StaticFactoryMethodObjectBean {   
11.     //依赖静态工作方法注入的对象   
12.     private DepentedFactoryMethodObjectBean dsfmob;   
13.     //提供一个简单类型的属性   
14.     private int property;   
15.     //私有的构造器   
16.     private StaticFactoryMethodObjectBean(DepentedFactoryMethodObjectBean dsfmob,int property){   
17.         this.dsfmob=dsfmob;   
18.         this.property=property;   
19.     }   
20.     //静态工厂方法   
21.     public static StaticFactoryMethodObjectBean createInstance(DepentedFactoryMethodObjectBean dsfmob,int property){   
22.         StaticFactoryMethodObjectBean smob=new StaticFactoryMethodObjectBean(dsfmob,property);   
23.         return smob;   
24.     }   
25.     //提供外部访问   
26.     public DepentedFactoryMethodObjectBean getDsfmob() {   
27.         return dsfmob;   
28.     }   
29.     public int getProperty() {   
30.         return property;   
31.     }   
32. }  

/** * 静态工厂方法构造注入参数 */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代码

1. /**  
2.  * 被依赖静态工厂方法注入的对象  
3.  */  
4. package com.iwtxokhtd.staticfactory.injection.bean;   
5.   
6. /**  
7.  * @author Administrator  
8.  *  
9.  */  
10. public class DepentedFactoryMethodObjectBean {   
11.   
12.     //提供一个简单的对象类型作为测试用   
13.     private String one;   
14.   
15.     public String getOne() {   
16.         return one;   
17.     }   
18.   
19.     //用setter注入   
20.     public void setOne(String one) {   
21.         this.one = one;   
22.     }   
23. }  

/** * 被依赖静态工厂方法注入的对象 */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代码

1. /**  
2.  * 实例工厂方法构造注入对象bean  
3.  */  
4. package com.iwtxokhtd.instancefactory.injection.bean;   
5.   
6. import com.iwtxokhtd.staticfactory.injection.bean.DepentedFactoryMethodObjectBean;   
7.   
8. /**  
9.  * @author Administrator  
10.  *  
11.  */  
12. public class InstanceFactoryMethodObjectBean {   
13.   
14.     //依赖的对象   
15.     private DepentedFactoryMethodObjectBean dfmob;   
16.     //提供一个简单的类型   
17.     private String two;   
18.     //这个默认的空构造器不能少,否则bean会创建失败   
19.     private InstanceFactoryMethodObjectBean(){   
20.            
21.     }   
22.     //私有的构造器   
23.     private InstanceFactoryMethodObjectBean(DepentedFactoryMethodObjectBean dfmob,String two){   
24.         this.dfmob=dfmob;   
25.         this.two=two;   
26.     }   
27.     //实例工厂方法   
28.     public InstanceFactoryMethodObjectBean createInstance(DepentedFactoryMethodObjectBean dfmob,String two){   
29.         InstanceFactoryMethodObjectBean ifmob=new InstanceFactoryMethodObjectBean(dfmob,two);   
30.         return ifmob;   
31.     }   
32.     public DepentedFactoryMethodObjectBean getDfmob() {   
33.         return dfmob;   
34.     }   
35.     public String getTwo() {   
36.         return two;   
37.     }   
38. }  

/** * 实例工厂方法构造注入对象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代码

1. /**  
2.  * 构造器注入测试类  
3.  */  
4. package com.iwtxokhtd.constructor.injection.test;   
5.   
6. import org.springframework.context.ApplicationContext;   
7. import org.springframework.context.support.ClassPathXmlApplicationContext;   
8.   
9. import com.iwtxokhtd.constructor.injection.bean.ConstructorInjectionObjectBean;   
10. import com.iwtxokhtd.constructor.injection.bean.ConstructorInjectionPropertyBean;   
11. import com.iwtxokhtd.instancefactory.injection.bean.InstanceFactoryMethodObjectBean;   
12. import com.iwtxokhtd.setter.injection.bean.SetterInjectionObjectBean;   
13. import com.iwtxokhtd.setter.injection.bean.SetterInjectionPropertyBean;   
14. import com.iwtxokhtd.staticfactory.injection.bean.StaticFactoryMethodObjectBean;   
15.   
16. /**  
17.  * @author Administrator  
18.  *  
19.  */  
20. public class InjectionTest {   
21.   
22.        
23.     public static void main(String[] args) {   
24.         ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");   
25.         System.out.println("构造器注入属性,配置时指定type属性");   
26.         //取得bean   
27.         ConstructorInjectionPropertyBean cipb=(ConstructorInjectionPropertyBean)ac.getBean("cipb");   
28.         //打印注入的两个属性值   
29.         System.out.println("构造器注入属性之年龄："+cipb.getAge());   
30.         System.out.println("构造器注入属性之姓名："+cipb.getName());   
31.         //用索引设置属性值的方式   
32.         System.out.println("构造器注入属性,配置时指定index属性");   
33.         cipb=(ConstructorInjectionPropertyBean)ac.getBean("indexProsBean");   
34.         //打印注入的两个属性值   
35.         System.out.println("构造器注入属性换了索引之年龄："+cipb.getAge());   
36.         System.out.println("构造器注入属性换了索引之姓名："+cipb.getName());   
37.         System.out.println("----------------------------------");   
38.         System.out.println("构造器注入对象,也加了个简单类型");   
39.         ConstructorInjectionObjectBean ciob=(ConstructorInjectionObjectBean)ac.getBean("ciob");   
40.         System.out.println("先访问其注入的简单类型");   
41.         System.out.println("构造器注入对象之简单类型："+ciob.getSimple());   
42.         System.out.println("再访问其注入的对象类型");   
43.         System.out.println("其注入对象的第一个注入的属性值："+ciob.getDb().getParamOne());   
44.         System.out.println("其注入对象的第二个注入的属性值："+ciob.getDb().getParamTwo());   
45.         System.out.println("----------------------------------");   
46.         System.out.println("Setter方法注入简单类型属性");   
47.         SetterInjectionPropertyBean sipb=(SetterInjectionPropertyBean)ac.getBean("sipb");   
48.         System.out.println("setter注入简单类型属性id："+sipb.getId());   
49.         System.out.println("setter注入简单类型属性name："+sipb.getName());   
50.         System.out.println("----------------------------------");   
51.         System.out.println("Setter方法注入对象类型,也加了一个简单的属性");   
52.         SetterInjectionObjectBean siob=(SetterInjectionObjectBean)ac.getBean("siob");   
53.         System.out.println("先访问setter注入的简单类型");   
54.         System.out.println("setter注入对象之简单类型："+siob.getYear());   
55.         System.out.println("再访问setter注入的对象类型");   
56.         System.out.println("setter注入对象的第一个注入的属性值："+siob.getDosb().getPropertyOne());   
57.         System.out.println("setter注入对象的第二个注入的属性值："+siob.getDosb().getPropertyTwo());   
58.         System.out.println("----------------------------------");   
59.         System.out.println("静态工厂方法注入对象类型,也加了一个简单的属性");   
60.         StaticFactoryMethodObjectBean sfmob=(StaticFactoryMethodObjectBean)ac.getBean("sfmob");   
61.         System.out.println("先访问静态工厂方法注入的简单类型");   
62.         System.out.println("静态工厂方法注入对象之简单类型："+sfmob.getProperty());   
63.         System.out.println("再访问静态工厂方法注入的对象类型");   
64.         System.out.println("静态工厂方法注入对象所注入的属性值："+sfmob.getDsfmob().getOne());   
65.         System.out.println("----------------------------------");   
66.         System.out.println("实例工厂方法注入对象类型,也加了一个简单的属性");   
67.         InstanceFactoryMethodObjectBean ifmob=(InstanceFactoryMethodObjectBean)ac.getBean("ifmobtest");   
68.         System.out.println("先访问实例工厂方法注入的简单类型");   
69.         System.out.println("实例工厂方法注入对象之简单类型："+ifmob.getTwo());   
70.         System.out.println("再访问实例工厂方法注入的对象类型");   
71.         System.out.println("实例工厂方法注入对象所注入的属性值："+ifmob.getDfmob().getOne());   
72.     }   
73.   
74. }  

/** * 构造器注入测试类 */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属性");//取得beanConstructorInjectionPropertyBean 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
再访问静态工厂方法注入的对象类型
静态工厂方法注入对象所注入的属性值：一个简单的类型
----------------------------------
实例工厂方法注入对象类型,也加了一个简单的属性
先访问实例工厂方法注入的简单类型
实例工厂方法注入对象之简单类型：实例工厂方法注入
再访问实例工厂方法注入的对象类型
实例工厂方法注入对象所注入的属性值：一个简单的类型