`

Spring之IOC注入方式总结

阅读更多

         林炳文Evankaka原创作品。转载请注明出处http://blog.csdn.net/evankaka

        在定义了 JavaBean 装载信息之后需要对其赋值。一个 JavaBean 的赋值可以通过构造方法完成初始化,或者通过 set()方法初始化和改变属性值。下面分别介绍如何在 XML 中配置 JavaBean 的属性为构造方法和 set()方法传递参数。

本文工程下载

一、构造注入

在类被实例化的时候,它的构造方法被调用并且只能调用一次。所以它被用于类的初始化操作。<constructor-arg>是<bean>标签的子标签。通过其<value>子标签可以为构造
方法传递参数。现在以一个简单的输出学生信息的实例演示如何为构造方法传递参数。

实例程序创建过程如下。
(1)建立 Student 接口,它是对学生类的简单抽象。程序代码如下

 

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. package com.linbingwen;  
  2.   
  3. public interface Student {  
  4.  public void printInfo();  
  5. }  

(2)建立实现 Student 接口的 Stu1 类,定义姓名、年龄、性别 3 个属性和包含这 3个参数的构造方法,在实现接口的 printInfo()方法中输出所有属性信息。程序代码如下

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. package com.linbingwen;  
  2.   
  3. public class Stu1 implements Student {  
  4.     private String name;  
  5.     private String sex;  
  6.     private int age;  
  7.   
  8.     public Stu1(String name, String sex, int age) {  
  9.         super();  
  10.         this.name = name;  
  11.         this.sex = sex;  
  12.         this.age = age;  
  13.     }  
  14.   
  15.     public void printInfo() {  
  16.         System.out.println("姓名:" + name);  
  17.         System.out.println("年龄:" + age);  
  18.         System.out.println("性别:" + sex);  
  19.     }  
  20. }  

( 3 ) applicationContext.xml 是 装 配 JavaBean 的 配 置 文 件 , 它 通 过 3 个<constructor-arg>标签为构造方法传递两个 String 类型和一个 int 类型的参数。程序代
码如下。

 

 

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
  4.     xmlns:p="http://www.springframework.org/schema/p"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans 
  6. http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
  7.     <bean id="stu1" class="com.linbingwen.Stu1">  
  8.         <constructor-arg>  
  9.             <value>飞龙</value>  
  10.         </constructor-arg>  
  11.         <constructor-arg>  
  12.             <value></value>  
  13.         </constructor-arg>  
  14.         <constructor-arg>  
  15.             <value>26</value>  
  16.         </constructor-arg>  
  17.     </bean>  
  18. </beans>  

注意:这里要把applicationContext.xml放在src文件夹下。添加Spring和包不懂看这里
(4)创建 Info 类。它是实例的主类,负责载入容器,从容器中获得 Stu1 类的实例,并调用 Stu1 类的 pringInfo()方法打印学生信息。程序代码如下

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. package com.linbingwen;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6.   
  7.   
  8. public class Info {  
  9.   
  10.     public static void main(String[] args) {  
  11.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");  
  12.         Student student = (Student) applicationContext.getBean("stu1");  
  13.         student.printInfo();  
  14.     }  
  15.   
  16. }  


实例运行结果如图 所示。

 

        通过这个实例,可以看到容器通过多个<constructor-arg>标签完成了对构造方法的传参,但是如果标签的赋值顺序与构造方法中参数的顺序或参数类型不同,程序会产生异常。<constructor-arg>标签可以使用“index”属性和“type”属性解决此类问题。下面分别介绍这两个属性的用法。
type 属性:可以指定参数类型以确定要为构造方法的哪个参数赋值。当需要赋值的属性在构造方法中没有相同的类型时,可以使用这个参数。因此实例中 stu1 的配置信息可以
这样写:

 

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  4. xmlns:p="http://www.springframework.org/schema/p"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans 
  6. http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
  7.     <bean id="stu1" class="com.linbingwen.Stu1">  
  8.         <constructor-arg>  
  9.             <value>飞龙</value>  
  10.         </constructor-arg>  
  11.         <constructor-arg>  
  12.             <value></value>  
  13.         </constructor-arg>  
  14.         <constructor-arg type="int">  
  15.             <value>26</value>  
  16.         </constructor-arg>  
  17.     </bean>  
  18. </beans>  

index 属性:用于指定构造方法的参数索引,指定当前<constructor-arg>标签为构造方法的那个参数赋值。因为程序中含有两个 String 类型的参数,type 属性无法做判断,
导致 name 和 sex 参数无法判断正确性。这时需要设置 index 属性定义赋值索引来指定构造方法的参数位置。修改后的 applicationContext.xml 配置文件内容如下。

 

 

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  4. xmlns:p="http://www.springframework.org/schema/p"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans 
  6. http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
  7.     <bean id="stu1" class="com.linbingwen.Stu1">  
  8.         <constructor-arg index="0">  
  9.             <value>飞龙</value>  
  10.         </constructor-arg>  
  11.         <constructor-arg index="1">  
  12.             <value></value>  
  13.         </constructor-arg>  
  14.         <constructor-arg type="int">  
  15.             <value>26</value>  
  16.         </constructor-arg>  
  17.     </bean>  
  18. </beans>  

在修改后的代码中,两个 String 类型的参数通过“index”属性指定了在构造方法中的位置,确保了传参的正确性,第 3 个<constructor-arg>标签的 type 属性可以改写成
“index=2”。现在的 3 个<constructor-arg>标签可以随意调换顺序而不会影响到构造方法的正确赋值。<constructor-arg>标签还有“ref”和“value”两个属性,分别用于引用其他 JavaBean和定义新值。由于使用构造方法在配置文件中定义 JavaBean 使用得不多,所以这两个属性不再介绍。

 

二、设值注入

一个简单的 JavaBean 最明显的规则就是以一个私有属性对应 set()和 get()方法,来实现对属性的封装。既然 JavaBean 有 set()方法来设置 Bean 的属性,Spring 就会有相应的支持。除了为构造方法传递参数的<constructor-arg>标签之外,<property>标签可以为JavaBean 的 set()方法传递参数,即通过 set()方法为属性赋值。在上面的实例中再添加一个 Moniter 类。

设置 Moniter 类属性和 set()/get()方法。程序代码如下。

 

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. package com.linbingwen;  
  2.   
  3. public class Moniter implements Student {  
  4.     private String name;  
  5.     private String sex;  
  6.     private int age;  
  7.   
  8.     public void printInfo() {  
  9.         System.out.println("姓名:" + name);  
  10.         System.out.println("年龄:" + age);  
  11.         System.out.println("性别:" + sex);  
  12.     }  
  13.   
  14.     public int getAge() {  
  15.         return age;  
  16.     }  
  17.   
  18.     public void setAge(int age) {  
  19.         this.age = age;  
  20.     }  
  21.   
  22.     public String getName() {  
  23.         return name;  
  24.     }  
  25.   
  26.     public void setName(String name) {  
  27.         this.name = name;  
  28.     }  
  29.   
  30.     public String getSex() {  
  31.         return sex;  
  32.     }  
  33.   
  34.     public void setSex(String sex) {  
  35.         this.sex = sex;  
  36.     }  
  37. }  

修改 applicationContext.xml 配置文件。添加名称为 Moniter 的 Java Bean 的定义,用<property>标签的“name”属性指定要操作的 JavaBean 的属性,然后通过<property>的子标签<value>为属性赋值。修改后的代码如下。

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  4. xmlns:p="http://www.springframework.org/schema/p"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans 
  6. http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
  7.     <bean id="stu1" class="com.linbingwen.Stu1">  
  8.         <constructor-arg index="0">  
  9.             <value>飞龙</value>  
  10.         </constructor-arg>  
  11.         <constructor-arg index="1">  
  12.             <value></value>  
  13.         </constructor-arg>  
  14.         <constructor-arg type="int">  
  15.             <value>26</value>  
  16.         </constructor-arg>  
  17.     </bean>  
  18.   
  19.     <bean id="moniter" class="com.linbingwen.Moniter">  
  20.         <property name="age">  
  21.             <value>26</value>  
  22.         </property>  
  23.         <property name="name">  
  24.             <value>欣欣</value>  
  25.         </property>  
  26.         <property name="sex">  
  27.             <value></value>  
  28.         </property>  
  29.     </bean>  
  30. </beans>  

程序运行结果如图  所示

 

三、接口注入(interface injection)

接口注入指的就是在接口中定义要注入的信息,并通过接口完成注入。

具体步骤如下
①.编写一个接口IBuniness,各种数据库的注入将通过这个接口进行。代码如下

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. package ch3;  
  2.   
  3. public interface IBusiness {  
  4.   
  5.  public void createDI(DataBase db);  
  6. }  

②.任何想要使用数据库实例的类都必须实现这个接口,业务逻辑类Business实现这个接口IBusiness。代码如下

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. package ch3;  
  2.   
  3. public class Business implements IBusiness {  
  4.   
  5.  private DataBase db;  
  6.  @Override  
  7.  public void createDI(DataBase db) {//接口注入  
  8.   this.db = db;  
  9.  }  
  10. // 根据注入的数据库,从XXX数据库中取得数据。  
  11.  public void getData(){  
  12.   db.getData();  
  13.  }  
  14. }  

3.编写测试类TestBusiness。代码如下

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. package ch3;  
  2. public class TestBusiness {  
  3.  private Business business = new Business();  
  4. // 根据注入的数据库类,从oracle中取得数据库。  
  5.  public void getData() {  
  6.   business.createDI(new OracleDataBase()); 
  7. // 注入实际的数据库类型。如要变更式样,只需改变此处即可,达到重用目的。  
  8.   business.getData();  
  9.  }  
  10. }  


如果要完成依赖关系注入的对象,必须实现IBusiness接口。

 

四、JavaBean 的赋值标签

以上只介绍了如何用<value>标签赋值,那么复杂的属性如何赋值呢?例如 Null、对象引用、集合类等。接下来将要介绍对 JavaBean 的复杂属性赋值的标签,它们可以应用到
任何如<constructor-arg>和<property>可以给 JavaBean 的属性赋值的标签中。
1.<value>标签
这是一个普通的赋值标签,可直接在成对的<value>标签中放入数值或其他赋值标签,Spring 会把这个标签提供的属性值注入到指定的 JavaBean 中。语法格式如下。

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <value>arg</value>  

arg:传递给 JavaBean 的属性值。
2.<ref>标签
这个标签可以引用其他 JavaBean 的实例对象,当传递的参数是其他 JavaBean 的实例对象时使用此标签。语法格式如下。

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <ref bean="JavaBean"/>  

bean:指定引用的 JavaBean。
3.<null>标签
这是为 JavaBean 赋 Null 空值的标签。当 JavaBean 的某个属性暂不使用,要将其设置为 Null 值时使用此标签。语法格式如下。

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <null/>  

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <null></null>  

4.<list>标签
这是为 List 集合类或数组赋值的标签。当 JavaBean 的某个属性是 List 集合类型或数组时,需要使用此标签为 List 集合类型或数组的每一个元素赋值。语法格式如下。

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <list>  
  2.     <value>arg1</value>  
  3.     <value>arg2</value>  
  4. </list>  

<value>:赋值标签,为<list>标签指定的属性赋值。也可以使用其他赋值标签作为集合类赋值标签的子标签,例如<ref>或 3.2.7 节中介绍的使用<bean>标签定义匿名内部
JavaBean 的方法。此标签应用在<bean>标签中定义 JavaBean 的完整代码举例如下。

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <bean id="school" class="School">  
  2.     <property name="studentList">  
  3.       <list>  
  4.         <ref bean=" student1"/>  
  5.         <value>student2</value>  
  6.       </list>  
  7.      </property>  
  8. </bean>  

5.<set>标签
和<list>标签类似,<set>标签也是为集合对象赋值,不过赋值的对象是 Set 类型的属性。语法格式如下。

 

 

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <set>  
  2.     <ref bean="arg1"/>  
  3.     <value>arg2</value>  
  4. ……  
  5. </set>  

此标签应用在<bean>标签中定义 JavaBean 的完整代码举例如下

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <bean id="school" class="School">  
  2.     <property name="student">  
  3.       <set>  
  4.         <ref bean=" student1"/>  
  5.         <value>name</value>  
  6.       </set>  
  7.     </property>  
  8. <bean>  

6.<map>标签
此标签为 Map 集合赋值。因为 Map 以键值对(key/value)的方式存放数据,所以需要使用<entry>子标签装载 key 与 value 数据。Map 集合的 key 可以是任何类型的对象,而<entry>标签的属性 key 是以 String 类型表示的,所以限制了 Spring 中 Map 的 key 只能用 String 来表示。语法格式如下。

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <map>  
  2.     <entry key="key1">  
  3.     <ref bean="arg1" />  
  4.     </entry>  
  5. </map>  

<entry>:<map>标签的子标签,其“key”属性用于指定 Map 集合类的键值(key)。此标签应用在<bean>标签中定义 JavaBean 的完整代码举例如下。

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <bean id="school" class="School">  
  2.   <property name="student">  
  3.     <map>  
  4.       <entry key="key1">  
  5.       <ref bean=" student1" />  
  6.       </entry>  
  7.       <entry key="key2">  
  8.       <value> student2</value>  
  9.       </entry>  
  10.    </map>  
  11. </property>  
  12. </bean>  

7.<props>标签
这是为 java.util.Properties 类型属性赋值的标签,和<map>标签类似,但是它的(key/value)键值全都是 String 类型的,无法赋予 Object 对象类型。语法格式如下。

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <props>  
  2. <prop key="key1">value</prop>  
  3. </props>  

<prop>:<props>的子标签,其“key”属性用于指定 Properties 类的键值(key)。此标签应用在<bean>标签中定义 JavaBean 的完整代码举例如下。

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <bean id="school" class="School">  
  2.     <property name="student">  
  3.         <props>  
  4.           <prop key="key1">student1</prop>  
  5.           <prop key="key2">student2</prop>  
  6.          </props>  
  7.      </property>  
  8. </bean>  

8 匿名内部 JavaBean 的创建
通过前面的介绍,读者应该对如何使用 XML 装配 JavaBean 有了一定的了解。但是编程中经常遇到匿名的内部类,在 Spring 中该如何利用 XML 装配呢?其实非常简单,在需要匿名内部类的地方直接用<bean>标签定义一个内部类即可。如果要使这个内部类匿名,可以不指定<bean>标签的 id 或 name 属性。例如下面这段代码:

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <bean id="school" class="School">  
  2.  <property name="student">  
  3.     <bean class="Student"/> <!--定义学生匿名内部类-->  
  4.  </property>  
  5. </bean>  

代码中定义了匿名的 Student 类,将这个匿名内部类赋给了 school 类的实例对象。

五、 list、set、map注入使用范例

还是接上面的工程,新建一个School.java,代码如下:

 

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. package com.linbingwen;  
  2.   
  3. import java.util.Iterator;  
  4. import java.util.List;  
  5. import java.util.Map;  
  6. import java.util.Set;  
  7.   
  8. public class School {  
  9.     private List listStu;  
  10.     private Set setStu;  
  11.     private Map mapStu;  
  12.   
  13.     public List getListStu() {  
  14.         return listStu;  
  15.     }  
  16.     public void setListStu(List listStu) {  
  17.         this.listStu = listStu;  
  18.     }  
  19.     public Set getSetStu() {  
  20.         return setStu;  
  21.     }  
  22.     public void setSetStu(Set setStu) {  
  23.         this.setStu = setStu;  
  24.     }  
  25.   
  26.       
  27.     public Map getMapStu() {  
  28.         return mapStu;  
  29.     }  
  30.     public void setMapStu(Map mapStu) {  
  31.         this.mapStu = mapStu;  
  32.     }  
  33.       
  34.     public void printSchool(){  
  35.         System.out.println("--------list--------");    
  36.         for (int i = 0; i < listStu.size(); i++) {    
  37.             System.out.println(listStu.get(i));    
  38.         }      
  39.         System.out.println("--------set--------");    
  40.         for(Object s : setStu){    
  41.             System.out.println(s);    
  42.         }     
  43.         System.out.println("--------map--------");    
  44.         Iterator it=mapStu.entrySet().iterator();            
  45.         System.out.println(mapStu.entrySet().size());      
  46.         String key;            
  47.         String value;     
  48.         while(it.hasNext()){     
  49.                 Map.Entry entry = (Map.Entry)it.next();            
  50.                 key=entry.getKey().toString();            
  51.                 value=entry.getValue().toString();            
  52.                 System.out.println(key+"===="+value);                      
  53.         }     
  54.     }  
  55. }  

applicationContext.xml如下:

 

 

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  4. xmlns:p="http://www.springframework.org/schema/p"  
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.  http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
  7.   
  8.     <bean id="stu1" name="student1" class="com.linbingwen.Stu1">  
  9.         <constructor-arg index="0">  
  10.             <value>飞龙</value>  
  11.         </constructor-arg>  
  12.         <constructor-arg index="1">  
  13.             <value>男</value>  
  14.         </constructor-arg>  
  15.         <constructor-arg type="int">  
  16.             <value>26</value>  
  17.         </constructor-arg>  
  18.     </bean>  
  19.   
  20.     <bean id="moniter" name="student2" class="com.linbingwen.Moniter">  
  21.         <property name="age">  
  22.             <value>26</value>  
  23.         </property>  
  24.         <property name="name">  
  25.             <value>欣欣</value>  
  26.         </property>  
  27.         <property name="sex">  
  28.             <value>女</value>  
  29.         </property>  
  30.     </bean>  
  31.   
  32.   
  33.     <bean id="school" class="com.linbingwen.School">  
  34.         <!--List 注入例子 -->  
  35.         <property name="listStu">  
  36.             <list>  
  37.                 <ref bean="moniter" />  <!--使用上面已定义好的bean -->  
  38.                 <ref bean="moniter" />  <!--使用上面已定义好的bean -->  
  39.                 <ref bean="stu1" />     <!--使用上面已定义好的bean -->  
  40.                 <bean class="com.linbingwen.Moniter"> <!--定义学生匿名内部类,用setter方法注入 -->  
  41.                     <property name="age" value="20" />  
  42.                     <property name="name" value="阿屁" />  
  43.                     <property name="sex" value="男" />  
  44.                 </bean>  
  45.                 <value>1</value>  
  46.                 <value>hello</value>  
  47.             </list>  
  48.         </property>  
  49.   
  50.         <!--set 注入例子 -->  
  51.         <property name="setStu">  
  52.             <set>  
  53.                 <ref bean="moniter" />  <!--使用上面已定义好的bean -->  
  54.                 <ref bean="stu1" />     <!--使用上面已定义好的bean -->  
  55.                 <ref bean="stu1" />     <!--使用上面已定义好的bean -->  
  56.                 <bean class="com.linbingwen.Stu1"
  57.                     <!--定义学生匿名内部类,用constructor方法注入 -->  
  58.                     <constructor-arg value="大平" index="0"></constructor-arg>  
  59.                     <constructor-arg value="男" index="1"></constructor-arg>  
  60.                     <constructor-arg value="10" index="2"></constructor-arg>  
  61.                 </bean>  
  62.                 <value>333333</value>  
  63.                 <value>Evankaka</value>  
  64.             </set>  
  65.         </property>  
  66.   
  67.         <!--map 注入例子 -->  
  68.         <property name="mapStu">  
  69.             <map>  
  70.                 <entry key="key1">  
  71.                     <ref bean="moniter" />  <!--使用上面已定义好的bean -->  
  72.                 </entry>  
  73.                 <entry key="key2">  
  74.                    <bean class="com.linbingwen.Moniter"
  75.                     <!--定义学生匿名内部类,用setter方法注入 -->  
  76.                     <property name="age" value="80" />  
  77.                     <property name="name" value="小王" />  
  78.                     <property name="sex" value="男" />  
  79.                 </bean>  
  80.                 </entry>  
  81.                 <entry key="key3">  
  82.                     <value>student2</value>  
  83.                 </entry>  
  84.                 <entry key="key4">  
  85.                     <value>56</value>  
  86.                 </entry>  
  87.             </map>  
  88.         </property>  
  89.   
  90.     </bean>  
  91. </beans>  

如下:

 

 

[java] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. package com.linbingwen;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class Info {  
  7.   
  8.     public static void main(String[] args) {  
  9.         ApplicationContext applicationContext = new 
  10. ClassPathXmlApplicationContext("applicationContext.xml");  
  11.         Student student = (Student) applicationContext.getBean("stu1");  
  12.         student.printInfo();  
  13.         Student moniter = (Student) applicationContext.getBean("moniter");  
  14.         moniter.printInfo();  
  15.         School school=(School) applicationContext.getBean("school");  
  16.         school.printSchool();  
  17.     }  
  18.   
  19. }  

输出结果:

 

四月 02, 2015 5:36:38 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@addb54: startup date [Thu Apr 02 17:36:38 CST 2015]; root of context hierarchy
四月 02, 2015 5:36:38 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
四月 02, 2015 5:36:38 下午 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@ebcd03: defining beans [stu1,moniter,school]; root of factory hierarchy
姓名:飞龙
年龄:26
性别:男
姓名:欣欣
年龄:26
性别:女
--------list--------
姓名:欣欣;年龄:26;性别:女
姓名:欣欣;年龄:26;性别:女
姓名:飞龙;年龄:26;性别:男
姓名:阿屁;年龄:20;性别:男
1
hello
--------set--------
姓名:欣欣;年龄:26;性别:女
姓名:飞龙;年龄:26;性别:男
姓名:大平;年龄:10;性别:男
333333
Evankaka
--------map--------
4
key1====姓名:欣欣;年龄:26;性别:女
key2====姓名:小王;年龄:80;性别:男
key3====student2
key4====56

 

六、 总结

 

 设值注入和构造注入的比较

 1、设值注入的优点

(1)与传统的JavaBean的写法更相似,更容易让人理解,依赖关系显得更加直观、自然。

(2)对于复杂的依赖关系,如果采用构造注入会导致构造器过于臃肿,难以阅读。因为Spring在创建Bean实例时,需要同时实例化其依赖的全部实例,因而导致Struts+Spring+Hibernate整合开发性能下降。设值注入可以避免这些问题。

(3)在某些属性可选的情况下,多参数的构造器更加笨重。

 2、构造注入的优点

(1) 可以在构造器中决定依赖关系的注入顺序。例如,组件中其他依赖关系的注入,常常需要依赖于Datasource的注入。采用构造注入时,可以在代码中清晰地决定注入顺序,优先依赖先注入。

(2)对于依赖关系无须变化的bean,构造注入更有用处。因为没有setter,所有的关系都在构造器中设定,因此无需担心后续代码对依赖关系产生破坏。

 

(3) 依赖关系只能在构造器中设定,因为只有组件的创建者才能改变组件的依赖关系。对于组件的调用者而言,组件内部的依赖关系完全透明,更符合高内聚的原则。

建议采用设值注入为主,构造注入为辅的注入策略。

Spring Bean的其他说明

 

1、 Bean的标识(id,name,class)

id:bean的唯一标识。

2、name:bean的别名,可以有多个。

class:bean的具体实现类

3、 Bean的作用域

(1) singleton:单例,在IOC容器里只有一个实例

 

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <!-- 默认 -->  
  2. <beanidbeanid="loginAction"class="net.vzhang.spring3.action.LoginAction" scope="singleton"/>  

 

(2) prototype:

 

[html] view plaincopy在CODE上查看代码片派生到我的代码片
 
  1. <beanidbeanid="loginAction2"class="net.vzhang.spring3.action.LoginAction2" scope="prototype"/>  

request:针对Web应用的每次请求都生成一个新的实例

 

每次对bean请求时,都会创建一个新的实例。

对bean的请求:将其注入到另外一个bean中,或者调用BeanFactory的getBean方法。

 session:HttpSessio

分享到:
评论

相关推荐

    Spring IOC的注入方式总结

    在Spring中,IOC的主要实现方式有两种:依赖注入(Dependency Injection,简称DI)和基于接口的配置。下面将对这两种方式进行详细阐述。 一、依赖注入(Dependency Injection) 1. **构造器注入**:通过构造函数来...

    SPRING IOC注入方式过程解析

    SPRING IOC注入方式过程解析 SPRING IOC是一种轻量级的控制反转(Inversion of Control)容器框架,主要用于解耦合Java应用程序中的组件。其中,IOC(Inversion of Control)注入是SPRING IOC的核心机制之一。下面...

    Springioc注入Demo

    在Spring IOC中,主要的注入方式有以下几种: 1. **构造器注入**:通过构造函数传递依赖对象,Spring容器会根据构造函数的参数类型创建并注入相应的对象。这种方式确保对象在创建时就具备所有依赖,增强了对象的...

    Spring Ioc 注解 依赖注入

    其中,IoC和依赖注入(Dependency Injection, DI)是Spring框架最核心的部分之一。 #### 二、IoC容器概述 在传统的Java应用程序中,对象的创建和管理通常由程序员来完成。这种方式会导致代码之间存在高度耦合,难以...

    springIoc实现原理

    Spring Ioc(Inversion of Control,控制反转)是Spring框架的核心特性之一,它改变了传统应用程序中对象的创建和管理方式。在传统的软件设计中,对象的创建和依赖关系的维护通常由代码自身来完成,而在Spring Ioc中...

    Spring Ioc(依赖注入)入门例子--属性注入

    Spring的核心特性之一就是它的Inversion of Control(IoC,控制反转)容器,也被称为Dependency Injection(DI,依赖注入)。这个概念是Spring框架使应用程序组件之间解耦的关键。让我们深入探讨一下Spring的IoC和...

    Spring之IOC示例

    Spring实现IOC的方式主要有两种:依赖注入(Dependency Injection,简称DI)和基于接口的配置。依赖注入是指通过构造函数、设值方法或者属性来将依赖的对象传入,而不是由类自己去查找或创建。这种设计模式降低了类...

    SpringIoc注入

    在Spring中,IoC通过容器来管理对象及其依赖关系,而我们今天主要讨论的是Spring的IoC注入。 **一、什么是IoC注入** IoC,即控制反转,意味着应用程序不再负责创建和管理对象,而是将这个责任交给了一个外部容器...

    以注解方式模拟Spring IoC AOP

    依赖注入是Spring框架的核心特性之一,它通过反转对象创建和管理的控制权,使得应用程序组件之间的耦合度降低。在Spring中,通常通过以下三种注解实现IoC: - `@Autowired`:自动装配,Spring会根据类型或名称找到...

    Spring-ioc-jar

    Spring IOC,全称为Inversion of Control,中文常被称为“控制反转”,是Spring框架的核心特性之一。这个概念在软件设计中引入了一种新的依赖管理方式,它将对象的创建和管理权交给了容器,使得开发者可以更专注于...

    Spring的ioc小案例

    本案例主要探讨的是Spring框架的核心特性之一——依赖注入(Dependency Injection,简称DI),通常也被称为IOC(Inversion of Control,控制反转)。通过这个小案例,我们可以深入理解Spring如何实现IoC以及属性注入...

    Spring IOC之方法注入

    总结来说,Spring的IoC方法注入提供了一种灵活的方式来管理和初始化对象,通过`@PostConstruct`和`@PreDestroy`注解,或者实现`InitializingBean`和`DisposableBean`接口,我们可以在对象生命周期的关键点执行特定的...

    模拟Spring的IOC

    在Java世界中,Spring框架以其强大的依赖注入(Dependency Injection,简称DI)和控制反转(Inversion of Control,简称IOC)能力,成为企业级应用开发的首选框架之一。理解并模拟Spring的IOC机制对于深入学习Spring...

    spring 2.5 IOC 自动扫描,自动注入

    Spring支持多种注入方式,包括构造器注入、设值注入和接口注入。 在Spring 2.5中,可以通过注解来实现自动注入。比如,使用`@Autowired`注解来标记字段或者方法,Spring会自动寻找类型匹配的bean并注入。例如: ```...

    Spring_IOC-v(上)笔记

    IoC 技术是 Spring 框架的核心概念之一,它的主要思想是将对象的创建和管理交给容器来管理,而不是由对象自己来管理。这样可以降低对象之间的耦合度,提高系统的灵活性和可维护性。 在 Spring 中,IoC 通过依赖...

    Spring源码分析_Spring_IOC

    总结来说,Spring的IOC容器机制通过`BeanFactory`和`ApplicationContext`接口的实现,提供了强大且灵活的对象管理和依赖注入能力,极大地简化了Java应用的开发和维护过程。通过深入理解IOC容器的创建与初始化流程,...

    Spring的IoC实现案例

    总结来说,这个案例展示了Spring IoC如何帮助我们构建松散耦合的系统。通过IoC,我们可以轻松地更改`Priter`类使用的纸张类型,而无需修改`Priter`类本身的代码。这不仅提高了代码的可测试性,还增强了系统的可扩展...

    Spring IOC Annotation 注入 学习实例

    Annotation注入是Spring IOC的一种实现方式,它利用Java注解替代XML配置来管理Bean的依赖关系,使得代码更加简洁、可读性更强。 在Spring框架中,我们主要关注以下几个关键的注解: 1. `@Component`:这是一个基础...

Global site tag (gtag.js) - Google Analytics