zoukankan      html  css  js  c++  java

  • Spring学习总结（5）——IOC注入方式总结

    一、构造注入

    在类被实例化的时候，它的构造方法被调用并且只能调用一次。所以它被用于类的初始化操作。<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 http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
    6.     <bean id="stu1" class="com.linbingwen.Stu1">  
    7.         <constructor-arg>  
    8.             <value>飞龙</value>  
    9.         </constructor-arg>  
    10.         <constructor-arg>  
    11.             <value>男</value>  
    12.         </constructor-arg>  
    13.         <constructor-arg>  
    14.             <value>26</value>  
    15.         </constructor-arg>  
    16.     </bean>  
    17. </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" xmlns:p="http://www.springframework.org/schema/p"  
    4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
    5.     <bean id="stu1" class="com.linbingwen.Stu1">  
    6.         <constructor-arg>  
    7.             <value>飞龙</value>  
    8.         </constructor-arg>  
    9.         <constructor-arg>  
    10.             <value>男</value>  
    11.         </constructor-arg>  
    12.         <constructor-arg type="int">  
    13.             <value>26</value>  
    14.         </constructor-arg>  
    15.     </bean>  
    16. </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" xmlns:p="http://www.springframework.org/schema/p"  
    4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
    5.     <bean id="stu1" class="com.linbingwen.Stu1">  
    6.         <constructor-arg index="0">  
    7.             <value>飞龙</value>  
    8.         </constructor-arg>  
    9.         <constructor-arg index="1">  
    10.             <value>男</value>  
    11.         </constructor-arg>  
    12.         <constructor-arg type="int">  
    13.             <value>26</value>  
    14.         </constructor-arg>  
    15.     </bean>  
    16. </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" xmlns:p="http://www.springframework.org/schema/p"  
    4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
    5.     <bean id="stu1" class="com.linbingwen.Stu1">  
    6.         <constructor-arg index="0">  
    7.             <value>飞龙</value>  
    8.         </constructor-arg>  
    9.         <constructor-arg index="1">  
    10.             <value>男</value>  
    11.         </constructor-arg>  
    12.         <constructor-arg type="int">  
    13.             <value>26</value>  
    14.         </constructor-arg>  
    15.     </bean>  
    16.   
    17.     <bean id="moniter" class="com.linbingwen.Moniter">  
    18.         <property name="age">  
    19.             <value>26</value>  
    20.         </property>  
    21.         <property name="name">  
    22.             <value>欣欣</value>  
    23.         </property>  
    24.         <property name="sex">  
    25.             <value>女</value>  
    26.         </property>  
    27.     </bean>  
    28. </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.   business.getData();  
    8.  }  
    9. }  

    如果要完成依赖关系注入的对象，必须实现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" xmlns:p="http://www.springframework.org/schema/p"  
    4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
    5.   
    6.     <bean id="stu1" name="student1" class="com.linbingwen.Stu1">  
    7.         <constructor-arg index="0">  
    8.             <value>飞龙</value>  
    9.         </constructor-arg>  
    10.         <constructor-arg index="1">  
    11.             <value>男</value>  
    12.         </constructor-arg>  
    13.         <constructor-arg type="int">  
    14.             <value>26</value>  
    15.         </constructor-arg>  
    16.     </bean>  
    17.   
    18.     <bean id="moniter" name="student2" class="com.linbingwen.Moniter">  
    19.         <property name="age">  
    20.             <value>26</value>  
    21.         </property>  
    22.         <property name="name">  
    23.             <value>欣欣</value>  
    24.         </property>  
    25.         <property name="sex">  
    26.             <value>女</value>  
    27.         </property>  
    28.     </bean>  
    29.   
    30.   
    31.     <bean id="school" class="com.linbingwen.School">  
    32.         <!--List 注入例子 -->  
    33.         <property name="listStu">  
    34.             <list>  
    35.                 <ref bean="moniter" />  <!--使用上面已定义好的bean -->  
    36.                 <ref bean="moniter" />  <!--使用上面已定义好的bean -->  
    37.                 <ref bean="stu1" />     <!--使用上面已定义好的bean -->  
    38.                 <bean class="com.linbingwen.Moniter"> <!--定义学生匿名内部类，用setter方法注入 -->  
    39.                     <property name="age" value="20" />  
    40.                     <property name="name" value="阿屁" />  
    41.                     <property name="sex" value="男" />  
    42.                 </bean>  
    43.                 <value>1</value>  
    44.                 <value>hello</value>  
    45.             </list>  
    46.         </property>  
    47.   
    48.         <!--set 注入例子 -->  
    49.         <property name="setStu">  
    50.             <set>  
    51.                 <ref bean="moniter" />  <!--使用上面已定义好的bean -->  
    52.                 <ref bean="stu1" />     <!--使用上面已定义好的bean -->  
    53.                 <ref bean="stu1" />     <!--使用上面已定义好的bean -->  
    54.                 <bean class="com.linbingwen.Stu1"> <!--定义学生匿名内部类，用constructor方法注入 -->  
    55.                     <constructor-arg value="大平" index="0"></constructor-arg>  
    56.                     <constructor-arg value="男" index="1"></constructor-arg>  
    57.                     <constructor-arg value="10" index="2"></constructor-arg>  
    58.                 </bean>  
    59.                 <value>333333</value>  
    60.                 <value>Evankaka</value>  
    61.             </set>  
    62.         </property>  
    63.   
    64.         <!--map 注入例子 -->  
    65.         <property name="mapStu">  
    66.             <map>  
    67.                 <entry key="key1">  
    68.                     <ref bean="moniter" />  <!--使用上面已定义好的bean -->  
    69.                 </entry>  
    70.                 <entry key="key2">  
    71.                    <bean class="com.linbingwen.Moniter"> <!--定义学生匿名内部类，用setter方法注入 -->  
    72.                     <property name="age" value="80" />  
    73.                     <property name="name" value="小王" />  
    74.                     <property name="sex" value="男" />  
    75.                 </bean>  
    76.                 </entry>  
    77.                 <entry key="key3">  
    78.                     <value>student2</value>  
    79.                 </entry>  
    80.                 <entry key="key4">  
    81.                     <value>56</value>  
    82.                 </entry>  
    83.             </map>  
    84.         </property>  
    85.   
    86.     </bean>  
    87. </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 ClassPathXmlApplicationContext("applicationContext.xml");  
    10.         Student student = (Student) applicationContext.getBean("stu1");  
    11.         student.printInfo();  
    12.         Student moniter = (Student) applicationContext.getBean("moniter");  
    13.         moniter.printInfo();  
    14.         School school=(School) applicationContext.getBean("school");  
    15.         school.printSchool();  
    16.     }  
    17.   
    18. }  
    输出结果：

    四月 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
  • 相关阅读:
    函数参数
    文件操作
    is,数据类型补充,set,深浅拷贝
    is,==区别,编码转换
    列表,元祖,range
    字典,解构
    编码,基础数据类型 int str bool,for循环
    while循环,格式化输出,运算符
    java7中使用透明时与输入法冲突
    TC SRM 597 DEV2
  • 原文地址：https://www.cnblogs.com/zhanghaiyang/p/7213293.html
Copyright © 2011-2022 走看看