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

最新推荐文章于 2022-10-27 13:42:47 发布
最新推荐文章于 2022-10-27 13:42:47 发布
阅读量1.1k 收藏 8
点赞数
分类专栏： 网络文摘 文章标签： bean spring ioc setter string class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/icemenlover/article/details/4729211
版权
本文通过实例详细介绍了Spring2.5中bean的四种注入方式：构造器注入、setter注入、静态工厂方法注入和实例工厂方法注入。通过配置文件`beans.xml`展示了每种方式的具体使用，并在客户端进行测试，验证了注入效果。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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>  

 

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 {

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

spring框架学习 - spring IoC 之 Bean定义继承 及 容器扩展点
TyuIn的博客
12-15 1045
接上一篇博客：https://blog.csdn.net/qq_43605444/article/details/121948260?spm=1001.2014.3001.5502 8、Bean定义继承 一个 bean 定义可以包含很多配置信息，包括构造函数参数、属性值和容器特定的信息，例如初始化方法、静态工厂方法名称等。 子 bean 定义继承父定义的配置数据。 子定义可以根据需要覆盖某些值或添加其他值。 使用父 bean 和子 bean 定义可以节省大量的输入。 实际上，这是一种模板形式。 如果您以编程
Spring-Ioc之bean注入-singleton
kaxu00的博客
09-04 590
Spring-Ioc之bean注入-singleton 大家知道spring-ioc的bean注入是其核心模块。其中包括了beanDefinition的创建，bean的生命周期，特殊情况的bean-aop。最终形成的bean会有不同的scope熟悉。这里就先详细分析一下singleton-scope情况下，bean是如何通过spring的反射机制来实现注入的。 代码版本 spring 5.0...
IOC操作:Bean注入
qq_52112371的博客
11-25 255
注入 有参与无参注入 <!--无参,配置User对象--> <bean id="user" class="com.lesson01.User" > <property name ="id" value="1001"></property> </bean> <!--有参配置--> <bean id="have" class="com.lesson01.HaveArgs" &g
spring两种从ioc容器中获取bean实例的方法
qw160的博客
07-29 1236
spring两种从ioc容器中获取bean实例的方法.juint,@test 两种区别仅在junit测试 插播：junit和@test @Test的使用 是该方法可以不用main方法调用就可以测试出运行结果，是一种测试方法 一般函数都需要有main方法调用才能执行，注意被测试的方法必须是public修饰的 JUnit是一个Java语言的单元测试框架。它由Kent Beck和Erich Gamma建立，逐渐成为源于Kent Beck的sUnit的xUnit家族中最为成功的一个。 JUnit有它自己的JUnit
细说Spring——IoC详解（注解驱动开发之Bean的注入）
啦啦啦的博客
06-15 1268
一、前言 之前的IoC讲解部分大多是理论内容，感觉缺少一些操作示例，接下来我就会用Spring的注解开发，将一些主要的Spring黑科技展示出来，而所要展示的内容很多，可能一次写不完整，所以分为多篇博客进行讲解。下面我们一起学习一下Spring的注解驱动开发，我是参照尚硅谷的Spring注解驱动开发视频学习的此部分内容，自己实现了所有的代码，而这个视频大家可以在B站看到，也可以去尚硅谷官网下载，...
Spring总结一：IOC与Bean注入
yue_xx的博客
02-07 405
Spring 是什么？ Spring 是一个开源框架 Spring 为简化企业级应用开发而生。使用 Spring 可以使简单的 JavaBean 实现以前之后 EJB 才能实现的功能。 Spring 是一个 IOC（DI）和 AOP 容器框架。 具体描述 Spring 轻量级：Spring 是非侵入性的，基于 Spring 开发的应用中的对象可以不依赖 Spring 的 API 依赖注入（DI ...
spring 2.5 IOC 自动扫描,自动注入
03-12
自动注入是指Spring框架能够根据bean的依赖关系，自动地将所需的其他bean注入到目标bean中，无需在代码中使用new操作符创建对象。Spring支持多种注入方式，包括构造器注入、设值注入和接口注入。 在Spring 2.5中，...
Spring2.5 IOC的简单实现
03-18
**Spring 2.5 IOC（控制反转）的简单实现** Spring 框架是 Java 开发中的一个核心组件，尤其在企业级应用中广泛应用。它提供了依赖注入（Dependency Injection，DI），也就是通常所说的控制反转（Inversion of ...
struts2.1+spring2.5+hibernate3.3整合之第一步（spring2.5+hibernate3.3）
03-19
Spring2.5是全面的企业级应用框架，它不仅包含IoC（Inversion of Control，控制反转）容器，用于管理对象的生命周期和依赖关系，还提供了AOP（Aspect-Oriented Programming，面向切面编程）功能，实现了对横切关注点...
Spring2.5 IOC框架的源码解读与工具应用
### Spring2.5 IOC的简单实现 #### 知识点概述 本节将探讨Spring2.5版本中，基于控制反转（Inversion of Control, IOC）原理的简单实现。Spring框架是Java领域的一个轻量级的、全面的企业级应用开发框架，其中IOC...
ioc注入属性（外部bean和内部bean）
Mr_Fank_的博客
02-28 287
特殊值属性注入 null值 <property name="bauthor"> <null/> </property> 特殊符号 <property name="bname"> <value><![CDATA[///三体第四部///]]></value> </property> 注意：不可以写成<property name="bname" value="<![CDATA[/
Spring-Ioc之bean注入-scope
kaxu00的博客
09-20 443
这里简单试验一下spring注入时的自定义scope scope作用 spring-ioc支持bean的注入的同时，也支持定义bean的范围。而且范围的类型超出了java本身的类型以外，这些类型开箱即用，已经实现的范围类型有以下几种 Scope Description singleton （默认）将每个Spring IoC容器的bean definition范围限定为单个对象实例。...
Spring2.5 IoC之bean的四种注入方式(理论篇)
icemenlover的专栏
10-26 609
注入依赖依赖注入(DI)的基本原理是对象之间的依赖，通过以下几种方式实现：构造器的参数、工厂方法的参数，或给由构造函数或者工厂方法创建的对象设置属性。容器的工作就是创建bean时注入那些依赖关系，这样相对由bean自己来完成这些工作从控制上发生了根本性的倒转，因此依赖注入也叫控制反转(IoC)。DI注入有Setter和构造器两种注入方式。构造器注入：通过带参数的构造器实
SpringIOC注入bean方法（总和）
qq_44815020的博客
09-08 411
@SpringBootApplication 放置在Springboot启动类上，表明该类是开启Springboot容器的入口，它是一个复合注解。里面包含了包扫描，自动注入，配置注入的功能 @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan( excl
Spring2.5依靠注入的方式有三种
bean616的专栏
07-20 127
[code="java"]Spring2.5依靠注入的方式有三种： 1.通过setter方法注入； 2.通过构造方法注入； 3.通过注解进行注入； 第一种方式：通过setter方法注入 Java代码 package com.test; public class UserServiceImplement implements I...
SpringIoc中Bean的注入方式详解
qq_45626589的博客
07-21 1501
SpringIOC思想一、XMl注入，默认注入，XML 自动包扫描注入，属性的注入，set 方法注入，外部 Bean 的注入，复杂属性的注入，对象注入，数组注入，Map 注入，Properties 注入，二、注解注入，自动化配置，配置类自动扫描注入，对象注入，三、Bean 的作用域...
Spring中有哪些方式可以把Bean注入到IOC容器
weixin_44371237的博客
10-27 1720
把Bean注入到IOC容器里面的方式有7种方式
SpringIOC容器bean注入的几种方式
qq_66912832的博客
05-25 1805
bean注入的方式 如上图所示： 下面的注解都是用在主配置类中，也就是加了@Configuration的类里面 1.通过@CompentScan + @Controller @Service @Respository @component @ComponentScan的功能其实就是自动扫描并加载符合条件的组件 适用场景（内部bean）：针对我们自己写的组件可以通过该方式来进行加载到容器中。 2.通过@Configuration+@Bean的方式来导入组件 (适...
Spring2.5 IoC之bean的四种注入方式（转）
Rab
09-29 178
1、新建一个java工程名叫DI(依赖注入的意思)，加入commons-loggin.jar和spring.jar。注意下面的代码含义见其注释，这里就不再作解释。 2、整个工程测试完后spring配置文件beans.xml文件的代码如下： Xml代码 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值