【SSM】Spring6(五.Bean的生命周期)

1.Bean的生命周期（五步）

• 实例化Bean（调用无参构造方法）
• 给Bean属性赋值（调用set方法）
• 初始化Bean（调用Bean的init方法）
• 使用Bean
• 销毁Bean（调用Bean的destroy）
  (注意：第三步和第五步的方法需要自己写，自己配)

User.java

package com.sdnu.spring6.bean;

public class User {
    private String name;

    public User() {
        System.out.println("第一步：无参数构造方法执行");
    }

    public void setName(String name) {
        System.out.println("第二步：给对象的属性赋值");
        this.name = name;
    }

    //此方法需要自己写，自己配置，方法名随意
    public void initBean(){
        System.out.println("第三步：初始化Bean");
    }

    //此方法需要自己写，自己配置，方法名随意
    public void destroyBean(){
        System.out.println("第五步：销毁Bean");
    }
}

Spring配置文件

<?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">

    <bean id="user" class="com.sdnu.spring6.bean.User" init-method="initBean" destroy-method="destroyBean">
        <property name="name" value="张三"/>
    </bean>
</beans>

测试

package com.sdnu.spring6.test;

import com.sdnu.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanLifecycleTest {
    @Test
    public void testBeanLifecycleFive(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Object user = applicationContext.getBean("user", User.class);
        System.out.println("第四步：使用Bean");
        //必须手动关闭Spring容器，这样Spring容器才会销毁Bean
        ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext)applicationContext;
        context.close();
    }
}

2.Bean的生命周期（七步）

• 实例化Bean（调用无参构造方法）
• 给Bean属性赋值（调用set方法）
• 执行Bean后处理器的before方法
• 初始化Bean（调用Bean的init方法）
• 执行Bean后处理器的after方法
• 使用Bean
• 销毁Bean（调用Bean的destroy）
  (注意：第三步和第五步的方法需要自己写，自己配)

编写一个类实现BeanPostProcessor

package com.sdnu.spring6.bean;

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

public class LogBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行Bean后处理器的before方法");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行Bean后处理器的after方法");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

配置

<?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">

    <!--这个Bean处理器将作用于整个配置文件的所有Bean-->
    <bean class="com.sdnu.spring6.bean.LogBeanPostProcessor"/>
    <bean id="user" class="com.sdnu.spring6.bean.User" init-method="initBean" destroy-method="destroyBean">
        <property name="name" value="张三"/>
    </bean>
</beans>

3.Bean的生命周期（十步）

比七步多了三步，分别是
（1）在执行Bean后处理器的before方法之前
（2）在执行Bean后处理器的before方法之后
（3）在执行使用Bean之后，执行销毁Bean之前

这三个点位的特点是检查是否实现某些特定的接口，如果实现了接口，spring容器会调用这些特定接口中的方法。

Bean实现了
● Aware相关的接口
● InitializingBean
● DisposableBean

Aware相关的接口包括：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
● 当Bean实现了BeanNameAware，Spring会将Bean的名字传递给Bean。
● 当Bean实现了BeanClassLoaderAware，Spring会将加载该Bean的类加载器传递给Bean。
● 当Bean实现了BeanFactoryAware，Spring会将Bean工厂对象传递给Bean。

User.java

package com.sdnu.spring6.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean{
    private String name;

    public User() {
        System.out.println("第一步：无参数构造方法执行");
    }

    public void setName(String name) {
        System.out.println("第二步：给对象的属性赋值");
        this.name = name;
    }

    //此方法需要自己写，自己配置，方法名随意
    public void initBean(){
        System.out.println("第六步：初始化Bean");
    }

    //此方法需要自己写，自己配置，方法名随意
    public void destroyBean(){
        System.out.println("第十步：销毁Bean");
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("第三步：（2）Bean这个类的类加载器是" + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("第三步：（3）生产这个Bean的工厂对象是" + beanFactory);
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("第三步：（1）Bean的名字是" + s);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("第五步：InitializingBean的afterPropertiesSet方法执行");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("第九步：DisposableBean的destroy方法执行");
    }
}

LogBeanPostProcessor.java

package com.sdnu.spring6.bean;

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

public class LogBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第四步：执行Bean后处理器的before方法");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("第七步：执行Bean后处理器的after方法");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

spring配置

<?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">

    <!--这个Bean处理器将作用于整个配置文件的所有Bean-->
    <bean class="com.sdnu.spring6.bean.LogBeanPostProcessor"/>
    <bean id="user" class="com.sdnu.spring6.bean.User" init-method="initBean" destroy-method="destroyBean">
        <property name="name" value="张三"/>
    </bean>
</beans>

测试

package com.sdnu.spring6.test;

import com.sdnu.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanLifecycleTest {
    @Test
    public void testBeanLifecycleFive(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Object user = applicationContext.getBean("user", User.class);
        System.out.println("第八步：使用Bean");
        //必须手动关闭Spring容器，这样Spring容器才会销毁Bean
        ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext)applicationContext;
        context.close();
    }
}

4.Spring根据Bean的作用域选择管理方式

● 对于singleton作用域的Bean，Spring 能够精确地知道该Bean何时被创建，何时初始化完成，以及何时被销毁；
● 而对于 prototype 作用域的 Bean，Spring 只负责创建，当容器创建了 Bean 的实例后，Bean 的实例就交给客户端代码管理，Spring 容器将不再跟踪其生命周期。

5. 自己new的对象如何让Spring管理

		// 自己new的对象
        User user = new User();
        System.out.println(user);

        // 创建 默认可列表BeanFactory 对象
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        // 注册Bean
        factory.registerSingleton("userBean", user);
        // 从spring容器中获取bean
        User userBean = factory.getBean("userBean", User.class);
        System.out.println(userBean);