深入了解Spring中的容器

1.创建Bean的3种方式

1.1使用构造器创建bean实例

这是最常见的方式，如果不采用构造注入，bean类需要有默认构造函数。如果采用构造注入，则需要配置xml文件的<constructor-arg>

1.2使用静态工厂方法创建bean

最典型的工厂方法如

 package spi;

 public class PersonFactory {
     public static Person getPerson(String arg) {
         if (arg.equalsIgnoreCase("Chinese")) {
             return new Chinese();
         } else {
             return new American();
         }
     }
 }

如果在Spring容器中配置一个bean，bean的实例希望由上的静态工厂方法反回，则可以在bean中使用 factory-method来指定工厂方法，并用<constructor-arg>指定参数。

 <bean id="chinese" class="spi.PersonFactory" factory-method="getPerson">
 　　<constructor-arg value="chinese" />
 </bean>

1.3实例化工厂方法创建bean

这与上面的使用静态工厂方法创建bean高度相似，区别是这里是需要先创建工厂的实例。工厂方法如下

 package spi;

 public class PersonFactory {
     public Person getPerson(String arg) {
         if (arg.equalsIgnoreCase("Chinese")) {
             return new Chinese();
         } else {
             return new American();
         }
     }
 }

在xml配置中，除了使用factory-method来指定bean的实例化工厂方法外，还需要使用factory-bean指定工厂实例的bean

 <bean id="chinese" class="spi.PersonFactory" factory-method="getPerson" factory-bean="personFactory">
 　　<constructor-arg value="chinese" />
 </bean>
 <bean id="personFactory" class="spi.PersonFactory" />

2.bean的继承

可以在Spring中使用abstract属性将一个bean定义一个模板配置，这叫做一个抽象bean。抽象bean不能被实例化，只是为了降低配置文件的冗余而存在的，只能由子bean继承，子类则使用parent属性指定父类bean。下面是一个例子，

     <bean id="personTemplate" abstract="true">
         <property name="name" value="zhangsan" />
         <property name="axe" value="stoneAxe" />
     </bean>

     <bean id="chinesePerson" parent="personTemplate">
         <property name="axe" value="steelAxe" />
     </bean>

这个例子中，子类bean chinesePerson将会从父类继承name属性，但是会覆盖父类的axe属性。

注意的是并非父类所有属性子类都能继承，depends-on, autowire, singleton, scope, lazy-ini 这些属性只能从子类本身获取或采用默认值。

并且Spring容器bean的继承可以在不同类型的bean之间存在。

3.工厂bean： FactoryBean接口

Spring容器会检查所有bean，如果发现某个bean实现了FactoryBean接口，就会调用接口的getObject()，其返回值才会作为真正的bean。

开发人员可以重写getObject()方法供Spring调用，例如下面，

 package spi;

 import java.lang.reflect.Field;

 import org.springframework.beans.factory.FactoryBean;

 public class GetField implements FactoryBean<Object>{
     private String targetClass;
     private String targetField;

     public String getTargetClass() {
         return targetClass;
     }

     public void setTargetClass(String targetClass) {
         this.targetClass = targetClass;
     }

     public String getTargetField() {
         return targetField;
     }

     public void setTargetField(String targetField) {
         this.targetField = targetField;
     }

     @Override
     public Object getObject() throws Exception {
         // TODO Auto-generated method stub
         Class<?> clazz = Class.forName(targetClass);
         Field field = clazz.getField(targetField);
         return field.get(null);
     }

     @Override
     public Class<?> getObjectType() {
         // TODO Auto-generated method stub
         return Object.class;
     }

     @Override
     public boolean isSingleton() {
         // TODO Auto-generated method stub
         return false;
     }

 }

这个类实现了FactoryBean接口，可以返回任何我们需要的对象，功能非常强大，在Spring中可以做如下配置，

     <bean id="getField" class="spi.GetField">
         <property name="targetClass" value="spi.Chinese" />
         <property name="targetField" value="axe" />
     </bean>

测试代码如下，

     public static void test6() {
         ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
         System.out.println(ctx.getBean("getField"));
     }

程序输出：North

Spring提供的工厂Bean，大多以FactoryBean结尾，用于生产指定类型的bean，工厂bean是Spring的重要工具之一。

4.获取Bean本身id

就像Bean希望获取所在的ApplicationContext实例一样，有时候Bean还希望获取XML中配置的id名称，这种情况需要bean实现BeanNameAware接口，过程与实现ApplicationContextAware类似。并且实现BeanNameAware接口的setBeanName()方法供Spring调用，例如下面，

 public class Chinese implements Person, BeanNameAware {
     private String beanName;
     @Override
     public void setBeanName(String arg0) {
         this.beanName = beanName;

     }
 ...

这样容器创建bean时候就会调用这个setBeanName()方法，bean就能获取自己的id名称了。例如还可以在Chinese类中添加下面的方法，

     public void info(){
         System.out.println("我在XML中的id名称为："+beanName);
     }

5.强制初始化bean

某些情况下，容器中的依赖并不是非常直接，初始化bean时候，如果依赖的bean尚未初始化，有可能会出错，这种情况下我们希望先初始化依赖的bean。

我们可以使用depebds-on属性来强制容器先初始化依赖额bean，例如

 <bean id="chinese" class="spi.Chinese" depends-on="steelAxe" />
 <bean id="steelAxe" class="spi.SteelAxe" />

6.容器中Bean的生命周期

对于singleton的bean，Spring可以精确控制生命周期，因此可以在bean的各个阶段指定各种行为。

例如在bean依赖注入之后，或者销毁之前，可以插入指定动作。

6.1依赖关系注入之后的行为

有两种方式可以在Bean属性设置成功之后执行特定行为。

• 一是使用init-method属性

这种方式要求在bean中定义一个回调方法供Spring调用，并在XML中配置init-method属性，例如

 <bean id="chinese" class="spi.Chinese" init-method="init">

只要在bean中实现init()方法，就能在bean被设置完属性之后调用，执行特定方法。

• 二是让bean实现InitialializingBean接口，并实现接口的 afterPropertiesSet()方法

这种方式不要求使用init-method属性，但是这对bean类具有侵入性，不推荐。

6.2Bean销毁之前的行为

要让Bean被销毁之前执行特定行为，也可以类似上面那样用两种方式实现，

一是使用destroy-method属性

二是实现DisposableBean接口，并实现destroy()方法

另外，对于非web应用，如果希望在关闭应用前先关闭容器实例（即ApplicationContext实例），则可以先在JVM中注册一个钩子，程序退出时就会执行回调函数，优雅地关闭容器实例，例如，

     public static void test5() {
         AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
         Person p = ctx.getBean("chinese", Person.class);
         p.useAxe();
         ctx.registerShutdownHook();
     }

6.3协调作用域不同步的Bean

如果在一个singleton类型的bean中注入一个prototype类型的bean时候，会发现有个问题，在整个应用程序生命周期，singleton bean只会被初始化一次，然而prototype bean每次都会重新创建并初始化，那么意味着singleton中的依赖注入并不是最新的。

要解决这个问题，Spring使用“方法注入”，具体方式为：

将调用bean（通常是singleton)定义为抽象类，定义一个抽象方法，用来返回一个对象，这个对象将用来对前面的bean注入值

在调用bean中使用 <lookup-method>子元素替代<property>元素，可以使得每次调用bean时候，都会进行一次注入。

bean定义如下

 class abstract class Chinese implements Person {
     private Dog dog;
     public abstract Dog getDog{}
     ...
 }

XML配置

 <bean id="chinese" class="spi.Chinese">
     <lookup-method name="getDog" bean="gunDog" />
 </bean>
 <bean id="gunDog" class="spi.GunDog" scope="prototype" />

对于上面的配置，Spring会做负责生成Chinese抽象类的子类，并重写getDog()方法，通常会这样写，

 public Dog getDog(){
     //获取ctx
     ...
     return ctx.getBean("gunDog");
 }

这样就强行要求singleton类型的bean，每次获取Dog属性时候，都进行一次依赖注入。

7.获取其他bean的属性值

获取bean属性值，即调用getter方法。Spring提供一个工厂Bean ： PropertyPathFactoryBean专门用来调用getter方法获取属性值。

Spring的工厂Bean很强大，大多以*FactoryBean名称结尾，每一种工厂Bean可以生产特定产品，PropertyPathFactoryBean则是专门用来获取属性值的。

要使用PropertyPathFactoryBean，直接将它配置成一个XML中的bean即可，同时需要配置bean的targetBeanName和propertyPath属性，下面是一个例子，

     <bean id="chinese" class="spi.Chinese" destroy-method="close">
         <property name="age" value="30" />
         <property name="son">
             <bean class="spi.Son">
                 <property name="age" value="11" />
             </bean>
         </property>
     </bean>
     <!-- 将指定Bean实例的getter方法返回值定义成son1 bean -->
     <bean id="son1" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
         <!-- 指定son1 bean来自哪个目标bean的getter方法 -->
         <property name="targetBeanName" value="chinese" />
         <!-- 指定目标bean的哪个getter方法, axe代表getSon() -->
         <property name="propertyPath" value="son" />
     </bean>

targetBeanName属性用来指定将要获取哪个bean的属性，propertyPath用来指定要执行目标bean的哪个getter方法。

上面涉及一个Son类代码如下，

 package spi;

 public class Son {
     private int age;

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }
     public String toString(){
         return "Son[age="+this.age+"]";
     }
 }

测试代码如下，

 System.out.println("系统获取son1: "+ctx.getBean("son1"));

将会得到如下结果，

系统获取son1: Son[age=11]

获取到的bean属性值还可以用来注入另一个bean，下面是一个例子，

     <bean id="son2" class="spi.Son">
         <property name="age">
         <!-- 使用嵌套bean为setAge()方法指定参数 -->
         <!-- 以下是访问指定bean的getter方法的简单方式，
         chinese.son.age代表获取chinese.getSon().getAge(), 也就是前面的son1-->
             <bean id="chinese.son.age" class="org.springframework.beans.factory.config.PropertyPathFactoryBean" />
         </property>
     </bean>

测试代码，

 System.out.println("系统获取son2: "+ctx.getBean("son2"));

执行结果，

 系统获取son2: Son[age=11]

另外，propertyPath所指定的getter方法，也可以是一个复合方法（即属性的属性），像下面这样，

     <bean id="theAge" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
         <property name="targetBeanName" value="chinese" />
         <!-- 这里的son.age是一个复合属性，表示chinese.getSon().getAge() -->
         <property name="propertyPath" value="son.age" />
     </bean>

测试代码，

 System.out.println("系统获取theAge: "+ctx.getBean("theAge"));

执行结果，

系统获取theAge: 11

同时，目标bean也可以是嵌入的一个bean，不过这时候不是使用targetBeanName属性来指定，而是targetObject，例如这样，

     <bean id="theAge2" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
         <property name="targetObject">
             <bean class="spi.American">
                 <property name="age" value="30" />
             </bean>
         </property>
         <property name="propertyPath" value="age" />
     </bean>

测试代码，

 System.out.println("系统获取theAge2: "+ctx.getBean("theAge2"));

执行结果，

 系统获取theAge2: 30

另外，对于获取其他bean属性的工厂Bean配置，还有一种简化配置如下，

 <util:property-path id="son1" path="person.son" />

不过这种配置需要导入util:命名空间。

8.获取Field值

获取Field分为两种情况，第一种是静态Field，第二种是对象实例的Field值。

Spring定义了专门的工厂Bean：FieldRetrievingFactoryBean来获取Field值。在XML中配置一个FieldRetrievingFactoryBean类型的bean即可。

对于静态Field情形，需要在XML中设置FieldRetrievingFactoryBean bean的 targetClass(即目标类）和targetFiled(即目标字段）。

对于实例对象的Field，需要指定targetObject(目标对象）和targetField(目标字段）。

对于第二种情况，其实编程中意义不大，因为通常定义在类中的对象实例都是private的，FieldRetrievingFactoryBean无法直接获取，我们使用PropertyPathFactoryBean调用public的getter方法即可。

对于第一种情况，典型用法如下，

     <bean id="theAge3" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">
         <property name="targetClass" value="java.sql.Connection" />
         <property name="targetField" value="TRANSACTION_SERIALIZABLE" />
     </bean>

FieldRetrievingFactoryBean有个setStaticField()方法用来指定目标类和目标Field，因此上面的配置又可以简写为，

     <bean id="theAge4" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">
         <property name="staticField" value="java.sql.Connection.TRANSACTION_SERIALIZABLE" />
     </bean>

FieldRetrievingFactoryBean返回的bean也可以用来注入其他bean，

     <bean id="son3" class="spi.Son">
         <property name="age">
             <bean id="java.sql.Connection.TRANSACTION_SERIALIZABLE"  class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean" />
         </property>
     </bean>

上面三段配置的测试代码如下，

         System.out.println("系统获取theAge3: "+ctx.getBean("theAge3"));
         System.out.println("系统获取theAge4: "+ctx.getBean("theAge4"));
         System.out.println("系统获取son3: "+ctx.getBean("son3"));

测试结果，

 系统获取theAge3: 8
 系统获取theAge4: 8
 系统获取son3: Son[age=8]

FieldRetrievingFactoryBean也支持命名空间的简写，即

<util:constrant static-field="java.sql.Connection.TRANSACTION_SERIALIZABLE" />

9.获取方法返回值

Spring使用工厂Bean：MethodInvokingFactoryBean来执行bean中的普通方法，如果有返回值，将被赋值给xml中定义的bean

执行普通方法也分两种情况，一种是静态类的普通方法，一种是普通对象的方法，

对于两种情况，都将MethodInvokingFactoryBean定义为XML中一个普通bean，且设置相似的参数。

targetClass/targetObject 用来设置目标类或者目标对象

targetMethod用来设置目标方法

arguments用来设置执行普通方法所需要的参数

一个典型的用法如下，

     <!-- 配置
     JFrame win = new JFrame("我的窗口");
     win.setVisible(true);
      -->
      <bean id="win" class="javax.swing.JFrame">
          <constructor-arg value="我的窗口" type="java.lang.String" />
          <property name="visible" value="true" />
      </bean>
     <!-- 配置
     JTextArea jta = JTextArea(7,40);
      -->
      <bean id="jta" class="javax.swing.JTextArea">
          <constructor-arg value="7" type="int" />
          <constructor-arg value="40" type="int" />
      </bean>

      <!-- 配置
      win.add(new JScrollPane(jta));
      使用MethodInvokingFactoryBean驱动Spring调用普通方法
       -->
       <bean class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
           <property name="targetObject" ref="win" />
           <property name="targetMethod" value="add" />
           <property name="arguments">
               <list>
                   <bean class="javax.swing.JScrollPane">
                       <constructor-arg ref="jta" />
                   </bean>
               </list>
           </property>
       </bean>

上面使用纯XML配置的方法，相当于执行了下面的java代码，

 JFrame win = new JFrame("我的窗口");
 win.setVisible(true);
 JTextArea jta = JTextArea(7,40);
 win.add(new JScrollPane(jta));

通过上面的几点发现，Spring框架就是通过XML配置来执行java代码，因此几乎可以把所有java代码都放在Spring配置中管理，归纳一下：

• 调用构造器创建对象，用<bean ..>元素
• 调用setter方法，用<property..>元素
• 调用getter方法，用工厂Bean  PropertyPathFactoryBean
• 调用普通方法，用工厂Bean  MethodInvokingFactoryBean
• 获取Field的值，用工厂Bean FieldRetrievingFactoryBean