Spring的@PostConstruct和Aware接口实现原理

最新推荐文章于 2023-02-12 20:05:57 发布
最新推荐文章于 2023-02-12 20:05:57 发布
阅读量474 收藏 1
点赞数
分类专栏： java
原文链接：https://www.jianshu.com/p/62f7545a3e1b
版权

@PostConstruct是由CommonAnnotationBeanPostProcessor类实现的。

一、CommonAnnotationBeanPostProcessor是什么时候加载进去的呢？
我们首先看到CommonAnnotationBeanPostProcessor是spring context下的包，说明是spring自带的类。我们就大胆猜想，它是spring的创世纪类，即internal类。我们怎么验证呢？我们知道spring自带的创世纪类是在下面的构造方法里面：

public AnnotationConfigApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
new AnnotatedBeanDefinitionReader的时候会调用：

AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
里面有段代码会添加CommonAnnotationBeanPostProcessor类：

// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
二、CommonAnnotationBeanPostProcessor怎么和@PostConstruct关联上的？
首先看下该类的无参构造方法：

public CommonAnnotationBeanPostProcessor() {
setOrder(Ordered.LOWEST_PRECEDENCE - 3);
setInitAnnotationType(PostConstruct.class);
setDestroyAnnotationType(PreDestroy.class);
ignoreResourceType(“javax.xml.ws.WebServiceContext”);
}
这个无参构造方法肯定会在实例化该类的时候被调用。
看到里面有PostConstruct注解了吧。在详细看下setInitAnnotationType方法：

public void setInitAnnotationType(Class<? extends Annotation> initAnnotationType) {
this.initAnnotationType = initAnnotationType;
}
会把PostConstruct.class赋值给initAnnotationType属性。这个属性所属的类为InitDestroyAnnotationBeanPostProcessor，可以看到它实现了BeanPostProcessor接口。

我们就很容易猜想了，PostConstruct肯定在BeanPostProcessor的两个拓展方法其中一个被执行了。

三、验证BeanPostProcessor中哪个拓展方法调用了@PostConstruct注解
大不了我们看下InitDestroyAnnotationBeanPostProcessor类的这两个方法的实现：

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
try {
metadata.invokeInitMethods(bean, beanName);
}
catch (InvocationTargetException ex) {
throw new BeanCreationException(beanName, “Invocation of init method failed”, ex.getTargetException());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, “Failed to invoke init method”, ex);
}
return bean;
}

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    return bean;
}

很明显postProcessAfterInitialization这个方法的实现直接返回bean，没做任何处理，排除。我们看下postProcessBeforeInitialization方法。里面有个findLifecycleMetadata方法得到metadata，然后调用invokeInitMethods。我们可以猜想出来，metadata肯定是一个method反射对象，然后通过反射调用该方法。是不是有可能findLifecycleMetadata方法，返回的就是@PostConstruct注解的方法呢？

private LifecycleMetadata findLifecycleMetadata(Class<?> clazz) {
if (this.lifecycleMetadataCache == null) {
// Happens after deserialization, during destruction…
return buildLifecycleMetadata(clazz);
}
// Quick check on the concurrent map first, with minimal locking.
LifecycleMetadata metadata = this.lifecycleMetadataCache.get(clazz);
if (metadata == null) {
synchronized (this.lifecycleMetadataCache) {
metadata = this.lifecycleMetadataCache.get(clazz);
if (metadata == null) {
metadata = buildLifecycleMetadata(clazz);
this.lifecycleMetadataCache.put(clazz, metadata);
}
return metadata;
}
}
return metadata;
}
核心方法在buildLifecycleMetadata：

private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
final boolean debug = logger.isDebugEnabled();
LinkedList initMethods = new LinkedList();
LinkedList destroyMethods = new LinkedList();
Class<?> targetClass = clazz;

    do {
        final LinkedList<LifecycleElement> currInitMethods = new LinkedList<LifecycleElement>();
        final LinkedList<LifecycleElement> currDestroyMethods = new LinkedList<LifecycleElement>();

        ReflectionUtils.doWithLocalMethods(targetClass, new ReflectionUtils.MethodCallback() {
            @Override
            public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
                if (initAnnotationType != null) {
                    if (method.getAnnotation(initAnnotationType) != null) {
                         // PostConstruct 赋值给了initAnnotationType，只要用@PostConstruct修饰的方法，必然会进来。
                        LifecycleElement element = new LifecycleElement(method);
                        currInitMethods.add(element);
                        if (debug) {
                            logger.debug("Found init method on class [" + clazz.getName() + "]: " + method);
                        }
                    }
                }
                if (destroyAnnotationType != null) {
                    if (method.getAnnotation(destroyAnnotationType) != null) {
                        currDestroyMethods.add(new LifecycleElement(method));
                        if (debug) {
                            logger.debug("Found destroy method on class [" + clazz.getName() + "]: " + method);
                        }
                    }
                }
            }
        });

        initMethods.addAll(0, currInitMethods);
        destroyMethods.addAll(currDestroyMethods);
        targetClass = targetClass.getSuperclass();
    }
    while (targetClass != null && targetClass != Object.class);

    return new LifecycleMetadata(clazz, initMethods, destroyMethods);
}

看到关键字ReflectionUtils.doWithLocalMethods(class,() -> doWith)了吗？遍历class所有的method，执行doWith方法。而doWith方法里面出现了最关键的initAnnotationType。是不是关联上了第二节说的那个方法了：

public void setInitAnnotationType(Class<? extends Annotation> initAnnotationType) {
// PostConstruct 赋值给了initAnnotationType
this.initAnnotationType = initAnnotationType;
}
最终，bean class所有用@PostConstruct注解修饰的方法，都会被返回给第三节中的findLifecycleMetadata方法。如下：

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
try {
metadata.invokeInitMethods(bean, beanName);
}
catch (InvocationTargetException ex) {
throw new BeanCreationException(beanName, “Invocation of init method failed”, ex.getTargetException());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, “Failed to invoke init method”, ex);
}
return bean;
}
我们看下metadata.invokeInitMethods方法。

public void invokeInitMethods(Object target, String beanName) throws Throwable {
Collection initMethodsToIterate =
(this.checkedInitMethods != null ? this.checkedInitMethods : this.initMethods);
if (!initMethodsToIterate.isEmpty()) {
boolean debug = logger.isDebugEnabled();
for (LifecycleElement element : initMethodsToIterate) {
if (debug) {
logger.debug(“Invoking init method on bean '” + beanName + "’: " + element.getMethod());
}
element.invoke(target);
}
}
}
element.invoke(target)不就是method.invoke(object)嘛~

四、知道@PostConstruct怎么被调用了，那它什么时候被调用呢？
上节我们已经知道了@PostConstruct被类CommonAnnotationBeanPostProcessor的构造函数添加进去的，该类继承了InitDestroyAnnotationBeanPostProcessor。而它又实现了BeanPostProcessor接口，并且实现在postProcessBeforeInitialization方法里面。

我们都知道postProcessBeforeInitialization方法是在doCreatedBean的initializeBean的applyBeanPostProcessorsBeforeInitialization方法里面。如下：

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

    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessBeforeInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}

beanProcessor.postProcessBeforeInitialization方法，可不就有CommonAnnotationBeanPostProcessor嘛~因为它是spring的创世纪类，由第一节中的spring自动加载进去。

所以我们这里可以知道初始化bean的时候（参考initializeBean方法的实现），那几个初始化方法的执行顺序了。

invokeAwareMethods -> postProcessBeforeInitialization(ApplicationContextAwareProcessor会执行剩下的aware方法) -> afterPropertiesSet -> initMethod -> postProcessAfterInitialization(AOP)

Spring的Aware接口实现原理
aware其实就是spring的回调方法，用来在某一个生命周期阶段，调用用户的回调方法。

比如：我们创建一个bean实现ApplicationContextAware接口，该接口只有一个方法：setApplicationContext。那么我们的bean既然实现了该接口，必须重写该方法，这个时候我们就可以在这个bean里面定义一个容器，来接收spring回调给我们的ApplicationContext容器。这样，咱们就可以拿到整个spring容器了。

再比如：我们创建一个bean实现BeanNameAware接口，那么spring会在特殊生命周期阶段回调咱们的bean的setBeanName。我们同样也可以定义一个String成员属性来接收这个beanName。

所以，aware接口给了程序员可以让spring回调我们业务的口子。比如：我们自己实现一个demoAware。由于demoAware并没有被spring预先硬编码进去，所以想要spring回调demoAware的实现类，我们可以看考ApplicationContextAwareProcessor。咱们可以实现BeanPostProcessor，在postProcessBeforeInitialization或者postProcessAfterInitialization的方法里面，调用invokeAwareInterfaces方法。是不是很灵活！！！

转自：https://www.jianshu.com/p/62f7545a3e1b

阿良@
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
盘点10个Spring实际开发中最常用扩展点
2301_76607156的博客
03-23 643
Spring的核心思想就是容器，具有控制反转（IoC）和面向切面（AOP）两大核心；更是封装了Spring，遵循约定大于配置，加上自动装配的机制。很多时候我们只要引用了一个依赖，几乎是零配置就能完成一个功能的装配。一个高级开发者如果想精通Spring，不能仅仅局限于对框架的使用，而是需要对Spring进行深入理解，了解Spring对Bean是如何进行管理的，熟知Spring的各个扩展点。在网上搜索Spring扩展点，发现很少有博文说的很全的，只有一些常用的扩展点的说明。
spring boot 启动加载 CommandLineRunner @PostConstruct
热门推荐
我是程序媛，我骄傲
02-25 1万+
spring boot 启动加载 CommandLineRunner 在项目中，经常有这样的需求，我们需要在项目启动完立即初始化一些数据（比如缓存等），以便后面调用使用。spring boot可以通过CommandLineRunner接口实现启动加载功能。 新建一个Java文件，类需要用Component声明下，需要实现CommandLineRunner接口，然后重写run方法，在run方法内编写...
@PostConstruct与afterPropertiesSet
qq_37436172的博客
01-31 2676
PostConstract和afterPropertiesSet都是在bean的属性注入完毕之后才执行，都可以用来进行bean 的初始化@PostConstract是通过BeanPostProcessor的前置方法中执行的（我们也可以参考这个自定义注解实现），略早于通过继承InitializingBean的afterPropertiesSet初始化方法。
Springboot扩展点之@PostConstruct
凡夫编程
02-12 5668
@postContruct全限定类名是javax.annotation.PostConstruct，可以看出来其本身不是Spring定义的注解，但是Spring提供了具体的实现，所以这篇文章主要分析的是@PostConstruct在Spring项目开发中的功能特性、实现方式和基本工作原理。
Spring中11个最常用的扩展点
meser88的博客
10-13 1068
前言 最近越来越多的读者认可我的文章，还是件挺让人高兴的事情。有些读者私信我说希望后面多分享spring方面的文章，这样能够在实际工作中派上用场。正好我对spring源码有过一定的研究，并结合我这几年实际的工作经验，把spring中我认为不错的知识点总结一下，希望对您有所帮助。 一 如何获取spring容器对象 1.实现BeanFactoryAware接口 @Service public class PersonService implements BeanFactoryAware { p
@PostConstruct注解用来获取springbean对象.txt
06-07
获取springbean对象
java @PostConstruct和@PreConstruct注解
06-14
java @PostConstruct和@PreConstruct注解整理.........
Spring实战之使用@POSTConstruct和@PreDestroy定制生命周期行为操作示例
08-25
主要介绍了Spring实战之使用@POSTConstruct和@PreDestroy定制生命周期行为操作,结合实例形式详细分析了Spring使用@POSTConstruct和@PreDestroy定制生命周期相关接口定义、配置与功能实现技巧,需要的朋友可以参考下
SpringBoot @PostConstruct原理用法解析
08-18
主要介绍了SpringBoot @PostConstruct原理用法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java注解@PostConstruct使用及相关原理分析
kolloge的博客
11-04 3724
Java注解PostConstruct原理及相关问题分析，Spring容器中同类使用多PostConstruct顺序不固定问题等
springmvc学习一初始化源码
小小少年的博客
10-08 386
这两天，学习了一下springmvc的源码，主要是学习了启动和调用的流程，主要分以下两部分来记录笔记 1.启动流程 2.调用流程 springmvc源码，先概括的说一下 1、初始化handlerMapping对象、初始化handlerAdapter对象；在初始化handlerMapping对象的时候，会解析所有的bean，将controller和对应的URL存入到对应的map集合中 2、在调用的时候，会调用到org.springframework.web.servlet.DispatcherServlet#
Spring @Autowird注解和@Resouce注解源码分析
持之以恒
07-28 456
从使用上来看@Autowird和@Resource注解的区别 两个注解都可用于属性或者方法上的注入；@Autowired是默认按照类型装配， @Resource默认是按照名称装配 从提供来源看： @Autowired是由Spring提供 @Resource是有java提供，在包javax.annotation下 从spring处理源看： @Autowired是由AutowiredAnnotationBeanPostProcessor后处理器进行处理 @Resource是由CommonAnnotat
InitializingBean、BeanPostProcessor、init-method、@PostConstruct执行先后顺序
Asa_Prince的博客
06-29 8860
一、理论 @PostConstruct 注解好多人以为是Spring提供的。其实是Java自己的注解。该注解被用来修饰一个非静态的void（）方法。被@PostConstruct修饰的方法会在服务器加载Servlet的时候运行，并且只会被服务器执行一次。PostConstruct在构造函数之后执行，init（）方法之前执行。通常我们会是在Spring框架中使用到@PostConstruct注解 该注解的方法在整个Bean初始化中的执行顺序：Constructor(构造方法) -> @...
java postconstruct_spring框架中@PostConstruct的实现原理
weixin_39763640的博客
02-16 189
在spring项目经常遇到@PostConstruct注解，首先介绍一下它的用途: 被注解的方法，在对象加载完依赖注入后执行。此注解是在Java EE5规范中加入的，在Servlet生命周期中有一定作用，它通常都是一些初始化的操作，但初始化可能依赖于注入的其他组件，所以要等依赖全部加载完再执行。与之对应的还有@PreDestroy，在对象消亡之前执行，原理差不多，这里不做过多介绍。那么首先看下源码...
@PostConstruct注解原理解析
Meiko记录
01-22 1151
定义： @PostContruct注解，在方法上加该注解会在项目启动的时候执行该方法，也可以理解为在spring容器初始化的时候执行该方法。 从Java EE5规范开始，Servlet中增加了两个影响Servlet生命周期的注解，@PostConstruct和@PreDestroy，这两个注解被用来修饰一个非静态的void（）方法。 用法： @PostConstruct public void someMethod(){} 或者 public @...
spring InitializingBean init-method postConstruct 执行顺序
秋香的博客
02-19 7918
Spring 容器中的 Bean 是有生命周期的，Spring 允许在 Bean 在初始化完成后以及 Bean 销毁前执行特定的操作，常用的设定方式有以下三种：通过实现 InitializingBean/DisposableBean 接口来定制初始化之后/销毁之前的操作方法； 通过 元素的 init-method/destroy-method属性指定初始化之后 /销毁之前调用的操作方法； 在指定
Spring的@PostConstruct与ApplicationContextAware冲突问题
qq_32734365的博客
04-28 5599
1，背景 由于笔者希望在非Spring管理的类中使用Spring中的配置,故在项目类定义了如下工具类： @Component public class SpringUtils implements ApplicationContextAware { private static ApplicationContext applicationContext; @Overri
BeanPostProcessor及其子类,各种常用Aware接口,DisposableBean,InitializingBean,@PostConstruct,@PreDestroy执行顺序
溜金哇开呀酷裂的博客
01-04 698
先上结论 1-InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation... 2-SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors... Soldier 构造方法... 3-MergedBeanDefinitionPostP...
Spring中bean的生命周期
最新发布
04-27
4. 初始化：在Bean的所有属性都被赋值后，会调用Bean的初始化方法，可以通过@Bean注解、InitializingBean接口、@PostConstruct注解等方式来实现初始化方法。 5. 后处理器：在Bean的初始化方法执行完成后，Spring...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值