admin管理员组文章数量:1565292
==> 学习汇总(持续更新)
==> 从零搭建后端基础设施系列(一)-- 背景介绍
一、BeanPostProcessor
字面上的意思是bean的后置处理器,什么意思呢?其实就是说,在bean的生命周期中,可以对它干什么。再简单点就是,bean初始化之前干点什么,之后又干点什么。
public interface BeanPostProcessor {
@Nullable
default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
//bean初始化之前,要干点什么或者什么都不干,但是干不干都要把人家给返回回去,不能一进来就出不去了~
return bean;
}
@Nullable
default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
//bean已经初始化完了,这时候你想干点什么或者什么都不干,和上面一样,都要给人家返回回去
return bean;
}
}
简单示例
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@Component
static class MyBeanPostProcessor1 implements BeanPostProcessor {
@Override
@Nullable
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("bean 初始化之前");
return bean;
}
@Override
@Nullable
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("bean 初始化之后");
return bean;
}
}
}
二、InstantiationAwareBeanPostProcessor
字面上的意思是实例化bean后置处理器,什么意思呢?就是说你可以在bean实例化前后做一些事情。注意,是先实例化才到初始化的!
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
//the bean object to expose instead of a default instance of the target bean, or null to proceed with default instantiation
@Nullable
default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
//如果什么都不做,返回null,代表走默认实例化的逻辑
//如果在这里做了什么,那么就返回你指定实例化逻辑产生的对象
return null;
}
//true if properties should be set on the bean,false if property population should be skipped. Normal implementations should return true
default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
//实例化完了之后,如果这里返回true,代表这个bean的属性会被正常set进去,如果是false,那么就会跳过,spring给的建议是一般都要返回true。
return true;
}
//the actual property values to apply to the given bean (can be the passed-in PropertyValues instance), or null which proceeds with the existing properties but specifically continues with a call to postProcessPropertyValues
@Nullable
default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
throws BeansException {
//null,相当于什么都没做
//返回不是null,相当于将返回的变量值替换原来的变量赋值
return null;
}
//deprecated as of 5.1, in favor of {@link #postProcessProperties(PropertyValues, Object, String)}
@Deprecated
@Nullable
default PropertyValues postProcessPropertyValues(
PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
return pvs;
}
}
简单示例
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@Component
static class MyBeanPostProcessor2 implements InstantiationAwareBeanPostProcessor {
@Override
@Nullable
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("bean 初始化之前");
return bean;
}
@Override
@Nullable
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("bean 初始化之后");
return bean;
}
@Override
@Nullable
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
System.out.println("bean 实例化之前");
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
System.out.println("bean 实例化之后");
return true;
}
@Override
@Nullable
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
throws BeansException {
System.out.println("bean 变量处理");
return null;
}
}
}
三、SmartInstantiationAwareBeanPostProcessor
字面意思就是智能实例化bean后置处理器,什么意思呢?其实就是比InstantiationAwareBeanPostProcessor多三个接口,在bean实例化之前,多做一些事情而已。
public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {
//return the type of the bean, or null if not predictable
@Nullable
default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
//实例化之前先预测bean的类型??(我也不是很懂它的用途,下篇文章讲例子的时候再顺带解决)
return null;
}
//return the candidate constructors, or null if none specified
@Nullable
default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName)
throws BeansException {
//说白了就是可以决定用哪个构造器来实例化这个bean
return null;
}
//return the object to expose as bean reference typically with the passed-in bean instance as default)
default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
//这个就牛逼了,可以解决循环引用的问题,例如A引用了B,B引用了A,A实例化的时候,需要先实例化B,B实例化的时候又需要去实例化A,当B->实例化A的时候,就会走到这个方法,提前把A的引用暴露出去,这时候B就可以完成实例化,最后A也完成的实例化。
return bean;
}
简单示例
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@Component
static class MyBeanPostProcessor3 implements SmartInstantiationAwareBeanPostProcessor {
@Override
@Nullable
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("bean 初始化之前");
return bean;
}
@Override
@Nullable
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("bean 初始化之后");
return bean;
}
@Override
@Nullable
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
System.out.println("bean 实例化之前");
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
System.out.println("bean 实例化之后");
return true;
}
@Override
@Nullable
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
throws BeansException {
System.out.println("bean 变量处理");
return null;
}
@Override
@Nullable
public Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
System.out.println("预测 bean 类型");
return null;
}
@Override
@Nullable
public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName)
throws BeansException {
System.out.println("选择构造器");
return null;
}
@Override
public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
System.out.println("提前暴露引用");
return bean;
}
}
@Component
static class B {
@Autowired
A a;
}
@Component
static class A {
@Autowired
B b;
}
}
四、DestructionAwareBeanPostProcessor
字面上的意思就是销毁bean后置处理器,什么意思呢?就是销毁bean之前,你还想干嘛。
public interface DestructionAwareBeanPostProcessor extends BeanPostProcessor {
void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;
//return true} if postProcessBeforeDestruction is supposed to be called for this bean instance eventually, or false if not needed
default boolean requiresDestruction(Object bean) {
//默认是true,也就是需要销毁之前做点什么,会调用postProcessBeforeDestruction
//如果是false,那么就不会调用
return true;
}
简单示例
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@Component
static class MyBeanPostProcessor4 implements DestructionAwareBeanPostProcessor {
@Override
@Nullable
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("bean 初始化之前");
return bean;
}
@Override
@Nullable
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("bean 初始化之后");
return bean;
}
@Override
public void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException {
System.out.println(beanName + " 销毁之前");
}
@Override
public boolean requiresDestruction(Object bean) {
return true;
}
}
}
五、MergedBeanDefinitionPostProcessor
字面上意思是合并bean定义后置处理器,什么意思呢?目前我也还不太懂~,哈哈,等下一篇讲例子再详细说一下。
public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {
void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);
default void resetBeanDefinition(String beanName) {
//目前还不知道是干嘛用的,怎么用的
}
简单示例
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@Component
static class MyBeanPostProcessor5 implements MergedBeanDefinitionPostProcessor {
@Override
@Nullable
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("bean 初始化之前");
return bean;
}
@Override
@Nullable
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("bean 初始化之后");
return bean;
}
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
System.out.println("bean 合并");
}
@Override
public void resetBeanDefinition(String beanName) {
System.out.println("重置 bean定义");
}
}
}
六、总结
spring中带Processor的类还有很多,但是本质上都和这几个差不多,都是用来处理XXX在XXX的时候XXX。大白话讲就是,在A创建/发生/实例化/初始化之前,你想干什么。有点类似AOP的思想,在中间横叉一道。详细的场景及使用例子,等整理好另开一篇文章讲解。
本文标签: 例子功能SpringBootBeanPostProcessor
版权声明:本文标题:springboot之BeanPostProcessor功能及例子(一) 内容由热心网友自发贡献,该文观点仅代表作者本人, 转载请联系作者并注明出处:https://www.elefans.com/xitong/1726873922a1088131.html, 本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容,一经查实,本站将立刻删除。
发表评论