😀前言
本章是spring基于XML 配置bean系类中第6篇讲解spring-bean的生命周期和怎么配置spring-bean的后置处理器

🏠个人主页：尘觉主页
在这里插入图片描述

🧑个人简介：大家好，我是尘觉，希望我的文章可以帮助到大家，您的满意是我的动力😉😉

在csdn获奖荣誉: 🏆csdn城市之星2名
⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　💓Java全栈群星计划top前5
⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　⁣⁣⁣⁣　🤗 端午大礼包获得者

💕欢迎大家：这里是CSDN，我总结知识的地方，欢迎来到我的博客，感谢大家的观看🥰
如果文章有什么需要改进的地方还请大佬不吝赐教先在次感谢啦😊

文章目录

💌spring-bean的生命周期和怎么配置spring-bean的后置处理器
- bean 的生命周期
- - 🍃● 说明:
  - 创建House.java
  - 配置beans.xml
  - 使用细节
- 🍉配置 bean 的后置处理器
- - 🍎说明
  - 创建后置处理器MyBeanPostProcessor.java
  - 配置beans.xml
  - 🍊其它说明
- 😄总结

💌spring-bean的生命周期和怎么配置spring-bean的后置处理器

bean 的生命周期

🍃● 说明:

bean 对象创建是由 JVM 完成的，然后执行如下方法

执行构造器
执行 set 相关方法
调用 bean 的初始化的方法
使用 bean
当容器关闭时候，调用 bean 的销毁方法

这里java基础

ioc的编译类型 ApplicationContext , 运行类型 ClassPathXmlApplicationContext

因为ClassPathXmlApplicationContext 实现了 ConfigurableApplicationContext

ClassPathXmlApplicationContext 是有close

将ioc 转成ClassPathXmlApplicationContext,再调用close
ioc.close();关闭ioc容器.

    public void testBeanLife() {

        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");

        House house = ioc.getBean("house", House.class);

        System.out.println("使用house=" + house);

        //关闭容器
        //1. 这里又要考察大家的java基础
        //2. ioc的编译类型 ApplicationContext , 运行类型 ClassPathXmlApplicationContext
        //3. 因为ClassPathXmlApplicationContext 实现了 ConfigurableApplicationContext
        //4. ClassPathXmlApplicationContext 是有close
        //5. 将ioc 转成ClassPathXmlApplicationContext,再调用close
        //ioc.close();
        //关闭ioc容器.
        ((ConfigurableApplicationContext) ioc).close();


    }

创建House.java

public class House {
    private String name;

    public House() {
        System.out.println("House() 构造器...");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("House setName()=" + name);
        this.name = name;
    }

    //1. 这个方法是程序员来编写的.
    //2. 根据自己的业务逻辑来写.
    public void init() {
        System.out.println("House init()..");
    }

    //1. 这个方法是程序员来编写的.
    //2. 根据自己的业务逻辑来写.
    //3. 名字也不是固定的
    public void destroy() {
        System.out.println("House destroy()..");
    }

    @Override
    public String toString() {
        return "House{" +
                "name='" + name + '\'' +
                '}';
    }
}

配置beans.xml

init-method=“init” 指定bean的初始化方法 , 在setter方法后执行

init方法执行的时机，有spring容器来控制

destroy-method=“destroy” 指定bean的销毁方法, 在容器关闭的时候执行

destroy方法执行的时机，有spring容器来控制

    <!--配置House对象，演示整个Bean的生命周期
    解读
    1. init-method="init" 指定bean的初始化方法 , 在setter方法后执行
    2. init方法执行的时机，有spring容器来控制
    3. destroy-method="destroy" 指定bean的销毁方法, 在容器关闭的时候执行
    4. destroy方法执行的时机，有spring容器来控制
    -->
    <bean class="com.spring.bean.House" id="house"
          init-method="init"
          destroy-method="destroy">
        <property name="name" value="北京豪宅"/>
    </bean>

使用细节

初始化 init 方法和 destory 方法, 是程序员来指定
销毁方法就是当关闭容器时，才会被调用

🍉配置 bean 的后置处理器

🍎说明

在 spring 的 ioc 容器,可以配置 bean 的后置处理器
该处理器/对象会在 bean 初始化方法调用前和初始化方法调用后被调用
程序员可以在后置处理器中编写自己的代码

@Test
    public void testBeanPostProcessor() {

        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans02.xml");

        House house = ioc.getBean("house", House.class);
        System.out.println("使用house=" + house);

        House house02 = ioc.getBean("house02", House.class);
        System.out.println("使用house02=" + house02);

        ((ConfigurableApplicationContext)ioc).close();

    }

创建 House.java 前面有

创建后置处理器MyBeanPostProcessor.java

什么时候被调用: 在Bean的init方法前被调用
@param bean 传入的在IOC容器中创建/配置Bean
@param beanName 传入的在IOC容器中创建/配置Bean的id
@return Object 程序员对传入的bean 进行修改/处理【如果有需要的话】 ,返回
@throws BeansException

什么时候被调用: 在Bean的init方法后被调用
@param bean 传入的在IOC容器中创建/配置Bean
@param beanName 传入的在IOC容器中创建/配置Bean的id
@return 程序员对传入的bean 进行修改/处理【如果有需要的话】 ,返回
@throws BeansException

public class MyBeanPostProcessor implements BeanPostProcessor {

    /**
     * 什么时候被调用: 在Bean的init方法前被调用
     * @param bean 传入的在IOC容器中创建/配置Bean
     * @param beanName 传入的在IOC容器中创建/配置Bean的id
     * @return Object 程序员对传入的bean 进行修改/处理【如果有需要的话】 ,返回
     * @throws BeansException
     */

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization().. bean="
                + bean + " beanName=" + beanName);

        //初步体验案例: 如果类型是House的统一改成 上海豪宅
        //对多个对象进行处理/编程==>切面编程
        if(bean instanceof House) {
            ((House)bean).setName("上海豪宅~");
        }
        return null;
    }

    /**
     * 什么时候被调用: 在Bean的init方法后被调用
     * @param bean  传入的在IOC容器中创建/配置Bean
     * @param beanName 传入的在IOC容器中创建/配置Bean的id
     * @return 程序员对传入的bean 进行修改/处理【如果有需要的话】 ,返回
     * @throws BeansException
     */

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization().. bean="
                + bean + " beanName=" + beanName);
        return bean;
    }
}

配置beans.xml

当我们在 .xml 容器配置文件配置了 MyBeanPostProcessor

这时后置处理器对象，就会作用在该容器创建的Bean对象

已经是针对所有对象编程->切面编程AOP

 <!--配置House对象-->
    <bean class="com.spring.bean.House" id="house"
          init-method="init"
          destroy-method="destroy">
        <property name="name" value="大豪宅"/>
    </bean>

    <bean class="com.spring.bean.House" id="house02"
          init-method="init"
          destroy-method="destroy">
        <property name="name" value="香港豪宅"/>
    </bean>

    <!--配置了一个Monster对象-->

    <!--配置后置处理器对象
    1. 当我们在beans02.xml 容器配置文件 配置了 MyBeanPostProcessor
    2. 这时后置处理器对象，就会作用在该容器创建的Bean对象
    3. 已经是针对所有对象编程->切面编程AOP
    -->
    <bean class="com.spring.bean.MyBeanPostProcessor" id="myBeanPostProcessor"/>

🍊其它说明

1、怎么执行到这个方法?=> 使用 AOP(反射+动态代理+IO+容器+注解)
.
2、有什么用？=> 可以对 IOC 容器中所有的对象进行统一处理 ,比如日志处理/权限的校验/安全的验证/事务管理. - 初步体验: 如果类型是 House 的统一改成上海豪宅
.
3、针对容器的所有对象吗? 是的=>切面编程特点