2011级-csdn-java-张侃—Spring(2)

二、装配Bean

2.1容纳你的bean
bean工厂:最简单的容器，提供了基础的依赖
              注入支持。创建各种类型的Bean.
应用上下文:建立在bean工厂基础之上，提供系
                统架构服务。

2.1.1 bean工厂介绍
工厂设计模式，创建分发各种bean。配置好它们之
间的写作关系，参与bean的生命周期。

BeanFactory factory = new XmlBeanFactory(
new FileInputStream("beans.xml"));
bean工厂只把bean的定义信息载进来，用到的时候
才实例化。
factory.getBean("mybean");就可得到一个
bean。

2.1.2 使用应用上下文
ApplicationCotext,spring更加高级的容器。功能
强大：
1.提供文本信息解析工具，包括对国际化支持。
2.提供载入文件资源的通用方法，如图片。
3.可以向注册为监听器的bean发送事件。
在很少的情况下，使用BeanFactory，如在移动设
备。

2.1.2 使用应用上下文(续)
三种经常用到的实现：
1.ClassPathXmlApplicationContext:从类路径中加载。
2.FileSystemXmlApplicationContext:从文件系统加载。
3.XmlWebApplicationContext:从web系统中加载。

2.1.2 使用应用上下文(续)

ApplicationContext context = 
  new FileSystemXmlApplicationContext("
  c:\foo.xml");
ApplicationContext context = 
  new ClassPathXmlApplicationContext("
  foo.xml");

2.1.2 使用应用上下文(续)
除了应用上下文提供的附加功能外，应用上下文
与bean工厂的另一个重要区别是关于单例bean
如何被加载。
bean工厂延迟加载所有bean，直到getBean()
方法被调用。
应用上下文会在启动后预载入所有单例bean.这样可确
保应用不需要等待他们被创建。

2.1.3 bean的生命周期
bean被载入到容器中时，他的生命周期就开始
了。bean工厂在一个bean可以使用前完成很多
工作：
1.容器寻找bean的定义信息并实例化。
2.使用依赖注入，spring按bean定义信息配置bean的所有属性。
3.若bean实现了BeanNameAware接口，工厂调用Bean的setBeanName
  （）方法传递bean的ID。
4.若bean实现了BeanFactoryAware接口，工厂调用setBeanFactory（）
   方法传入工厂自身。
5.若BeanPostProcessor和bean关联，则它们的
   postProcessBeforeInitialization()方法被调用。
6.若bean指定了ini-method方法、，它将被调用。
7.最后，若有BeanPostProcessor和bean关联，则它们的
   postProcessAfterInitialization()方法被调用、。

2.1.3 bean的生命周期(续)
将bean从工厂中删掉有两种方法：
1.若bean实现了DisposableBean接口，
   distroy()方法被调用。
2.如果指定了定制的销毁方法，就调用这个方法。
bean在应用上下文中的生命周期和在bean工厂
的生命周期唯一不同的是：若bean实现了
ApplicationContextAware()接口，
setApplicationContext()方法会被调用。

2.2 基本装配
   在spring容器内拼凑bean叫做装配。装
   配bean的时候，需要告诉容器哪些bean
   以及容器如何使用依赖注入将它们配合在
   一起。

2.2.1 使用XML装配
   xml是最常见的spring应用系统配置源。
   几种spring容器都支持使用xml装配bean，包括：
   1.XmlBeanFactory:调用InputStream载入上下文
      定义文件。
   2.ClassPathXmlApplicationContext:从类路径载
      入上下文定义文件。
   3.XmlWenApplicationContext:从web应用上下文
      中载入定义文件。

2.2.1 使用XML装配(续)
上下文定义文件的根元素是<beans>.<beans>有多
个<bean>子元素。每个<bean>元素定义了一个
bean如何被装配到spring容器中。

<beans>
       <bean id="foo" class="...Foo"/>
       <bean id="bar" class="...Bar"/>
</beans>

2.2.2 添加一个bean
对bean的最基本的配置包括bean的ID和他的
全称类名。
<bean id="foo" class="...Foo"/>
bean的id是foo。

2.2 基本装配-scope
prototype、singleton、request session、global-session
spring中的bean缺省情况下是单例模式。始终返回一个实
例。若想返回不同的实例的话需要定义成原型模式。
bean的singleton属性告诉上下文该bean是否为单例的。缺
省为true。若为false的话，为原型bean。

<bean id="foo" class="...Foo" singleton="false"/>
<!– spring2.5 -->
<bean scope="prototype|single|..">

2.2.2 添加一个bean(续)
  使用原型bean会对性能产生影响，尽量不要把singleton设置为false,除非有必要。

2.2.2 添加一个bean(续)
  实例化与销毁
  spring实例化bean或销毁bean时，有时需要作一些处理工作，因此spring可以在创建和拆卸bean的时候调用bean的两个生命周期方法。

 <bean class="Foo" init-method destory-method>
 <!-- spring2.5-->
 @PostConstruct public void ini(){…} 
 @PreDestroy public void destroy(){…}
 <bean
          class="...CommonAnnotationBeanPostProcessor">

2.2.2 添加一个bean(续)
  spring也提供了两个接口来实现相同的功能：
  InitializingBean和DisposableBean.
  InitializingBean接口提供了一个afterPropertiesSet()方法。
  DisposableBean接口提供了destroy().
  不推荐使用该接口，它将你的bean和springAPI邦定在一起。

2.2.3 通过set方法注入依赖
  <bean>元素的< property >子元素指明了使用它们的set方法来注入。可以注入任何东西，从基本类型到集合类，甚至是应用系统的bean。

2.2.3 通过set方法注入依赖(续)
  简单bean配置
  配置bean的简单属性，基本数据类型和string。

  <bean id="foo" class="...Foo">
        <property name="name">
              <value>tom</value>
        </property>  
  </bean>

2.2.3 通过set方法注入依赖(续)
 引用其它bean

 <bean id="foo" class="...Foo">
        <property name="name">
              <ref bean="bar">
        </property>  
  </bean>
 <bean id="bar" class="...Bar">
  </bean>

2.2.3 通过set方法注入依赖(续)
  内部bean

  <bean id="foo" class="...Foo">
        <property name="bar">
              <bean class="...Bar">
        </property>  
  </bean>
这种方式的缺点是你无法在其它地方重用这个bar实
例，原因是它是专门为foo而用。

2.2.3 通过set方法注入依赖(续)
  装配map：

<property name="barlist">
       <map>
           <entry key="key1" value="bar1" />
           <entry key="key2 value-ref="xxx" />
      </map>
  </property>
  key值必须是string的,key-ref可以是其他bean
  <!– spring2.5 -->
  <util:map>

2.2.3 通过set方法注入依赖(续)
  装配Properties：

  <property name="barlist">
       <props>
           <prop key="key1">bar1</prop>
           <prop key="key2">bar2</prop>
       </props>
  </property>
  <!-- spring2.5 -->
  <util:properties>

2.2.4 通过构造函数注入依赖

   <bean id="foo" class="...Foo">
        <constructor-arg>
              <value>42</value>
        </constructor>
    </bean>
    <bean id="foo" class="...Foo">
        <constructor-arg>
              <ref bean="bar">
        </constructor>
    </bean>
    set注入的缺点是无法清晰表达哪些属性是必须的，哪些是可选
    的，构造注入的优势是通过构造强制依赖关系，不可能实例化不
    完全的或无法使用的bean。

2.2.4 通过构造函数注入依赖(续)
  解决构造函数参数不确定性
  构造函数多或参数类型大都相同该如何处理？
  spring并不是按照参数的顺序来配置参数的。
  有两种方法来解决构造参数的不确定性：序号和类型。
  <constructor-arg>有一个可选的index属性，可用来指定参数的顺序。

2.2.4 通过构造函数注入依赖(续)
  解决构造函数参数不确定性
  通过参数的顺序：

  <constructor-arg index=0>
        <value>http://www.tom.com</value>
  </construcotr-arg>
  <constructor-arg index=1>
        <value>bar1</value>
  </construcotr-arg>

2.2.4 通过构造函数注入依赖(续)
  解决构造函数参数不确定性
  通过参数的类型：
 

<constructor-arg type="java.lang.String">
         <value>http://www.tom.com</value>
  </construcotr-arg>
  <constructor-arg java.lang.URL>
         <value>bar1</value>
  </construcotr-arg>