0
0

Spring常用扩展点

文章目录

一、前言介绍

1、常用扩展点

我们知道，IOC（控制反转） 和 AOP（面向切面编程）是spring的基石。除此之外，spring的扩展能力非常强。由于这个优势的存在，让spring拥有强大的包容能力，让很多第三方应用能够轻松投入spring的怀抱。比如：rocketmq、mybatis、redis等。

Spring中最常用的11个扩展点

  • 自定义拦截器
  • Spring容器对象获取
  • 全局异常处理
  • 类型转换器
  • 导入配置
  • 项目启动配置
  • BeanDefinition的修改
  • Bean前后初始化
  • 初始化方法
  • 容器关闭
  • 自定义作用域

2、Spring所有扩展接口

Spring的核心思想就是容器，内部想要把自动装配玩的转，就必须要了解spring对于bean的构造生命周期以及各个扩展接口。当然业务代码也能合理利用这些扩展点写出更加漂亮的代码。这里总结了几乎Spring & Springboot所有的扩展接口，以及各个扩展点的使用场景。下面是一个bean在spring内部从被加载到最后初始化完成所有可扩展点的顺序调用图。

在这里插入图片描述

二、常用扩展点详解

1、自定义拦截器

1.1 介绍

spring mvc拦截器与spring拦截器相比，它里面能够获取

HttpServletRequest

和

HttpServletResponse

等web对象实例。
可以参考：springBoot整合JWT实现前后端Token验证

spring mvc拦截器的顶层接口是：

HandlerInterceptor

，包含三个方法：

  • preHandle目标方法执行前执行
  • postHandle 目标方法执行后执行
  • afterCompletion请求完成时执行

一般情况会用HandlerInterceptor接口的实现类HandlerInterceptorAdapter类。假如有权限认证、日志、统计的场景，可以使用该拦截器。

1.2 代码详情

首先继承

HandlerInterceptorAdapter

类定义拦截器

publicclassAuthInterceptorextendsHandlerInterceptorAdapter{@OverridepublicbooleanpreHandle(HttpServletRequest request,HttpServletResponse response,Object handler)throwsException{String requestUrl = request.getRequestURI();if(checkAuth(requestUrl)){returntrue;}returnfalse;}privatebooleancheckAuth(String requestUrl){System.out.println("===权限校验===");returntrue;}}

然后将该拦截器注册到spring容器

@ConfigurationpublicclassWebAuthConfigextendsWebMvcConfigurerAdapter{@BeanpublicAuthInterceptorgetAuthInterceptor(){returnnewAuthInterceptor();}@OverridepublicvoidaddInterceptors(InterceptorRegistry registry){
        registry.addInterceptor(newAuthInterceptor());}}

最后在请求接口时spring mvc通过该拦截器，能够自动拦截该接口，并且校验权限。

2、获取Spring容器对象

借鉴参考：Spring事件监听

在我们日常开发中，除了通过

@Autowired

注解获取Bean外，有时候我们会经常需要从Spring容器中手动获取Bean，下面是几种手动获取Bean的方法

2.1 BeanFactoryAware接口

实现

BeanFactoryAware

接口，然后重写

setBeanFactory

方法，就能从该方法中获取到spring容器对象

@ServicepublicclassPersonServiceimplementsBeanFactoryAware{privateBeanFactory beanFactory;@OverridepublicvoidsetBeanFactory(BeanFactory beanFactory)throwsBeansException{this.beanFactory = beanFactory;}publicvoidadd(){Person person =(Person) beanFactory.getBean("person");}}

2.2 ApplicationContextAware接口

实现

ApplicationContextAware

接口，然后重写

setApplicationContext

方法，也能从该方法中获取到spring容器对象

@ServicepublicclassPersonService2implementsApplicationContextAware{privateApplicationContext applicationContext;@OverridepublicvoidsetApplicationContext(ApplicationContext applicationContext)throwsBeansException{this.applicationContext = applicationContext;}publicvoidadd(){Person person =(Person) applicationContext.getBean("person");}}

2.3 ApplicationListener接口

@ServicepublicclassPersonService3implementsApplicationListener<ContextRefreshedEvent>{privateApplicationContext applicationContext;@OverridepublicvoidonApplicationEvent(ContextRefreshedEvent event){
        applicationContext = event.getApplicationContext();}publicvoidadd(){Person person =(Person) applicationContext.getBean("person");}}

3、全局异常处理

参考：Spring Boot后端接口规范

我们在开发接口时，如果出现异常，为了给用户一个更友好的提示，必须在每一个接口处捕获异常，但是随着接口数量增加，代码量和可维护性也随之增加，因此全局异常捕获就派上用场了：

RestControllerAdvice

。只需在

handleException

方法中处理异常情况，业务接口中可以放心使用，不再需要捕获异常（程序统一处理了）

@RestControllerAdvicepublicclassGlobalExceptionHandler{@ExceptionHandler(Exception.class)publicStringhandleException(Exception e){if(e instanceofArithmeticException){return"数据异常";}if(e instanceofException){return"服务器内部异常";}
        retur null;}}

4、类型转换器

4.1 介绍

spring目前支持3中类型转换器

  • **Converter<S,T>**：将 S 类型对象转为 T 类型对象
  • **ConverterFactory<S, R>**：将 S 类型对象转为 R 类型及子类对象
  • GenericConverter：它支持多个source和目标类型的转化，同时还提供了source和目标类型的上下文，这个上下文能让你实现基于属性上的注解或信息来进行类型转换

常用的日期类转换可以参考：Java8 日期时间类整理

4.2 简单实战

通过自定义Converter，可以转换简单的参数，如下，有一个 UserDto 类，表示用户信息

publicclassUserDto{//用户名privateString name;//年龄privateInteger age;//省略getter、setter方法}

要求后台所有接口接受

UserDto

数据时，参数的值格式为：

name,age

@RequestMapping("/convert/test1")publicUserDtotest1(@RequestParam("user")UserDto user){System.out.println("name："+ user.getName());System.out.println("age："+ user.getAge());return user;}

SpringMVC 中提供了一个接口

org.springframework.core.convert.converter.Converter

，这个接口用来将一种类型转换为另一种类型，调用后端接口的时候，http 传递的参数都是字符串类型的，但是后端却可以使用 Integer、Double 等其他类型来接收，这就是

Converter

实现的。Spring 内部也提供了很多默认的实现，用于各种类型转换

@FunctionalInterfacepublicinterfaceConverter<S,T>{/**
  * 将source转换为目标T类型
  */@NullableTconvert(S source);}
  • 代码如下，添加一个配置类，实现WebMvcConfigurer接口
  • 重写addFormatters方法，在这个方法中添加一个自定义的Converter，实现其 convert 方法，将name,age格式的字符串转换为 UserDto 对象返回
@ConfigurationpublicclassMvcConfigimplementsWebMvcConfigurer{@OverridepublicvoidaddFormatters(FormatterRegistry registry){
        registry.addConverter(newConverter<String,UserDto>(){@OverridepublicUserDtoconvert(String source){if(source ==null){returnnull;}String[] split = source.split(",");String name = split[0];Integer age =Integer.valueOf(split[1]);returnnewUserDto(name, age);}});}}

最后访问

/convert/test1?user=ready,1

即可成功获取数据

5、配置的导入

5.1 介绍

参考：Spring容器加入bean的几种方式

有时我们需要在某个配置类中引入另外一些类，被引入的类也加到spring容器中。这时可以使用

@Import

注解完成这个功能。通过源码会发现，引入的类支持三种不同类型，将普通类和@Configuration注解的配置类分开讲解，列了四种不同类型

  • 普通类
  • @Configuration注解
  • ImportSelector接口类
  • ImportBeanDefinitionRegistrar接口类

5.2 普通类

这种引入方式是最简单的，被引入的类会被实例化bean对象

publicclassA{}@Import(A.class)@ConfigurationpublicclassTestConfiguration{}

通过

@Import

注解引入A类，spring就能自动实例化A对象，然后在需要使用的地方通过

@Autowired

注解注入即可，不用加

@Bean

注解也能实例化bean

5.3 配置类

这种引入方式是最复杂的，因为

@Configuration

注解还支持多种组合注解，比如：

  • @Import
  • @ImportResource
  • @PropertySource等

通过@Import注解引入@Configuration注解的配置类，会把该配置类相关

@Import

、

@ImportResource

、

@PropertySource

等注解引入的类进行递归，一次性全部引入。

publicclassA{}publicclassB{}@Import(B.class)@ConfigurationpublicclassAConfiguration{@BeanpublicAa(){returnnewA();}}@Import(AConfiguration.class)@ConfigurationpublicclassTestConfiguration{}

5.4 ImportSelector

这种引入方式需要实现

ImportSelector

接口，好处是

selectImports

方法返回的是数组，意味着可以同时引入多个类，还是非常方便的

publicclassAImportSelectorimplementsImportSelector{privatestaticfinalString CLASS_NAME ="com.sue.cache.service.test13.A";publicString[]selectImports(AnnotationMetadata importingClassMetadata){returnnewString[]{CLASS_NAME};}}@Import(AImportSelector.class)@ConfigurationpublicclassTestConfiguration{}

5.5 ImportBeanDefinitionRegistrar

种引入方式需要实现

ImportBeanDefinitionRegistrar

接口，这种方式是最灵活的，能在

registerBeanDefinitions

方法中获取到

BeanDefinitionRegistry

容器注册对象，可以手动控制BeanDefinition的创建和注册。

publicclassAImportBeanDefinitionRegistrarimplementsImportBeanDefinitionRegistrar{@OverridepublicvoidregisterBeanDefinitions(AnnotationMetadata importingClassMetadata,BeanDefinitionRegistry registry){RootBeanDefinition rootBeanDefinition =newRootBeanDefinition(A.class);
        registry.registerBeanDefinition("a", rootBeanDefinition);}}@Import(AImportBeanDefinitionRegistrar.class)@ConfigurationpublicclassTestConfiguration{}

6、项目启动时

有时候我们需要在项目启动时定制化一些附加功能，比如：加载一些系统参数、完成初始化、预热本地缓存等，该怎么办呢？好消息是springboot提供了：

  • CommandLineRunner
  • ApplicationRunner

这两个接口帮助我们实现以上需求。它们的用法很简单的，以

ApplicationRunner

接口为例：

@ComponentpublicclassTestRunnerimplementsApplicationRunner{@AutowiredprivateLoadDataService loadDataService;publicvoidrun(ApplicationArguments args)throwsException{
        loadDataService.load();}}

实现

ApplicationRunner

接口，重写

run

方法，在该方法中实现自己定制化需求。如果项目中有多个类实现了ApplicationRunner接口，他们的执行顺序要怎么指定呢？答案是使用

@Order(n)

注解，n的值越小越先执行。当然也可以通过

@Priority

注解指定顺序。

7、修改BeanDefinition

Spring IOC在实例化Bean对象之前，需要先读取Bean的相关属性，保存到

BeanDefinition

对象中，然后通过BeanDefinition对象，实例化Bean对象。如果想修改BeanDefinition对象中的属性，该怎么办呢？我们可以实现

BeanFactoryPostProcessor

接口

在

postProcessBeanFactory

方法中，可以获取

BeanDefinition

的相关对象，并且修改该对象的属性

@ComponentpublicclassMyBeanFactoryPostProcessorimplementsBeanFactoryPostProcessor{@OverridepublicvoidpostProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory)throwsBeansException{DefaultListableBeanFactory defaultListableBeanFactory =(DefaultListableBeanFactory) configurableListableBeanFactory;BeanDefinitionBuilder beanDefinitionBuilder =BeanDefinitionBuilder.genericBeanDefinition(User.class);
        beanDefinitionBuilder.addPropertyValue("id",123);
        beanDefinitionBuilder.addPropertyValue("name","shawn");
        defaultListableBeanFactory.registerBeanDefinition("user", beanDefinitionBuilder.getBeanDefinition());}}

8、初始化Bean前后

有时候需要在初始化Bean前后，实现一些自己的逻辑。这时可以实现

BeanPostProcessor

接口，该接口目前有两个方法：

  • postProcessBeforeInitialization 该在初始化方法之前调用。
  • postProcessAfterInitialization 该方法再初始化方法之后调用。

如果spring中存在User对象，则将它的userName设置成：shawn666。其实，我们经常使用的注解，比如：

@Autowired

、

@Value

、

@Resource

、

@PostConstruct

等，是通过

AutowiredAnnotationBeanPostProcessor

和

CommonAnnotationBeanPostProcessor

实现的。

@ComponentpublicclassMyBeanPostProcessorimplementsBeanPostProcessor{@OverridepublicObjectpostProcessAfterInitialization(Object bean,String beanName)throwsBeansException{if(bean instanceofUser){((User) bean).setUserName("shawn666");}return bean;}}

9、初始化方法

9.1 介绍

参考：Spring Bean初始化

spring中使用比较多的初始化bean的方法有：

  • 使用@PostConstruct注解
  • 实现InitializingBean接口

9.2 使用@PostConstruct注解

在需要初始化的方法上增加

@PostConstruct

注解，这样就有初始化的能力

@ServicepublicclassAService{@PostConstructpublicvoidinit(){System.out.println("===初始化===");}}

9.3 实现InitializingBean接口

实现

InitializingBean

接口，重写

afterPropertiesSet

方法，该方法中可以完成初始化功能

@ServicepublicclassBServiceimplementsInitializingBean{@OverridepublicvoidafterPropertiesSet()throwsException{System.out.println("===初始化===");}}

10、关闭容器前

有时候，我们需要在关闭spring容器前，做一些额外的工作，比如：关闭资源文件等。这时可以实现

DisposableBean

接口，并且重写它的

destroy

方法：

@ServicepublicclassDServiceimplementsInitializingBean,DisposableBean{@Overridepublicvoiddestroy()throwsException{System.out.println("DisposableBean destroy");}@OverridepublicvoidafterPropertiesSet()throwsException{System.out.println("InitializingBean afterPropertiesSet");}}

这样spring容器销毁前，会调用该

destroy

方法，做一些额外的工作。通常情况下，我们会同时实现

InitializingBean

和

DisposableBean

接口，重写初始化方法和销毁方法。

11、自定义作用域

我们都知道spring默认支持的

Scope

只有两种：

  • singleton 单例，每次从spring容器中获取到的bean都是同一个对象。
  • prototype 多例，每次从spring容器中获取到的bean都是不同的对象。

spring web又对Scope进行了扩展，增加了：

  • **RequestScope **同一次请求从spring容器中获取到的bean都是同一个对象。
  • **SessionScope **同一个会话从spring容器中获取到的bean都是同一个对象。

即便如此，有些场景还是无法满足我们的要求。比如，我们想在同一个线程中从spring容器获取到的bean都是同一个对象，该怎么办？这就需要自定义Scope了。

第一步实现Scope接口

publicclassThreadLocalScopeimplementsScope{privatestaticfinalThreadLocal THREAD_LOCAL_SCOPE =newThreadLocal();@OverridepublicObjectget(String name,ObjectFactory<?> objectFactory){Object value = THREAD_LOCAL_SCOPE.get();if(value !=null){return value;}Object object = objectFactory.getObject();
        THREAD_LOCAL_SCOPE.set(object);return object;}@OverridepublicObjectremove(String name){
        THREAD_LOCAL_SCOPE.remove();returnnull;}@OverridepublicvoidregisterDestructionCallback(String name,Runnable callback){}@OverridepublicObjectresolveContextualObject(String key){returnnull;}@OverridepublicStringgetConversationId(){returnnull;}}

第二步将新定义的Scope注入到spring容器中

@ComponentpublicclassThreadLocalBeanFactoryPostProcessorimplementsBeanFactoryPostProcessor{@OverridepublicvoidpostProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)throwsBeansException{
        beanFactory.registerScope("threadLocalScope",newThreadLocalScope());}}

第三步使用新定义的Scope

@Scope("threadLocalScope")@ServicepublicclassCService{publicvoidadd(){}}

三、Spring所有扩展接口详解

1、ApplicationContextInitializer

整个spring容器在刷新之前初始化

ConfigurableApplicationContext

的回调接口，简单来说，就是在容器刷新之前调用此类的

initialize

方法。这个点允许被用户自己扩展。用户可以在整个spring容器还没被初始化之前做一些事情。可以想到的场景可能为，在最开始激活一些配置，或者利用这时候class还没被类加载器加载的时机，进行动态字节码注入等操作。

publicclassTestApplicationContextInitializerimplementsApplicationContextInitializer{@Overridepublicvoidinitialize(ConfigurableApplicationContext applicationContext){System.out.println("[ApplicationContextInitializer]");}}

这时候spring容器还没被初始化，所以想要自己的扩展的生效，有以下三种方式：

  • 在启动类中用springApplication.addInitializers(new TestApplicationContextInitializer())语句加入@SpringBootApplicationpublicclassSpringextendApplication{publicstaticvoidmain(String[] args){SpringApplication springApplication =newSpringApplication(SpringextendApplication.class); springApplication.addInitializers(newTestApplicationContextInitializer()); springApplication.run(args);}}
  • 配置文件配置context.initializer.classes=com.example.demo.TestApplicationContextInitializer
  • Spring SPI扩展，在spring.factories中加入org.springframework.context.ApplicationContextInitializer=com.example.demo.TestApplicationContextInitializer

2、BeanDefinitionRegistryPostProcessor

这个接口在读取项目中的

beanDefinition

之后执行，提供一个补充的扩展点。使用场景：可以在这里动态注册自己的

beanDefinition

，可以加载classpath之外的bean

@ComponentpublicclassTestBeanDefinitionRegistryPostProcessorimplementsBeanDefinitionRegistryPostProcessor{@OverridepublicvoidpostProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)throwsBeansException{System.out.println("[BeanDefinitionRegistryPostProcessor] postProcessBeanDefinitionRegistry");}@OverridepublicvoidpostProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)throwsBeansException{System.out.println("[BeanDefinitionRegistryPostProcessor] postProcessBeanFactory");}}

3、BeanFactoryPostProcessor

这个接口是

beanFactory

的扩展接口，调用时机在spring在读取

beanDefinition

信息之后，实例化bean之前。在这个时机，用户可以通过实现这个扩展接口来自行处理一些东西，比如修改已经注册的

beanDefinition

的元信息。

@ComponentpublicclassTestBeanFactoryPostProcessorimplementsBeanFactoryPostProcessor{@OverridepublicvoidpostProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)throwsBeansException{System.out.println("[BeanFactoryPostProcessor]");}}

4、InstantiationAwareBeanPostProcessor

该接口继承了

BeanPostProcess

接口，区别如下：

BeanPostProcess

接口只在bean的初始化阶段进行扩展（注入spring上下文前后），而

InstantiationAwareBeanPostProcessor

接口在此基础上增加了3个方法，把可扩展的范围增加了实例化阶段和属性注入阶段。

该类主要的扩展点有以下5个方法，主要在bean生命周期的两大阶段：实例化阶段和初始化阶段，，按调用顺序为：

  • postProcessBeforeInstantiation：实例化bean之前，相当于new这个bean之前
  • postProcessAfterInstantiation：实例化bean之后，相当于new这个bean之后
  • postProcessPropertyValues：bean已经实例化完成，在属性注入时阶段触发，@Autowired,@Resource等注解原理基于此方法实现
  • postProcessBeforeInitialization：初始化bean之前，相当于把bean注入spring上下文之前
  • postProcessAfterInitialization：初始化bean之后，相当于把bean注入spring上下文之后

使用场景：，无论是写中间件和业务中，都能利用这个特性。比如对实现了某一类接口的bean在各个生命期间进行收集，或者对某个类型的bean进行统一的设值等等。

@ComponentpublicclassTestInstantiationAwareBeanPostProcessorimplementsInstantiationAwareBeanPostProcessor{@OverridepublicObjectpostProcessBeforeInitialization(Object bean,String beanName)throwsBeansException{System.out.println("[TestInstantiationAwareBeanPostProcessor] before initialization "+ beanName);return bean;}@OverridepublicObjectpostProcessAfterInitialization(Object bean,String beanName)throwsBeansException{System.out.println("[TestInstantiationAwareBeanPostProcessor] after initialization "+ beanName);return bean;}@OverridepublicObjectpostProcessBeforeInstantiation(Class<?> beanClass,String beanName)throwsBeansException{System.out.println("[TestInstantiationAwareBeanPostProcessor] before instantiation "+ beanName);returnnull;}@OverridepublicbooleanpostProcessAfterInstantiation(Object bean,String beanName)throwsBeansException{System.out.println("[TestInstantiationAwareBeanPostProcessor] after instantiation "+ beanName);returntrue;}@OverridepublicPropertyValuespostProcessProperties(PropertyValues pvs,Object bean,String beanName)throwsBeansException{System.out.println("[TestInstantiationAwareBeanPostProcessor] postProcessProperties "+ beanName);return pvs;}}

5、SmartInstantiationAwareBeanPostProcessor

该扩展接口有3个触发点方法：

  • predictBeanType：该触发点发生在postProcessBeforeInstantiation之前(在图上并没有标明，因为一般不太需要扩展这个点)，这个方法用于预测Bean的类型，返回第一个预测成功的Class类型，如果不能预测返回null；当你调用BeanFactory.getType(name)时当通过bean的名字无法得到bean类型信息时就调用该回调方法来决定类型信息。
  • determineCandidateConstructors：该触发点发生在postProcessBeforeInstantiation之后，用于确定该bean的构造函数之用，返回的是该bean的所有构造函数列表。用户可以扩展这个点，来自定义选择相应的构造器来实例化这个bean。
  • getEarlyBeanReference：该触发点发生在postProcessAfterInstantiation之后，当有循环依赖的场景，当bean实例化好之后，为了防止有循环依赖，会提前暴露回调方法，用于bean实例化的后置处理。这个方法就是在提前暴露的回调方法中触发。
@ComponentpublicclassTestSmartInstantiationAwareBeanPostProcessorimplementsSmartInstantiationAwareBeanPostProcessor{@OverridepublicClass<?>predictBeanType(Class<?> beanClass,String beanName)throwsBeansException{System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] predictBeanType "+ beanName);return beanClass;}@OverridepublicConstructor<?>[]determineCandidateConstructors(Class<?> beanClass,String beanName)throwsBeansException{System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] determineCandidateConstructors "+ beanName);returnnull;}@OverridepublicObjectgetEarlyBeanReference(Object bean,String beanName)throwsBeansException{System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] getEarlyBeanReference "+ beanName);return bean;}}

6、BeanFactoryAware

这个类只有一个触发点，发生在bean的实例化之后，注入属性之前，也就是Setter之前。这个类的扩展点方法为

setBeanFactory

，可以拿到

BeanFactory

这个属性。使用场景：你可以在bean实例化之后，但还未初始化之前，拿到 

BeanFactory

，在这个时候，可以对每个bean作特殊化的定制。也或者可以把

BeanFactory

拿到进行缓存，日后使用

@ComponentpublicclassTestBeanFactoryPostProcessorimplementsBeanFactoryPostProcessor{@OverridepublicvoidpostProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)throwsBeansException{System.out.println("[BeanFactoryPostProcessor] "+ beanFactory.toString());// 下面这个有循环依赖问题// System.out.println("[TestBeanFactoryAware] " + beanFactory.getBean(TestBeanFactoryAware.class).getClass().getSimpleName());}}

7、ApplicationContextAwareProcessor

该类本身并没有扩展点，但是该类内部却有6个扩展点可供实现 ，这些类触发的时机在bean实例化之后，初始化之前。该类用于执行各种驱动接口，在bean实例化之后，属性填充之后，通过执行扩展接口，来获取对应容器的变量。所以这里应该来说是有6个扩展点

  • EnvironmentAware：用于获取EnviromentAware的一个扩展类，这个变量非常有用， 可以获得系统内的所有参数。当然个人认为这个Aware没必要去扩展，因为spring内部都可以通过注入的方式来直接获得。
  • EmbeddedValueResolverAware：用于获取StringValueResolver的一个扩展类， StringValueResolver用于获取基于String类型的properties的变量，一般我们都用@Value的方式去获取，如果实现了这个Aware接口，把StringValueResolver缓存起来，通过这个类去获取String类型的变量，效果是一样的。
  • ResourceLoaderAware：用于获取ResourceLoader的一个扩展类，ResourceLoader可以用于获取classpath内所有的资源对象，可以扩展此类来拿到ResourceLoader对象。
  • ApplicationEventPublisherAware：用于获取ApplicationEventPublisher的一个扩展类，ApplicationEventPublisher可以用来发布事件，结合ApplicationListener来共同使用，下文在介绍ApplicationListener时会详细提到。这个对象也可以通过spring注入的方式来获得。
  • MessageSourceAware：用于获取MessageSource的一个扩展类，MessageSource主要用来做国际化。
  • ApplicationContextAware：用来获取ApplicationContext的一个扩展类，ApplicationContext应该是很多人非常熟悉的一个类了，就是spring上下文管理器，可以手动的获取任何在spring上下文注册的bean，我们经常扩展这个接口来缓存spring上下文，包装成静态方法。同时ApplicationContext也实现了BeanFactory，MessageSource，ApplicationEventPublisher等接口，也可以用来做相关接口的事情。

8、BeanNameAware

这个类也是Aware扩展的一种，触发点在bean的初始化之前，也就是

postProcessBeforeInitialization

之前，这个类的触发点方法只有一个：

setBeanName

。使用场景：用户可以扩展这个点，在初始化bean之前拿到spring容器中注册的的beanName，来自行修改这个beanName的值。

@ComponentpublicclassNormalBeanAimplementsBeanNameAware{publicNormalBeanA(){System.out.println("NormalBean constructor");}@OverridepublicvoidsetBeanName(String name){System.out.println("[BeanNameAware] "+ name);}}

9、@PostConstruct

这个并不算一个扩展点，其实就是一个标注。其作用是在bean的初始化阶段，如果对一个方法标注了

@PostConstruct

，会先调用这个方法。这里重点是要关注下这个标准的触发点，这个触发点是在

postProcessBeforeInitialization

之后，

InitializingBean.afterPropertiesSet

之前。使用场景：用户可以对某一方法进行标注，来进行初始化某一个属性

10、InitializingBean

这个类也是用来初始化bean的。

InitializingBean

接口为bean提供了初始化方法的方式，它只包括

afterPropertiesSet

方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。这个扩展点的触发时机在

postProcessAfterInitialization

之前。使用场景：用户实现此接口，来进行系统启动的时候一些业务指标的初始化工作。

11、FactoryBean

Spring通过反射机制利用bean的class属性指定支线类去实例化bean，在某些情况下，实例化Bean过程比较复杂，如果按照传统的方式，则需要在bean中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个

org.springframework.bean.factory.FactoryBean

的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。

FactoryBean

接口对于Spring框架来说占用重要的地位，Spring自身就提供了70多个

FactoryBean

的实现。它们隐藏了实例化一些复杂bean的细节，给上层应用带来了便利。从Spring3.0开始，

FactoryBean

开始支持泛型，即接口声明改为

FactoryBean<T>

的形式

使用场景：用户可以扩展这个类，来为要实例化的bean作一个代理，比如为该对象的所有的方法作一个拦截，在调用前后输出一行log，模仿

ProxyFactoryBean

的功能。

@ComponentpublicclassTestFactoryBeanimplementsFactoryBean<TestFactoryBean.TestFactoryInnerBean>{@OverridepublicTestFactoryBean.TestFactoryInnerBeangetObject()throwsException{System.out.println("[FactoryBean] getObject");returnnewTestFactoryBean.TestFactoryInnerBean();}@OverridepublicClass<?>getObjectType(){returnTestFactoryBean.TestFactoryInnerBean.class;}@OverridepublicbooleanisSingleton(){returntrue;}publicstaticclassTestFactoryInnerBean{}}

12、SmartInitializingSingleton

这个接口中只有一个方法

afterSingletonsInstantiated

，其作用是是 在spring容器管理的所有单例对象（非懒加载对象）初始化完成之后调用的回调接口。其触发时机为

postProcessAfterInitialization

之后。使用场景：用户可以扩展此接口在对所有单例对象初始化完毕后，做一些后置的业务处理。

@ComponentpublicclassTestSmartInitializingSingletonimplementsSmartInitializingSingleton{@OverridepublicvoidafterSingletonsInstantiated(){System.out.println("[TestSmartInitializingSingleton]");}}

13、CommandLineRunner

这个接口也只有一个方法：

run(String... args)

，触发时机为整个项目启动完毕后，自动执行。如果有多个

CommandLineRunner

，可以利用

@Order

来进行排序。使用场景：用户扩展此接口，进行启动项目之后一些业务的预处理。

@ComponentpublicclassTestCommandLineRunnerimplementsCommandLineRunner{@Overridepublicvoidrun(String... args)throwsException{System.out.println("[TestCommandLineRunner]");}}

14、DisposableBean

这个扩展点也只有一个方法：

destroy()

，其触发时机为当此对象销毁时，会自动执行这个方法。比如说运行

applicationContext.registerShutdownHook

时，就会触发这个方法。

15、ApplicationListener

准确的说，这个应该不算spring&springboot当中的一个扩展点，

ApplicationListener

可以监听某个事件的

event

，触发时机可以穿插在业务方法执行过程中，用户可以自定义某个业务事件。但是spring内部也有一些内置事件，这种事件，可以穿插在启动调用中。我们也可以利用这个特性，来自己做一些内置事件的监听器来达到和前面一些触发点大致相同的事情。

接下来罗列下spring主要的内置事件：

  • ContextRefreshedEventApplicationContext 被初始化或刷新时，该事件被发布。这也可以在ConfigurableApplicationContext接口中使用 refresh()方法来发生。此处的初始化是指：所有的Bean被成功装载，后处理Bean被检测并激活，所有Singleton Bean 被预实例化，ApplicationContext容器已就绪可用。
  • ContextStartedEvent当使用 ConfigurableApplicationContext （ApplicationContext子接口）接口中的 start() 方法启动 ApplicationContext时，该事件被发布。你可以调查你的数据库，或者你可以在接受到这个事件后重启任何停止的应用程序。
  • ContextStoppedEvent当使用 ConfigurableApplicationContext接口中的 stop()停止ApplicationContext 时，发布这个事件。你可以在接受到这个事件后做必要的清理的工作
  • ContextClosedEvent当使用 ConfigurableApplicationContext接口中的 close()方法关闭 ApplicationContext 时，该事件被发布。一个已关闭的上下文到达生命周期末端；它不能被刷新或重启
  • RequestHandledEvent这是一个 web-specific 事件，告诉所有 bean HTTP 请求已经被服务。只能应用于使用DispatcherServlet的Web应用。在使用Spring作为前端的MVC控制器时，当Spring处理用户请求结束后，系统会自动触发该事件

参考文章：

https://mp.weixin.qq.com/s/Bih1XRVLi6ywMtErG_YcgQ

https://www.jianshu.com/p/38d834db7413

标签： 1024程序员节
本文转载自: https://blog.csdn.net/lemon_TT/article/details/127500593
版权归原作者 魅Lemon 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Spring常用扩展点”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航