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

群组首页 → 企业架构 → Spring之旅 → 知识库 → Spring2.5 → Spring2.5 IoC之bean的四种注入方式(实践篇)

阅读:5640次评论:2条更新时间:2011-06-01

spring2.5 ioc bean 依赖注入

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

2、整个工程测试完后spring配置文件beans.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的四种注入方式

第一种注入方式：构造器注入

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

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

第三种注入方式：静态工厂方法参数注入

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

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

	public String getOne() {
		return one;
	}

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

第四种注入方式：实例工厂方法参数注入

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

客户端测试：

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