18.spring bean 的生命周期

陌陌龙

已于 2022-08-19 00:06:52 修改

阅读量177

点赞数

分类专栏：每特教育第十一期文章标签： spring java mybatis

于 2022-08-19 00:06:22 首次发布

本文链接：https://blog.csdn.net/u014001523/article/details/126416112

版权

每特教育第十一期专栏收录该内容

20 篇文章 2 订阅

订阅专栏

1.Bean生命周期简单概述
2.BeanPostProcessor作用
3.BeanPostProcessor实现增强
4.模拟手写BeanPostProcessor增强
5.常见后置处理器类型有哪些
6.@Autowired Bean后置处理器源码解读

第十期中----手写nacos config 分布式配置中心

刷新bean—设计spring bean生命周期

依赖BeanPostProcessor

IOC容器架构设计原理

周二 bean处理器底层架构设计

周四 bean生命周期原理总结—

周六手写出 spring bean生命周期

spring bean生命周期 BeanPostProcessor

Bean生命周期概述

1.Spring中的bean的生命周期主要包含四个阶段：实例化Bean --＞ Bean属性填充 --＞初始化Bean --＞销毁Bean

2.首先是实例化Bean，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚末初始化的依赖时，容器就会调用doCreateBean()方法进行实例化，实际上就是通过反射的方式创建出一个bean对象

3.Bean实例创建出来后，接着就是给这个Bean对象进行属性填充，也就是注入这个Bean依赖的其它bean对象

属性填充完成后，进行初始化Bean操作，初始化阶段又可以分为几个步骤：

3.1执行Aware接口的方法

3.2.Spring会检测该对象是否实现了xxxAware接口，通过Aware类型的接口，可以让我们拿到Spring容器的些资源。如实现

3.3.BeanNameAware接口可以获取到BeanName，实现BeanFactoryAware接口可以获取到工厂对象BeanFactory等

3.4.执行BeanPostProcessor的前置处理方法postProcessBeforelnitialization()，对Bean进行一些自定义的前置处理

3.5.判断Bean是否实现了InitializingBean接口，如果实现了，将会执行lnitializingBean的afeterPropertiesSet()初始化方法；

3.6.执行用户自定义的初始化方法，如init-method等；

3.7.执行BeanPostProcessor的后置处理方法postProcessAfterinitialization()

初始化完成后，Bean就成功创建了，之后就可以使用这个Bean，当Bean不再需要时，会进行销毁操作，

3.8首先判断Bean是否实现了DestructionAwareBeanPostProcessor接口，如果实现了，则会执行DestructionAwareBeanPostProcessor后置处理器的销毁回调方法

3.8其次会判断Bean是否实现了DisposableBean接口，如果实现了将会调用其实现的destroy()方法

3.9最后判断这个Bean是否配置了dlestroy-method等自定义的销毁方法，如果有的话，则会自动调用其配置的销毁方法；

为什么需要设计BeanPostProcessor

BeanPostProcessor及其子类都实现了后置处理的功能。

1.其中postProcessBeforeInitialization方法会在每一个bean对象的初始化方法调用之前回调；2.postProcessAfterInitialization方法会在每个bean对象的初始化方法调用之后被回调。

BeanPostProcessor处理器实现异步增强

package com.mayikt.postprocessor;

import com.mayikt.ext.MayiktAsync;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
* @author songchuanfu
* @qq 1802284273
*/
@Component
public class AsyncPostProcessor implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 1.判断类上是否有加上MayiktAsync
        MayiktAsync mayiktAsync = bean.getClass().getDeclaredAnnotation(MayiktAsync.class);
        // 2.如果类上有加上mayiktAsync 走cglib代理 采用异步执行方法
        if (mayiktAsync == null) {
            return bean;
        }
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(bean.getClass());
        enhancer.setCallback((MethodInterceptor) (o, method, objects, methodProxy) -> {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        methodProxy.invokeSuper(o, objects);// 执行目标方法
                    } catch (Throwable throwable) {

                    }
                }
            });
            return null;
        });

        return enhancer.create();
    }
}

package com.mayikt.entity;

import com.mayikt.ext.MayiktAsync;
import com.sun.org.slf4j.internal.Logger;
import com.sun.org.slf4j.internal.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
* @author songchuanfu
* @qq 1802284273
*/
@Component
@MayiktAsync
public class MayiktBean {


    public MayiktBean() {
        System.out.println("MayiktBean 构造方法执行...");
    }

    @Autowired
    public void getUser(UserEntity userEntity1) {
        System.out.println(" MayiktBean 依赖注入,userEntity:" + userEntity1);
    }

    @PostConstruct
    public void init() {
        System.out.println(" MayiktBean init()...");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("MayiktBean destroy()...");
    }

    public void add() {
        System.out.println(Thread.currentThread().getName() + ",...add()...");
    }
}

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
            // 执行 bean处理器 初始化（init）方法之前 
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
            // 执行类中 初始化方法init()
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
            //   // 执行 bean处理器 初始化（init）方法之后
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
			  // 执行bean处理器方法 如果返回值 null
            Object current = processor.postProcessBeforeInitialization(result, beanName);
			if (current == null) {
                // 返回就是原来bean对象
				return result;
			}
            // 如果我们的 postProcessBeforeInitialization返回值
            // 不为null的情况下 则将 返回值作为新对象
			result = current;
		}
		return result;
	}

自定义注解生效的情况下代理模式

1.aop+反射模式

2.bean 处理器改写原生bean对象为代理对象走代理回调方法目标方法前后实现增强。

BeanPostProcessor处理器封装底层原理

在spring中提供了非常多的BeanPostProcessor

package com.mayikt.ext;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;

import javax.annotation.Resource;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;

/**
* @author songchuanfu
* @qq 1802284273
*/
public class SpringApplicationContext {


    private List<MayiktBeanPostProcessor> mayiktBeanPostProcessors = new ArrayList<>();

    public SpringApplicationContext() {
        mayiktBeanPostProcessors.add(new AutowiredMayiktBeanPostProcessor());
        mayiktBeanPostProcessors.add(new ResourceMayiktBeanPostProcessor());
    }

    public void getBean(String name) throws BeansException {
        //1.实例化Bean 执行无参构造方法
        Object bean = new Object(); // 例如该对象从IOC容器中获取 bean对象
        //2.Bean属性填充  ---    @Autowired     @Resource
        mayiktBeanPostProcessors.forEach(beanPostProcessor -> {
            beanPostProcessor.postProcessBeforeInitialization(bean, name);
        });
        //3.初始化Bean
        //4.销毁Bean
        System.out.println("返回bean对象");
    }

    interface MayiktBeanPostProcessor {
        Object postProcessBeforeInitialization(Object bean, String beanName);
    }

    class AutowiredMayiktBeanPostProcessor implements MayiktBeanPostProcessor {

        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) {
            // 根据该bean 给该bean成员属性赋值
            System.out.println(" Autowired 依赖注入成员属性赋值 beanName:" + beanName);
            return bean;
        }
    }

    class ResourceMayiktBeanPostProcessor implements MayiktBeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) {
            // 根据该bean 给该bean成员属性赋值
            System.out.println(" Resource 依赖注入成员属性赋值beanName:" + beanName);
            return bean;
        }
    }

}

多个BeanPostProcessor处理器如何排序

实现Ordered

public class AsyncPostProcessor implements BeanPostProcessor , Ordered {
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

重写getOrder方法值越小越优先执行

    @Override
    public int getOrder() {
        return 3;
    }

常用BeanPostProcessor处理器

AutowiredAnnotationBeanPostProcessor

1.AutowiredAnnotationBeanPostProcessor 处理Autowired注解

2.CommonAnnotationBeanPostProcessor 处理 处理@Resource @PostConstruct @PreDestroy

package com.mayikt.entity;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;

/**
* @author songchuanfu
* @qq 1802284273
*/
@Component
public class MemberEntity {

    @Autowired
    private OrderEntity order1;

    private OrderEntity order2;
    private OrderEntity order3;

    @Autowired
    public void setOrderEntity(OrderEntity orderEntity) {
        System.out.println("@Autowired生效,setOrderEntity:" + orderEntity);
        this.order2 = orderEntity;
    }

    @Resource
    public void setOrderEntity2(OrderEntity orderEntity) {
        System.out.println("@Resource,orderEntity:" + orderEntity);
        this.order3 = orderEntity;
    }


    @PostConstruct
    public void init() {
        System.out.println(" MayiktBean init()...");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("MayiktBean destroy()...");
    }

    public OrderEntity getOrder1() {
        return order1;
    }


}
package com.mayikt.entity;

import org.springframework.stereotype.Component;

/**
* @author songchuanfu
* @qq 1802284273
*/
@Component
public class OrderEntity {
}
    // 1.创建轻量级 GenericApplicationContext
        GenericApplicationContext applicationContext = new GenericApplicationContext();
        // 2.注册bean对象
        applicationContext.registerBean("memberEntity", MemberEntity.class);
        applicationContext.registerBean("orderEntity", OrderEntity.class);
        applicationContext.registerBean(AutowiredAnnotationBeanPostProcessor.class);//处理Autowired注解
        applicationContext.registerBean(CommonAnnotationBeanPostProcessor.class);// 处理@Resource     @PostConstruct  @PreDestroy
        // 3.初始化IOC容器 执行 后置处理器
        applicationContext.refresh();
        Arrays.stream(applicationContext.getBeanDefinitionNames()).forEach((b) -> {
            System.out.println(b);
        });
        MemberEntity memberEntity = applicationContext.getBean("memberEntity", MemberEntity.class);
        System.out.println(memberEntity.getOrder1());
        applicationContext.close();

工厂处理器

bean后置处理器 bean额外增强功能

1.bean中成员属性赋值

2.注解生效额外增强

ConfigurationClassPostProcessor 工厂处理器

package com.mayikt.test;

import com.mayikt.config.SpringConfig02;
import com.mayikt.entity.MemberEntity;
import org.springframework.context.annotation.ConfigurationClassPostProcessor;
import org.springframework.context.support.GenericApplicationContext;

import javax.security.auth.login.Configuration;
import java.util.Arrays;

/**
* @author songchuanfu
* @qq 1802284273
*/
public class Test03 {
    public static void main(String[] args) {
        // 1.创建轻量级 GenericApplicationContext
        GenericApplicationContext applicationContext = new GenericApplicationContext();
        // 2.注册bean对象
        applicationContext.registerBean("springConfig02", SpringConfig02.class);
        applicationContext.registerBean(ConfigurationClassPostProcessor.class);
        // @ComponentScan("com.mayikt.entity") @Bean等 @Configuration
        applicationContext.refresh();
        Arrays.stream(applicationContext.getBeanDefinitionNames()).forEach((b) -> {
            System.out.println(b);
        });
    }
}