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>

<?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;

}

}

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

}

}

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

}

}

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

}

}

/**
* 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;

}

}

/**
* 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;

}

}

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

}

}

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

}

}

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

}

}

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

}

}

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