Bean的作用域

在创建Bean时会先读取bean的xml配置文件，在<Bean>标签中有属性scope，Spring中支持5种作用域

作用域	描述
单例（singleton）	默认，每一个Spring IoC容器都拥有唯一的一个实例对象
原型（prototype）	一个Bean定义，任何多个对象
请求（request）	一个HTTP请求会产生一个Bean对象了，也就是说，每一个HTTP请求都有自己的Bean实例，只在基于Web的Spring ApplicationContext中可用
会话（session）	限定一个Bean的作用域草HTTPSession的生命周期。同样，只有基于Web的SpringApplicationContext才能使用
全局会话（global session）	限定一个Bean的作用域为全局HTTPSession的生命周期。通常用于门户网站场景，同样，只有基于Web的Srping ApplicationContext可用

示范singleton和prototype作用域

xml

   <bean id="xmlinstancesingleton" class="test.model.XMLInstance"
          scope="singleton">
        <property name="name" value="abc"/>
        <property name="air" ref="CleanAir"/>
    </bean>

    <bean id="xmlinstanceprototype" class="test.model.XMLInstance"
          scope="prototype">
        <property name="name" value="abc"/>
        <property name="air" ref="CleanAir"/>
    </bean>

java

public class XMLInstance {
    private String name;
    public void setName(String name ){
        this.name = name;
    }
    private IAir iAir;
    public void setAir(IAir iAir){
        this.iAir = iAir;
    }
    public void Breath(){
        System.out.println("Name:"+this.name+"\nAir:"+this.iAir.toString());
    }
}

  //单例bean
        System.out.println("单例bean");
        xmlinstance = (XMLInstance)ac.getBean("xmlinstancesingleton");
        xmlinstance.setName("123");
        xmlinstance.Breath();
        xmlinstance = (XMLInstance)ac.getBean("xmlinstancesingleton");
        xmlinstance.Breath();
        
        //原型bean
        System.out.println("原型bean");
        xmlinstance = (XMLInstance)ac.getBean("xmlinstanceprototype");
        xmlinstance.setName("123");
        xmlinstance.Breath();
        xmlinstance = (XMLInstance)ac.getBean("xmlinstanceprototype");
        xmlinstance.Breath();

运行结果

单例bean
Name:123
Air:CleanAir
Name:123
Air:CleanAir
原型bean
Name:123
Air:CleanAir
Name:abc
Air:CleanAir

在上例中，使用单例模式时，获取两次bean对象，因为单例模式时在容器启动后以饿汉式实例化，在两次getBean其实都是获取同一静态的bean对象，所以输出结果都相同，使用原型时，是采用clone原型方式来getbean，新生成的bean和xml中配置的bean是相同的。所以当第一个getBean改变后，两个的Bean输出结果不同。

Bean的生命周期

1. 容器启动后，会对scope为singleton进行bean的实例化
2. 按照Bean定信息配置信息，注入所有属性。
3. 如果Bean实现了BeanNameAare接口，会回调该接口的setBeanName()方法，传入该Bean的id，此时该Bean就获得了自己在配置文件中的id。
4. 如果Bean实现了BeanFactoryAware接口，会回调该接口的setBeanFactory()方法，传入该Bean的BeanFactory,这样该Bean就获得了自己所在的BeanFactroy()
5. 如果Bean实现了ApplicationContextAware接口，会回调该接口的setApplicationContext()方法，传入该Bean的ApplicationContext,这样该bean就获得了自己所在的ApplicationContext.
6. 如果有Bean实现了BeanPostProcessor接口，就会回调该接口的postProceessBeforeInitialzation()方法。
7. 如果Bean实现了InitializingBean接口，就会回调该接口的afterPropertiesSet()方法。
8. 如果Bean配置了init-method方法，就会执行init-method配置的方法
9. 如果Bean实现了BeanPostProcessor接口，就会回调该接口的postProcessAfterInitizlization()方法。
10. 之后，就可以正式使用该Bean了。对于scope为singleton的Bean，Spring的ioc容器中会缓存一份该Bean的实例：对于scope为prototype的Bean，每次被调用都会新建一个新的对象，其生命周期交给调用方管理了，不再是由Spring容器进行管理了。
11. 容器关闭后，如果Bean实现了DisposableBean接口，就会回调该接口的destroy()方法。
12. 如果Bean配置了destroy_method方法，就会执行destroy-method配置的方法。到这里整个Bean的生命周期结束。

示范bean整个生命周期执行顺序

新建一个UserBean来实现BeanNameAware,BeanFactoryAware,InitializingBean, DisposableBean, ApplicationContextAware的接口。并为自己配置Myinit和MyDestory方法

java

public class UserBean implements BeanNameAware, BeanFactoryAware,
        InitializingBean, DisposableBean, ApplicationContextAware {
    private String name;
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
        System.out.println("set方法被调用");
    }
    public void myInit(){
        System.out.println("myInit被调用");
    }
    public void myDestroy(){
        System.out.println("myDestroy被调用");
    }
    public UserBean(){
        System.out.println("UserBean构造方法");
    }
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryAware被调用");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("BeanNameAware被调用");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean被调用");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean被调用");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("setApplicationContext被调用");
    }
    public static void main(String []args){
        ApplicationContext ac = new ClassPathXmlApplicationContext("META-INF/beanlife.xml");
        //生命周期
        UserBean userBean = (UserBean)ac.getBean("user");
        ((ClassPathXmlApplicationContext) ac).close();
    }
}

xml

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!--    bean生命周期-->
    <bean id="user" class="test.model.UserBean"
          init-method="myInit" destroy-method="myDestroy">
        <property name="name" value="abc"></property>
    </bean>
    <bean id="postProcessor" class="test.model.CusBeanPostProcessor"/>
</beans>

运行结果

UserBean构造方法
set方法被调用
BeanNameAware被调用
BeanFactoryAware被调用
setApplicationContext被调用
postProcessBeforeInitialization被调用
InitializingBean被调用
myInit被调用
postProcessAfterInitialization被调用
DisposableBean被调用
myDestroy被调用