Spring(四) Spring容器（2）

6.Spring容器中的Bean

6.1 Bean定义和Bean别名

对于开发者来说，开发者使用Spring做2件事：(1)开发Bean (2)配置Bean。

<beans.../>标签的属性：

default-lazy-init

default-merge

default-autowire

default-autowire-condidates

default-init-method

default-destroy-method

<beans.../>的定义对每一个bean都有效，<bean.../>对单个bean有效，如果这两者冲突，<bean.../>会覆盖<beans.../>的定义。<bean.../>也可以采用name属性，用于指定Bean的别名，通过访问Bean别名也可以访问Bean实例。

指定别名有2种方式：

(1)通过name属性指定：可以指定多个，使用逗号、冒号或者空格分隔多个别名；

(2)通过alias元素指定：一个元素是name，一个元素是alias。并且这个标签，不是在<bean.../>里，而是跟<bean.../>并列的。

新建一个测试类，AliasTest.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

package com.pmpa.ch03;   public class AliasTest {           private String name;     private int age;     public String getName() {         return name;     }     public void setName(String name) {         this.name = name;     }     public int getAge() {         return age;     }     public void setAge(int age) {         this.age = age;     }     @Override     public String toString() {         return "AliasTest [name=" + name + ", age=" + age + "]";     }               }

配置文件：

1 2 3 4 5

<bean id="aliastest" class="com.pmpa.ch03.AliasTest" name="#221,iuffs,googke">     <property name="name" value="honda" ></property>     <property name="age" value="13" ></property> </bean> <alias name="googke" alias="Sun"></alias>

测试类BeanTest.java

1 2	AliasTest at = ctx.getBean("Sun", AliasTest.class); System.out.println(at);

运行结果：

1	AliasTest [name=honda, age=13]

可以看到，通过别名“Sun”，Spring也找到了这个Bean,并正常输出。

6.2 容器中Bean的作用域

Bean包含5种作用域：

singleton：单例模式，在整个Spring IoC容器中，使用singleton定义的Bean将只有一个实例

prototype：原型模式，每次通过容器的getBean方法获取prototype定义的Bean时，都将产生一个新的Bean实例

request：对于每次HTTP请求，使用request定义的Bean都将产生一个新实例，即每次HTTP请求将会产生不同的Bean实例。只有在Web应用中使用Spring时，该作用域才有效

session：对于每次HTTP Session，使用session定义的Bean豆浆产生一个新实例。同样只有在Web应用中使用Spring时，该作用域才有效

globalsession：每个全局的HTTP Session，使用session定义的Bean都将产生一个新实例。典型情况下，仅在使用portlet context的时候有效。同样只有在Web应用中使用Spring时，该作用域才有效

6.2.1 singleton和prototype作用域测试实例：

如果不指定Bean的作用域，默认是singleton。prototype作用域的Bean的创建、销毁的系统代价比较大，应尽量避免使用。Spring配置文件的<bean.../>标签通过scope属性来配置bean的作用域。

ScopeTest.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

package com.pmpa.ch03;   public class ScopeTest {     private String idNo;       public String getIdNo() {         return idNo;     }       public void setIdNo(String idNo) {         this.idNo = idNo;     }       @Override     public String toString() {         return "ScopeTest [idNo=" + idNo + "]";     }       }

配置文件 beans03.xml

1 2 3 4 5 6

<bean id="scope1" class="com.pmpa.ch03.ScopeTest" scope="prototype">     <property name="idNo" value="152301ABC"></property> </bean> <bean id="scope2" class="com.pmpa.ch03.ScopeTest" scope="singleton">     <property name="idNo" value="110332CDE"></property> </bean>

测试类BeanTest.java：

1 2 3 4 5 6 7 8 9

//prototype作用域Bean的测试： ScopeTest st_prototype_1 = ctx.getBean("scope1", ScopeTest.class); ScopeTest st_prototype_2 = ctx.getBean("scope1", ScopeTest.class); System.out.println("prototype类型的对象1和2是否是同一对象：" + (st_prototype_1 == st_prototype_2));           //sigleton作用域Bean的测试： ScopeTest st_singleton_1 = ctx.getBean("scope2", ScopeTest.class); ScopeTest st_singleton_2 = ctx.getBean("scope2", ScopeTest.class); System.out.println("sigleton类型的对象1和2是否是同一对象：" + (st_singleton_1 == st_singleton_2));

运行结果：

1 2	prototype类型的对象1和2是否是同一对象：false sigleton类型的对象1和2是否是同一对象：true

对于singleton作用域的Bean，每次请求该id的bean，都将返回同一个共享实例。

6.2.2 request、session、globalsession作用域测试实例（待补充）：

6.3 配置依赖

BeanFactory和ApplicationContext实例化容器中Bean的时机不同：前者等到程序需要Bean实例时才创建；后者在容器创建ApplicationContext实例时，会初始化容器中的所有singleton Bean。

ApplicationContext可以在容器初始化阶段检验出配置错误。

Spring允许通过如下元素为setter方法、构造器参数指定参数值。

value

ref

bean

list、set、map、props

以上4种情况分别代表Bean类的4种类型的成员变量。

6.3.1 value：

value元素用于指定基本类型及其包装、字符串类型的参数。前边讲述的内容中，包含很多value赋值的情形，这里不再赘述。

6.3.2 ref：

如果需要为Bean设置的属性值是容器中的另一个Bean实例，则应该使用<ref.../>元素（其实，常用的是ref属性，前边事例都是这样。）这种术语也叫作“注入合作者Bean”。ref实例在前边例子中也很多，不再赘述。

自动装配注入合作者Bean：

Spring能自动装配Bean与Bean之间的依赖关系，即无需使用ref显示指定依赖Bean，而是由Spring容器检查XML配置文件内容，根据某种规则，为调用者Bean注入被依赖的Bean。

自动装配通过<beans.../>的default-autowrite属性指定，也可以通过<bean.../>元素的autowire属性指定。

自动装配可以减少配置文件的工作量，但是降低了依赖关系的透明性和清晰性。

auto-wire属性的可用值：

no：不使用自动装配，这是默认配置。

byName：根据setter方法名进行自动装配。

byType：根据setter方法的形参类型来自动装配。如果找到多个和形参类型匹配的Bean，则抛出异常。

constructor：与byType类似，区别是用于自动匹配构造器的参数。

autodetect：Spring容器根据Bean内部结构，自行决定使用constructor或byType策略。

AutoWireTest.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

package com.pmpa.ch03;   public class AutoWireTest {           private String uName;     private Car car;     private House house;     public String getuName() {         return uName;     }     public void setuName(String uName) {         this.uName = uName;     }     public Car getCar() {         return car;     }     public void setCar(Car car) {         this.car = car;     }     public House getHouse() {         return house;     }     public void setHouse(House house) {         this.house = house;     }           public void testAutoWire()     {         System.out.println("begin testing autowire " + uName);         car.carTest();         house.testHouse();     }       }

在外部，创建2个类，分别是Car和House，这2个类很简单。

配置文件beans03.xml

1 2 3 4 5 6 7 8 9 10 11 12 13

<bean id="benz" class="com.pmpa.ch03.Car">     <property name="brand" value="benz"></property>     <property name="speed" value="270"></property> </bean>   <bean id="biguiyuan" class="com.pmpa.ch03.House">     <property name="address" value="GuoMao"></property>     <property name="price" value="78900000"></property> </bean>   <bean id="autowiretest" class="com.pmpa.ch03.AutoWireTest" autowire="byType">     <property name="uName" value="自动装配测试1"></property> </bean>

这时候，创建的2个bean实例benz和biguiyuan的类型分别是Car和House，所以如果autowiretest实例的autowire属性设置为byType，则可以自动装配这2个属性。

测试类BeanTest.java

1 2	AutoWireTest awt = ctx.getBean("autowiretest", AutoWireTest.class); awt.testAutoWire();

运行结果：

1 2 3

begin testing autowire 自动装配测试1 The car benz can reach the speed of 270.0 The house GuoMao can reach the price of 7.89E7

通过byType自动装配成功。如果想通过byName完成自动装配，则需要修改配置文件，修改Car和House类型的2个bean实例的id（修改成什么Id，需要根据类AutoWireTest的2个setter方法来确定，应该是car和house），修改如下：

1 2 3 4 5 6 7 8 9 10 11 12 13

<bean id="car" class="com.pmpa.ch03.Car">     <property name="brand" value="benz"></property>     <property name="speed" value="270"></property> </bean>   <bean id="house" class="com.pmpa.ch03.House">     <property name="address" value="GuoMao"></property>     <property name="price" value="78900000"></property> </bean>   <bean id="autowiretest" class="com.pmpa.ch03.AutoWireTest" autowire="byName">     <property name="uName" value="自动装配测试1"></property> </bean>

当一个Bean既使用自动装配依赖，又使用ref显示指定依赖时，则显示指定的依赖会覆盖自动装配的依赖。

6.3.3 注入嵌套Bean：

如果某个Bean所依赖的Bean不想被Spring容器直接访问，可以使用嵌套Bean。

把<bean.../>配置成<property.../>或者<constructor-args.../>的子元素，那么该<bean.../>元素配置的Bean仅仅作为setter注入、构造注入的参数，这种Bean就是嵌套Bean。由于容器不能获取嵌套Bean，因此不需要为嵌套Bean指定id元素。

注意如下的配置文件：

1 2 3 4 5

<bean id="chinese02" class="com.pmpa.ch02.Chinese">     <property name = "axe" >         <bean class="com.pmpa.ch02.SteelAxe"></bean>     </property> </bean>

使用嵌套Bean与使用ref引用容器中另一个Bean在本质上是一样的。 之前的写法是<property name="..." ref="..."/>，现在改成<property name="..."><bean class="..."/></property>。注意这种写法中，不能指定bean id属性。

6.3.4 注入集合值：

如果需要调用形参类型为集合的setter方法，或者调用形参类型为集合的构造器，则可使用集合元素<list.../>、<set.../>、<map.../>、<props.../>分别来设置类型为List、Set、Map和Properties的集合参数值。

下面定义一个包含集合属性的java类，Student.java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

package com.pmpa.ch03;   import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.Set;   public class Student {           private String name;     private List<String> schools;     private Map scores;     private Map<String,Car> carPhases;     private Properties examinations;     private Set infos;     private String[] careers;     public String getName() {         return name;     }     public void setName(String name) {         this.name = name;     }     public List<String> getSchools() {         return schools;     }     public void setSchools(List<String> schools) {         this.schools = schools;     }     public Map getScores() {         return scores;     }     public void setScores(Map scores) {         this.scores = scores;     }     public Map<String, Car> getCarPhases() {         return carPhases;     }     public void setCarPhases(Map<String, Car> carPhases) {         this.carPhases = carPhases;     }     public Properties getExaminations() {         return examinations;     }     public void setExaminations(Properties examinations) {         this.examinations = examinations;     }     public Set getInfos() {         return infos;     }     public void setInfos(Set infos) {         this.infos = infos;     }     public String[] getCareers() {         return careers;     }     public void setCareers(String[] careers) {         this.careers = careers;     }     @Override     public String toString() {         return "Student [name=" + name + ", schools=" + schools + ", scores=" + scores + ", carPhases=" + carPhases                 + ", examinations=" + examinations + ", infos=" + infos + ", careers=" + Arrays.toString(careers) + "]";     }       }

分别为<property.../>元素增加<list.../>、<set.../>、<map.../>、<props.../>子元素来配置这些集合类型的参数值。

配置文件定义bean03.xml：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

<bean id="toyota" class="com.pmpa.ch03.Car">     <property name="brand" value="toyota"></property>     <property name="speed" value="180"></property> </bean> <bean id="bmw" class="com.pmpa.ch03.Car">     <property name="brand" value="bmw"></property>     <property name="speed" value="270"></property> </bean> <bean id="bently" class="com.pmpa.ch03.Car">     <property name="brand" value="bently"></property>     <property name="speed" value="460"></property> </bean>   <bean id="student" class="com.pmpa.ch03.Student">     <property name="name" value="Tom White"></property>     <!-- 配置List集合类型 -->     <property name="schools">         <list>             <!-- 下面每个value标签，定义一个list的元素，根据list泛型的类型，也可以使用ref、bean等等标签 -->             <value>衡水一中</value>             <value>北京工业大学</value>             <value>斯坦福大学</value>         </list>     </property>     <!-- 配置Map集合类型 -->     <property name="scores">         <map>             <!-- 下面每个entry标签，定义一个map的元素,也就是key-value对 -->             <entry key="数学" value="78"></entry>             <entry key="语文" value="132"></entry>             <entry key="英语" value="104"></entry>         </map>     </property>       <!-- 配置Map集合类型，Map<String,Car> -->     <property name="carPhases">         <map>             <!-- 下面每个entry标签，定义一个map的元素,也就是key-value对 -->             <entry key="打工阶段" value-ref="toyota"></entry>             <entry key="创业阶段" value-ref="bmw"></entry>             <entry key="成功阶段" value-ref="bently"></entry>         </map>     </property>       <!-- 配置Properties集合属性 -->     <property name="examinations">         <props>             <!-- 每个prop元素都配置一个属性项，其中key指定属性名 -->             <prop key="血常规">正常</prop>             <prop key="尿常规">脂肪肝</prop>         </props>     </property>       <!-- 配置Set集合属性 -->     <property name="infos">         <set>             <!-- 每个value、ref、bean都配置一个Set元素 -->             <value>简单的字符串赋值</value>             <bean class="com.pmpa.ch03.House"></bean>             <ref bean="car"></ref>             <!-- Set里可以继续配置一个List -->             <list>                 <value>Set中的List</value>                 <set><value type="java.lang.String">List中的Set</value></set>             </list>         </set>     </property>     <!-- 配置数组集合类型 -->     <property name="careers">         <list>             <!-- 每个value标签是一个数组元素 -->             <value>IBM</value>             <value>Google</value>             <value>Oracle</value>         </list>     </property> </bean>

测试类BeanTest.java

1 2 3

System.out.println("-----------------------测试集合注入------------------------"); Student student = ctx.getBean("student", Student.class); System.out.println(student);

运行结果：

1 2

-----------------------测试集合注入------------------------ Student [name=Tom White, schools=[衡水一中, 北京工业大学, 斯坦福大学], scores={数学=78, 语文=132, 英语=104}, carPhases={打工阶段=Car [brand=toyota, speed=180.0], 创业阶段=Car [brand=bmw, speed=270.0], 成功阶段=Car [brand=bently, speed=460.0]}, examinations={血常规=正常, 尿常规=脂肪肝}, infos=[简单的字符串赋值, com.pmpa.ch03.House@6d7b4f4c, Car [brand=benz, speed=270.0], [Set中的List, [List中的Set]]], careers=[IBM, Google, Oracle]]

说明：

1. Spring对List元素和数组的处理是一致的，都使用<list.../>元素配置。

2. <list.../>、<set.../>、<map.../>、<props.../>又可以接受value；ref；bean；list、set、map、props元素。

3. Properties类型，其key和value只能是字符串。

4. <entry.../>元素支持4个属性：key、key-ref(key为容器中的其他bean实例)、value、value-ref(value为容器中的其他bean实例，上边例子中有说明)。

5. Spring容器支持集合的合并，子Bean中的结合属性值可以从其父Bean的集合属性继承和覆盖而来。

6.3.4  组合属性：

使用car.brand 等类似格式为对象成员变量的属性赋值。为Bean的组合属性设置参数时，除最后一个属性外，其他属性值都不允许为null。

CombinationTest.java：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

package com.pmpa.ch03; public class CombinationTest {  private String name;  private Car car = new Car();  private House house = new House();  public String getName() {   return name;  }  public void setName(String name) {   this.name = name;  }  public Car getCar() {   return car;  }  public void setCar(Car car) {   this.car = car;  }  public House getHouse() {   return house;  }  public void setHouse(House house) {   this.house = house;  }  @Override  public String toString() {   return "CombinationTest [name=" + name + ", car=" + car + ", house=" + house + "]";  } }

配置文件：

1 2 3 4 5 6

<bean id="combinationtest" class="com.pmpa.ch03.CombinationTest">  <property name="name" value="combination"/>  <property name="car.brand" value="honda"></property>  <property name="car.speed" value="193" ></property>  <property name="house.address" value="XiDan" ></property> </bean>

运行结果：

1 2	-----------------------测试组合属性------------------------ CombinationTest [name=combination, car=Car [brand=honda, speed=193.0], house=House [address=XiDan, price=0.0]]

使用组合属性指定参数值时，除了最后一个属性外，其他属性都不能为Null,否则将引发NullPointerException异常，如果感觉自学困难的话，可以去参加java培训来提高。例如，上面配置文件为car.brand指定参数值，则CombinationTest的car就一定不能为null，所以该类在设置private属性时，要直接new一个对象。是这样：private Car car = new Car();而不能是这样：private Car car;
这种赋值方法，底层spring执行时，需要先调用getter方法，再调用setter方法，

1	combinationtest.getCar().setBrand("honda");

也就是说组合属性只有最后一个属性才调用setter方法，其余都调用getter方法——这也是为什么前面属性都不能为null的缘由。