spring中Bean的生命周期

一、Spring Bean是什么？

Spring bean是Spring框架在运行时管理的对象。Spring bean是任何Spring应用程序的基本构建块。你编写的大多数应用程序逻辑代码都将放在Spring bean中。Spring bean的管理包括：

• 创建一个对象
• 提供依赖项（例如其他bean，配置属性）
• 拦截对象方法调用以提供额外的框架功能
• 销毁一个对象

二、Bean生命周期

bean从创建到销毁经历的一下阶段：

1. 通过构造器创建bean实例 执行构造器
2. 为bean属性赋值 执行set方法
3. 初始化bean 调用bean的初始化方法,需要配置指定调用的方法
4. bean的获取 容器对象 getBean方法（这一步在网上，有时候不单列出来）
5. 容器关闭销毁bean 调用销毁方法,需要配置指定调用的方法

2.1.创建user类

package com.augus;

public class User {
    private Integer userid;
    private String username;
    private String password;

    @Override
    public String toString() {
        return "User{" +
                "userid=" + userid +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public User() {
        System.out.println("第一步：user构造");
    }

    public void initUser(){
        System.out.println("第三步：初始化user");
    }

    public void destoryUser(){
        System.out.println("第五步:User销毁");
    }

    public User(Integer userid, String username, String password) {
        this.userid = userid;
        this.username = username;
        this.password = password;
    }

    public Integer getUserid() {
        return userid;
    }

    public void setUserid(Integer userid) {
        System.out.println("第二步：user对象属性赋值");
        this.userid = userid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

2.创建applicationContext4.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"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
">
    <!--
    init-method="initUser" 指定初始化时执行的方法
    destroy-method="destoryUser" 指定销毁是执行的方法
    -->
    <bean id="user" class="com.augus.User" init-method="initUser" destroy-method="destoryUser">
        <property name="userid" value="100"></property>
        <property name="username" value="殷梨亭"></property>
        <property name="password" value="asds"></property>
    </bean>
</beans>

2.3.测试代码

import com.augus.User;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test4 {
    @Test
    public void testGetBean(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext4.xml");
        // 获取对象 , 并且输出其属性的值
        User user = context.getBean("user", User.class);
        System.out.println("第四部：从容器中获取user对象");
        System.out.println(user);

        //注意：只有当容器关闭的额时候，对象才会执行销毁
        context.close();
    }

}

三、Bean生命周期中设置后置处理器

Bean 后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理。

​BeanPostProcessor ​接口定义回调方法，可以实现该方法来提供自己的实例化逻辑，依赖解析逻辑等。也可以在 ​Spring​ 容器通过插入一个或多个 ​BeanPostProcessor​ 的实现来完成实例化，配置和初始化一个​bean​之后实现一些自定义逻辑回调方法。

你可以配置多个 ​BeanPostProcessor ​接口，通过设置 ​BeanPostProcessor ​实现的​ Ordered ​接口提供的​ order​ 属性来控制这些​ BeanPostProcessor​ 接口的执行顺序。

​BeanPostProcessor​ 可以对​ bean​（或对象）实例进行操作，这意味着 ​Spring IoC​ 容器实例化一个 ​bean​ 实例，然后 ​BeanPostProcessor​ 接口进行它们的工作。

流程如下：

• 通过构造器创建bean实例 执行构造器
• 为bean属性赋值 执行set方法
• 把bean实例传递给bean的后置处理器的方法
• 初始化bean 调用bean的初始化方法,需要配置指定调用的方法
• 把bean实例传递给bean的后置处理器的方法
• bean的获取 容器对象 getBean方法
• 容器关闭销毁bean 调用销毁方法,需要配置指定调用的方法

3.1.创建后置处理器 实现 BeanPostProcesser  重写两个方法

接口中的两个方法都要将传入的bean返回，而不能返回null，如果返回的是null那么我们通过getBean方法将得不到目标

package com.augus;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanProcesser implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        /*
        * Object bean,      实例化的bean
        * String beanName   实例化后bean的id
        * */
        System.out.println("bean:初始化之前执行");
        return bean; //必须returnbean
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("bean:初始化之后执行");
        return bean;
    }
}

3.2.配置后置处理器,对容器中的所有bean添加后置处理器的生命周期

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
">
    <!--
    init-method="initUser" 指定初始化时执行的方法
    destroy-method="destoryUser" 指定销毁是执行的方法
    -->
    <bean id="user" class="com.augus.User" init-method="initUser" destroy-method="destoryUser">
        <property name="userid" value="100"></property>
        <property name="username" value="殷梨亭"></property>
        <property name="password" value="asds"></property>
    </bean>

    <!--配置后置处理器
    会自动给上面的user进行后置处理器配置
    -->
    <bean id="myBeanProcesser" class="com.augus.MyBeanProcesser"></bean>
</beans>

3.3.测试代码

ApplicationContext会自动检测在配置文件中实现了BeanPostProcessor接口的所有bean，并把它们注册为后置处理器，然后在容器创建bean的适当时候调用它，因此部署一个后置处理器同部署其他的bean并没有什么区别。而使用BeanFactory实现的时候，bean 后置处理器必须通过代码显式地去注册，在IoC容器继承体系中的ConfigurableBeanFactory接口中定义了注册方法

import com.augus.User;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test4 {
    @Test
    public void testGetBean(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext4.xml");
        // 获取对象 , 并且输出其属性的值
        User user = context.getBean("user", User.class);
        System.out.println("第四部：从容器中获取user对象");
        System.out.println(user);

        //注意：只有当容器关闭的额时候，对象才会执行销毁
        context.close();
    }

}