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等自定义的销毁方法，如果有的话，则会自动调用其配置的销毁方法；
为什么需要设计BeanPostProcessorBeanPostProcessor及其子类都实现了后置处理的功能。
1.其中postProcessBeforeInitialization方法会在每一个bean对象的初始化方法调用之前回调；2.postProcessAfterInitialization方法会在每个bean对象的初始化方法调用之后被回调。
相关代码：
package com.mayikt.postprocessor; import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; @Component public class MyBeanPostProcessor implements BeanPostProcessor { //其中postProcessBeforeInitialization方法会在每一个bean对象的初始化方法调用之前回调； /** * 在调用init初始化之前 可以修改原有bean对象 如果返回是为null 则直接返回原有bean对象 * * @param bean * @param beanName * @return * @throws BeansException */ public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { if ("mayiktBean".equals(beanName)) System.out.println("A before--实例化的bean对象:" bean "t" beanName); return bean; } //postProcessAfterInitialization方法会在每个bean对象的初始化方法调用之后被回调。 可以修改原有bean对象 如果返回是为null 则直接返回原有bean对象 public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if ("mayiktBean".equals(beanName)) System.out.println("A after...实例化的bean对象:" bean "t" beanName); return bean; } } --------------------------------------------------------------------------- package com.mayikt.entity; 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.stereotype.Component; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; /** * @author songchuanfu * @qq 1802284273 */ @Component 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()..."); } }
@PostConstruct是Java自带的注解，在方法上加该注解会在项目启动的时候执行该方法，也可以理解为在spring容器初始化的时候执行该方法
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { if ("mayiktBean".equals(beanName)) System.out.println("A before--实例化的bean对象:" bean "t" beanName); return bean; } 相关源码： public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException { Object result = existingBean; for (BeanPostProcessor processor : getBeanPostProcessors()) { // 执行后置处理器 如果 后置处理器有返回bean对象 则使用 后置处理器返回bean对象 Object current = processor.postProcessBeforeInitialization(result, beanName); if (current == null) { return result; } result = current; } return result; }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
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多个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); }); } }相关代码
spring源码核心.rar
