Spring-Bean的作用域和生命周期

bean的作用域

概念：

Spring 2.5之前的Bean 的作用域只有两种

Springleton：单例Bean
Prototype ：原型Bean

Spring 2.5 之后Bean的作用域有一下五种

作用域	描述
singleton (单例)	使用该属性定义Bean时，IOC容器仅创建一个Bean实例，IOC容器每次返回的是同一个Bean实例。在整个spring ioc 容器中只能创建一个Bean实例
prototype (原型)	使用该属性定义Bean时，IOC容器可以创建多个Bean实例，每次返回的都是一个新的实例。每次调用都会创建一个bean
request (请求)	该属性仅对HTTP请求产生作用，使用该属性定义Bean时，每次HTTP请求都会创建一个新的Bean，适用于WebApplicationContext环境。
session (会话)	该属性仅用于HTTP Session，同一个Session共享一个Bean实例。不同Session使用不同的实例。
global-session (全局)	该属性仅用于HTTP Session，同session作用域不同的是，所有的Session共享一个Bean实例。

在Spring里面，默认情况下，bean是单实例对象

如何设置bean的作用域

在Spring配置文件bean标签里面有属性（scope）用于设置单实例还是多实例

scope属性值

默认值，singleton，表示单实例对象
prototype，表示多实例对象

1
2
3

<bean id="book" class="com.ligangit.spring5.collectionType.Book" scope="prototype">
    <property name="list" ref="bookList"></property>
</bean>

    @Test
    public void testCollection2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        Book book1 = context.getBean("book", Book.class);

        Book book2 = context.getBean("book", Book.class);
//        book.test();
        System.out.println(book1);
        System.out.println(book2);

    }

测试结果中两个Book对象的地址不相同，说明是两个不同的对象

bean作用域

singleton和prototype的区别
- 第一：singleton是单实例，prototype是多实例
- 第二：设置scope值是singleton时候，加载Spring配置文件时就会创建单实例对象；设置scope值是prototype时候，不是在加载Spring配置文件时就会创建对象，在调用getBean方法的时候创建多实例对象。
  
  singleton是在执行如下代码的时候，就会创建单实例对象；
  1
  ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
  prototype是在执行如下代码的时候，才会创建多实例对象，每次创建的都是新的对象。
  1
  Book book1 = context.getBean("book", Book.class);
scope值是request的时候，创建的对象会放入带request中；scope值是session的时候，创建的对象会放入带session中。

bean的生命周期

通过构造器创建bean实例（无参构造）
为bean的属性设置值和对其他bean引用（调用set方法）
调用bean的初始化的方法（需要进行配置初始化的方法）
bean可以使用了（对象获取到了）
当容器关闭时候，调用bean的销毁方法（需要进行配置销毁的方法）

演示bean的生命周期

实例类

public class Orders {
    //无参构造
    public Orders(){
        System.out.println("第一步 执行无参构造创建bean示例");
    }
    private String oname;
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("第二步 调用set方法设置属性值");
    }
    //创建执行的初始化的方法
    public void initMethod(){
        System.out.println("第三步 执行初始化的方法");
    }
    //创建执行的销毁的方法
    public void destroyMethod(){
        System.out.println("第五步 执行销毁的方法");
    }
}

Spring配置文件配置

1
2
3

<bean id="orders" class="com.ligangit.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
    <property name="oname" value="手机"></property>
</bean>

测试代码

@Test
public void testBean4(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
    Orders orders = context.getBean("orders", Orders.class);
    System.out.println("第四步 获取创建bean实例对象");
    System.out.println(orders);
    //手动让bean实例销毁
    ((ClassPathXmlApplicationContext) context).close();
}

测试结果

加上bean的后置处理器后，生命周期有七步

通过构造器创建bean实例（无参构造）
为bean的属性设置值和对其他bean引用（调用set方法）
把bean的实例传递给bean后置处理器的方法postProcessBeforeInitialization
调用bean的初始化的方法（需要进行配置初始化的方法）
把bean的实例传递给bean后置处理器的方法postProcessAfterInitialization
bean可以使用了（对象获取到了）
当容器关闭时候，调用bean的销毁方法（需要进行配置销毁的方法）

演示添加后置处理器效果

创建类，实现接口BeanPostProcessor，创建后置处理器

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return bean;
    }
}

在Spring配置文件中配置后置处理器

配置后置处理器后，会给此配置文件中所有的bean实例添加后置处理器

<bean id="orders" class="com.ligangit.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
    <property name="oname" value="手机"></property>
</bean>
   
<!--配置后置处理器（会给此配置文件中所有的bean实例添加后置处理器）-->
<bean id="myBeanPost" class="com.ligangit.spring5.bean.MyBeanPost"></bean>