欧博在线:【Spring注解驱动开发】BeanPostProcessor在Spring底层是若何使用的?看完这篇我懂了!!

admin/2020-06-30/ 分类:科技/阅读:

写在前面

在《【String注解驱动开发】面试官再问你BeanPostProcessor的执行流程,就把这篇文章甩给他!》一文中,我们详细的先容了BeanPostProcessor的执行流程。那么,BeanPostProcessor在Spring底层是若何使用的?今天,我们就一起来探讨下Spring的源码,一探BeanPostProcessor在Spring底层的使用情况。

项目工程源码已经提交到GitHub:https://github.com/sunshinelyz/spring-annotation

BeanPostProcessor接口

我们先来看下BeanPostProcessor接口的源码,如下所示。

package org.springframework.beans.factory.config; import org.springframework.beans.BeansException; import org.springframework.lang.Nullable; public interface BeanPostProcessor { @Nullable default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } @Nullable default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { return bean; } } 

可以看到,在BeanPostProcessor接口中,提供了两个方式:postProcessBeforeInitialization()方式和postProcessAfterInitialization()方式。postProcessBeforeInitialization()方式会在bean初始化之前挪用,postProcessAfterInitialization()方式会在bean初始化之后挪用。接下来,我们就剖析下BeanPostProcessor接口在Spring中的实现。

注重:这里,我枚举几个BeanPostProcessor接口在Spring中的实现类,来让人人加倍清晰的明白BeanPostProcessor接口在Spring底层的应用。

ApplicationContextAwareProcessor类

org.springframework.context.support.ApplicationContextAwareProcessor是BeanPostProcessor接口的实现类,这个类的作用是可以向组件中注入IOC容器,大致的源码如下所示。

package org.springframework.context.support; import java.security.AccessControlContext; import java.security.AccessController; import java.security.PrivilegedAction; import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.beans.factory.config.EmbeddedValueResolver; import org.springframework.context.ApplicationContextAware; import org.springframework.context.ApplicationEventPublisherAware; import org.springframework.context.ConfigurableApplicationContext; import org.springframework.context.EmbeddedValueResolverAware; import org.springframework.context.EnvironmentAware; import org.springframework.context.MessageSourceAware; import org.springframework.context.ResourceLoaderAware; import org.springframework.lang.Nullable; import org.springframework.util.StringValueResolver; class ApplicationContextAwareProcessor implements BeanPostProcessor { /****************************省略N多行代码************************/ } 

这里,省略了源码的细节,只给出了类结构,感兴趣的小伙伴们可自行翻阅Spring源码举行查看,我这里的Spring版本为5.2.6.RELEASE。

那详细若何使用ApplicationContextAwareProcessor类向组件中注入IOC容器呢?别急,我用一个例子来说明下,信赖小伙伴们看完后会有一种豁然开朗的感受——哦,原来是它啊,我之前在项目中使用过的!

要想使用ApplicationContextAwareProcessor类向组件中注入IOC容器,我们就不得不提Spring中的另一个接口:ApplicationContextAware,若是需要向组件中注入IOC容器,可以使组件实现ApplicationContextAware接口。

例如,我们建立一个Employee类,使其实现ApplicationContextAware接口,此时,我们需要实现ApplicationContextAware接口的setApplicationContext()方式,在setApplicationContext()方式中有一个ApplicationContext类型的参数,这个就是IOC容器工具,我们可以在Employee类中界说一个ApplicationContext类型的成员变量,然后在setApplicationContext()方式中为这个成员变量赋值,此时就可以在Employee中的其他方式中使用ApplicationContext工具了,如下所示。

package io.mykit.spring.plugins.register.bean; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.stereotype.Component; /** * @author binghe * @version 1.0.0 * @description 测试ApplicationContextAware */ @Component public class Employee implements ApplicationContextAware { private ApplicationContext applicationContext; @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { this.applicationContext = applicationContext; } } 

看到这里,信赖不少小伙伴们都有一种很熟悉的感受:没错,我之前也在项目中使用过!是的,这就是BeanPostProcessor在Spring底层的一种使用场景。至于上面的案例代码为何会在setApplicationContext()方式中获取到ApplicationContext工具,这就是ApplicationContextAwareProcessor类的劳绩了!

接下来,我们就深入剖析下ApplicationContextAwareProcessor类。

我们先来看下ApplicationContextAwareProcessor类中对于postProcessBeforeInitialization()方式的实现,如下所示。

@Override @Nullable public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware || bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware || bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){ return bean; } AccessControlContext acc = null; if (System.getSecurityManager() != null) { acc = this.applicationContext.getBeanFactory().getAccessControlContext(); } if (acc != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareInterfaces(bean); return null; }, acc); } else { invokeAwareInterfaces(bean); } return bean; } 

在bean初始化之前,首先对当前bean的类型举行判断,若是当前bean的类型不是EnvironmentAware,不是EmbeddedValueResolverAware,不是ResourceLoaderAware,不是ApplicationEventPublisherAware,不是MessageSourceAware,也不是ApplicationContextAware,则直接返回bean。若是是上面类型中的一种类型,则最终会挪用invokeAwareInterfaces()方式,并将bean通报给invokeAwareInterfaces()方式。invokeAwareInterfaces()方式又是个什么鬼呢?我们继续看invokeAwareInterfaces()方式的源码,如下所示。

private void invokeAwareInterfaces(Object bean) { if (bean instanceof EnvironmentAware) { ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment()); } if (bean instanceof EmbeddedValueResolverAware) { ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver); } if (bean instanceof ResourceLoaderAware) { ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext); } if (bean instanceof ApplicationEventPublisherAware) { ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext); } if (bean instanceof MessageSourceAware) { ((MessageSourceAware) bean).setMessageSource(this.applicationContext); } if (bean instanceof ApplicationContextAware) { ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext); } } 

可以看到invokeAwareInterfaces()方式的源码比较简单,就是判断当前bean属于哪种接口类型,则将bean强转为哪种接口类型的工具,然后挪用接口的方式,将响应的参数通报到接口的方式中。这里,我们在建立Employee类时,实现的是ApplicationContextAware接口,以是,在invokeAwareInterfaces()方式中,会执行如下的逻辑代码。

if (bean instanceof ApplicationContextAware) { ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext); } 

我们可以看到,此时会将this.applicationContext通报到ApplicationContextAware接口的setApplicationContext()方式中。以是,我们在Employee类中的setApplicationContext()方式中就可以直接接收到ApplicationContext工具了。

我们也可以在IDEA中通过Debug的形式来看一下程序的执行历程,此时我们在Employee类的setApplicationContext()方式上设置断点,如下所示。

接下来,我们以Debug的方式来运行SpringBeanTest类的testAnnotationConfig2()方式,运行后的效果如下图所示。

在IDEA的左下角可以看到方式的挪用客栈,通过对方式挪用栈的剖析,我们看到在执行Employee类中的setApplicationContext()方式之前,执行了ApplicationContextAwareProcessor类的invokeAwareInterfaces方式,如下所示。

当我们点击方式挪用栈中的invokeAwareInterfaces()方式时,代码的执行定位到如下一行代码。

((ApplicationContextAware) bean).setApplicationContext(this.applicationContext); 

和我们之前剖析的逻辑一致。

BeanValidationPostProcessor类

org.springframework.validation.beanvalidation.BeanValidationPostProcessor类主要是用来为bean举行校验操作,当我们建立bean,并为bean赋值后,我们可以通过BeanValidationPostProcessor类为bean举行校验操作。BeanValidationPostProcessor类的结构如下所示。

package org.springframework.validation.beanvalidation; import java.util.Iterator; import java.util.Set; import javax.validation.ConstraintViolation; import javax.validation.Validation; import javax.validation.Validator; import javax.validation.ValidatorFactory; import org.springframework.aop.framework.AopProxyUtils; import org.springframework.beans.BeansException; import org.springframework.beans.factory.BeanInitializationException; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.lang.Nullable; import org.springframework.util.Assert; public class BeanValidationPostProcessor implements BeanPostProcessor, InitializingBean { /*******************************省略N行代码**********************************/ } 

这里,我们也来看看postProcessBeforeInitialization()方式和postProcessAfterInitialization()方式的实现,如下所示。

@Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { if (!this.afterInitialization) { doValidate(bean); } return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { if (this.afterInitialization) { doValidate(bean); } return bean; } 

可以看到,在postProcessBeforeInitialization()方式和postProcessAfterInitialization()方式中的主要逻辑都是挪用doValidate()方式对bean举行校验,只不过在两个方式中都会对afterInitialization这个boolean类型的成员变量举行判断,若是afterInitialization的值为false,则在postProcessBeforeInitialization()方式中挪用doValidate()方式对bean举行校验;若是afterInitialization的值为true,则在postProcessAfterInitialization()方式中挪用doValidate()方式对bean举行校验。

InitDestroyAnnotationBeanPostProcessor类

org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor类主要用来处置@PostConstruct注解和@PreDestroy注解。

例如,我们之前建立的Cat类中就使用了@PostConstruct注解和@PreDestroy注解,如下所示。

package io.mykit.spring.plugins.register.bean; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; /** * @author binghe * @version 1.0.0 * @description 测试@PostConstruct注解和@PreDestroy注解 */ public class Cat { public Cat(){ System.out.println("Cat类的组织方式..."); } public void init(){ System.out.println("Cat的init()方式..."); } @PostConstruct public void postConstruct(){ System.out.println("Cat的postConstruct()方式..."); } @PreDestroy public void preDestroy(){ System.out.println("Cat的preDestroy()方式..."); } public void destroy(){ System.out.println("Cat的destroy()方式..."); } } 

那么,在Cat类中使用了 @PostConstruct注解和@PreDestroy注解来标注方式,Spring怎么就知道什么时候执行 @PostConstruct注解标注的方式,什么时候执行@PreDestroy标注的方式呢?这就要归功于InitDestroyAnnotationBeanPostProcessor类的实现了。

接下来,我们也通过Debug的方式来跟进下代码的执行流程。首先,在Cat类的postConstruct()方式上打上断点,如下所示。

接下来,我们以Debug的方式运行BeanLifeCircleTest类的testBeanLifeCircle04()方式,效果如下所示。

我们照样带着问题来剖析,Spring怎么就能定位到使用@PostConstruct注解标注的方式呢?通过剖析方式的挪用栈我们发现了在进入使用@PostConstruct注解标注的方式之前,Spring挪用了InitDestroyAnnotationBeanPostProcessor类的postProcessBeforeInitialization()方式,如下所示。

在InitDestroyAnnotationBeanPostProcessor类的postProcessBeforeInitialization()方式中,首先会找到bean中有关生命周期的注解,好比@PostConstruct注解等,找到这些注解之后,则将这些信息赋值给LifecycleMetadata类型的变量metadata,之后挪用metadata的invokeInitMethods()方式,通过反射来挪用标注了@PostConstruct注解的方式。这就是为什么标注了@PostConstruct注解的方式被Spring执行。

AutowiredAnnotationBeanPostProcessor类

org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor类主要是用于处置标注了@Autowired注解的变量或方式。

Spring为何能够自动处置标注了@Autowired注解的变量或方式,就交给小伙伴们自行剖析了。人人可以写一个测试方式并通过方式挪用客栈来剖析AutowiredAnnotationBeanPostProcessor类的源码,从而找到自己想要的谜底。

好了,咱们今天就聊到这儿吧!别忘了给个在看和转发,让更多的人看到,一起学习一起提高!!

项目工程源码已经提交到GitHub:https://github.com/sunshinelyz/spring-annotation

写在最后

若是以为文章对你有点辅助,请微信搜索并关注「 冰河手艺 」微信民众号,跟冰河学习Spring注解驱动开发。民众号回复“spring注解”关键字,领取Spring注解驱动开发焦点知识图,让Spring注解驱动开发不再渺茫。

,

欧博亚洲官网开户网址

欢迎进入欧博亚洲官网开户网址(Allbet Game):www.aLLbetgame.us,欧博官网是欧博集团的官方网站。欧博官网开放Allbet注册、Allbe代理、Allbet电脑客户端、Allbet手机版下载等业务。

TAG:
阅读:
广告 330*360
广告 330*360

热门文章

HOT NEWS
  • 周榜
  • 月榜
Sunbet_进入申博sunbet官网
微信二维码扫一扫
关注微信公众号
新闻自媒体 Copyright © 2002-2019 Sunbet 版权所有
二维码
意见反馈 二维码