Spring 中 11 个最常用的扩展点，你知道几个？

2022-12-19
浙江
本文字数：6956 字
阅读完需：约 23 分钟

前言

在使用 spring 的过程中，我们有没有发现它的扩展能力很强呢？由于这个优势的存在，使得 spring 具有很强的包容性，所以很多第三方应用或者框架可以很容易的投入到 spring 的怀抱中。今天我们主要来学习 Spring 中很常用的 11 个扩展点，你用过几个呢？

1. 类型转换器

如果接口中接收参数的实体对象中，有一个字段类型为 Date，但实际传递的参数是字符串类型：2022-12-15 10:20:15，该如何处理？

Spring 提供了一个扩展点，类型转换器Type Converter，具体分为 3 类：

Converter<S,T>: 将类型 S 的对象转换为类型 T 的对象
ConverterFactory<S, R>: 将 S 类型对象转换为 R 类型或其子类对象
GenericConverter：它支持多种源和目标类型的转换，还提供了源和目标类型的上下文。此上下文允许您根据注释或属性信息执行类型转换。

还是不明白的话，我们举个例子吧。

定义一个用户对象

@Datapublic class User {    private Long id;    private String name;    private Date registerDate;}

复制代码

实现Converter接口

public class DateConverter implements Converter<String, Date> {    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");    @Override    public Date convert(String source) {        if (source != null && !"".equals(source)) {            try {                simpleDateFormat.parse(source);            } catch (ParseException e) {                e.printStackTrace();            }        }        return null;    }}

复制代码

将新定义的类型转换器注入到 Spring 容器中

@Configurationpublic class WebConfig extends WebMvcConfigurerAdapter {    @Override    public void addFormatters(FormatterRegistry registry) {        registry.addConverter(new DateConverter());    }}

复制代码

调用接口测试

@RequestMapping("/user")    @RestController    public class UserController {        @RequestMapping("/save")        public String save(@RequestBody User user) {            return "success";        }    }

复制代码

请求接口时，前端传入的日期字符串，会自动转换成 Date 类型。

2. 获取容器 Bean

在我们日常开发中，经常需要从 Spring 容器中获取 bean，但是你知道如何获取 Spring 容器对象吗？

2.1 BeanFactoryAware

@Servicepublic class PersonService implements BeanFactoryAware {    private BeanFactory beanFactory;
    @Override    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {        this.beanFactory = beanFactory;    }
    public void add() {        Person person = (Person) beanFactory.getBean("person");    }}

复制代码

实现 BeanFactoryAware 接口，然后重写 setBeanFactory 方法，可以从方法中获取 spring 容器对象。

2.2 ApplicationContextAware

@Servicepublic class PersonService2 implements ApplicationContextAware {    private ApplicationContext applicationContext;
    @Override    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {        this.applicationContext = applicationContext;    }
    public void add() {        Person person = (Person) applicationContext.getBean("person");    }}

复制代码

实现ApplicationContextAware接口，然后重写setApplicationContext方法，也可以通过该方法获取 spring 容器对象。

2.3 ApplicationListener

@Servicepublic class PersonService3 implements ApplicationListener<ContextRefreshedEvent> {    private ApplicationContext applicationContext;    @Override    public void onApplicationEvent(ContextRefreshedEvent event) {        applicationContext = event.getApplicationContext();    }
    public void add() {        Person person = (Person) applicationContext.getBean("person");    }}

复制代码

3. 全局异常处理

以往我们在开发界面的时候，如果出现异常，要给用户更友好的提示，例如：

@RequestMapping("/test")@RestControllerpublic class TestController {
    @GetMapping("/add")    public String add() {        int a = 10 / 0;        return "su";    }}

复制代码

如果不对请求添加接口结果做任何处理，会直接报错：

用户可以直接看到错误信息吗？

这种交互给用户带来的体验非常差。为了解决这个问题，我们通常在接口中捕获异常：

@GetMapping("/add")public String add() {    String result = "success";    try {        int a = 10 / 0;    } catch (Exception e) {        result = "error";    }    return result;}

复制代码

界面修改后，出现异常时会提示：“数据异常”，更加人性化。

看起来不错，但是有一个问题。

如果只是一个接口还好，但是如果项目中有成百上千个接口，还得加异常捕获代码吗？

答案是否定的，这就是全局异常处理派上用场的地方：RestControllerAdvice。

@RestControllerAdvicepublic class GlobalExceptionHandler {
    @ExceptionHandler(Exception.class)    public String handleException(Exception e) {        if (e instanceof ArithmeticException) {            return "data error";        }        if (e instanceof Exception) {            return "service error";        }        retur null;    }}

复制代码

方法中处理异常只需要handleException，在业务接口中就可以安心使用，不再需要捕获异常（统一有人处理）。

4. 自定义拦截器

Spring MVC 拦截器，它可以获得HttpServletRequest和HttpServletResponse等 web 对象实例。

Spring MVC 拦截器的顶层接口是HandlerInterceptor，它包含三个方法：

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

为了方便，我们一般继承HandlerInterceptorAdapter，它实现了HandlerInterceptor。

如果有授权鉴权、日志、统计等场景，可以使用该拦截器，我们来演示下吧。

写一个类继承HandlerInterceptorAdapter：

public class AuthInterceptor extends HandlerInterceptorAdapter {    @Override    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)    throws Exception {        String requestUrl = request.getRequestURI();        if (checkAuth(requestUrl)) {            return true;        }        return false;    }    private boolean checkAuth(String requestUrl) {        return true;    }}

复制代码

将拦截器注册到 spring 容器中

@Configurationpublic class WebAuthConfig extends WebMvcConfigurerAdapter {
    @Bean    public AuthInterceptor getAuthInterceptor() {        return new AuthInterceptor();    }    @Override    public void addInterceptors(InterceptorRegistry registry) {        registry.addInterceptor(new AuthInterceptor());    }}

复制代码

Spring MVC 在请求接口时可以自动拦截接口，并通过拦截器验证权限。

5. 导入配置

有时我们需要在某个配置类中引入其他的类，引入的类也加入到 Spring 容器中。这时候可以使用注解@Import来完成这个功能。

如果你查看它的源代码，你会发现导入的类支持三种不同的类型。

但是我觉得最好把普通类的配置类和@Configuration注解分开解释，所以列出了四种不同的类型：

5.1 通用类

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

public class A {}
@Import(A.class)@Configurationpublic class TestConfiguration {    }

复制代码

通过@Import注解引入类 A，spring 可以自动实例化 A 对象，然后在需要使用的地方通过注解@Autowired注入：

@Autowiredprivate A a;

复制代码

5.2 配置类

这种引入方式是最复杂的，因为 @Configuration 支持还支持多种组合注解，比如：

@Import
@ImportResource
@PropertySource

public class A {}
public class B {}
@Import(B.class)@Configurationpublic class AConfiguration {
    @Bean    public A a() {        return new A();    }}
@Import(AConfiguration.class)@Configurationpublic class TestConfiguration {}

复制代码

@Configuration注解的配置类通过@Import注解导入，配置类@Import、@ImportResource相关注解引入的类会一次性全部递归引入@PropertySource所在的属性。

5.3 ImportSelector

该导入方法需要实现ImportSelector接口

public class AImportSelector implements ImportSelector {
    private static final String CLASS_NAME = "com.sue.cache.service.test13.A";
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {        return new String[]{CLASS_NAME};    }}
@Import(AImportSelector.class)@Configurationpublic class TestConfiguration {}

复制代码

这种方法的好处是selectImports方法返回的是一个数组，也就是说可以同时引入多个类，非常方便。

5.4 ImportBeanDefinitionRegistrar

该导入方法需要实现ImportBeanDefinitionRegistrar接口：

public class AImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {    @Override    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(A.class);        registry.registerBeanDefinition("a", rootBeanDefinition);    }}
@Import(AImportBeanDefinitionRegistrar.class)@Configurationpublic class TestConfiguration {}

复制代码

这种方法是最灵活的。容器注册对象可以在registerBeanDefinitions方法中获取，可以手动创建BeanDefinition注册到BeanDefinitionRegistry种。

6. 当工程启动时

有时候我们需要在项目启动的时候自定义一些额外的功能，比如加载一些系统参数，完成初始化，预热本地缓存等。我们应该做什么？

好消息是 SpringBoot 提供了：

CommandLineRunner
ApplicationRunner

这两个接口帮助我们实现了上面的需求。

它们的用法很简单，以ApplicationRunner接口为例：

@Componentpublic class TestRunner implements ApplicationRunner {
    @Autowired    private LoadDataService loadDataService;
    public void run(ApplicationArguments args) throws Exception {        loadDataService.load();    }}

复制代码

实现ApplicationRunner接口，重写run方法，在该方法中实现您的自定义需求。

如果项目中有多个类实现了ApplicationRunner接口，如何指定它们的执行顺序？

答案是使用 @Order(n)注解，n 的值越小越早执行。当然，顺序也可以通过@Priority注解来指定。

7. 修改`BeanDefinition`

在实例化 Bean 对象之前，Spring IOC需要读取 Bean 的相关属性，保存在BeanDefinition对象中，然后通过BeanDefinition对象实例化Bean对象。

如果要修改 BeanDefinition 对象中的属性怎么办？

答案：我们可以实现 BeanFactoryPostProcessor 接口。

@Componentpublic class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) configurableListableBeanFactory;        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(User.class);        beanDefinitionBuilder.addPropertyValue("id", 123);        beanDefinitionBuilder.addPropertyValue("name", "Tom");        defaultListableBeanFactory.registerBeanDefinition("user", beanDefinitionBuilder.getBeanDefinition());    }}

复制代码

在postProcessBeanFactory方法中，可以获取BeanDefinition的相关对象，修改对象的属性。

8. 初始化 Bean 前和后

有时，您想在 bean 初始化前后实现一些您自己的逻辑。

这时候就可以实现：BeanPostProcessor接口。

该接口目前有两个方法：

postProcessBeforeInitialization：应该在初始化方法之前调用。
postProcessAfterInitialization：此方法在初始化方法之后调用。

@Component    public class MyBeanPostProcessor implements BeanPostProcessor {
        @Override        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {            if (bean instanceof User) {                ((User) bean).setUserName("Tom");            }            return bean;        }    }

复制代码

我们经常使用的@Autowired、@Value、@Resource、@PostConstruct等注解都是通过AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor来实现的。

9. 初始化方法

目前在 Spring 中初始化 bean 的方式有很多种：

使用@PostConstruct注解
实现InitializingBean接口

9.1 使用 `@PostConstruct`

@Servicepublic class AService {    @PostConstruct    public void init() {        System.out.println("===init===");    }}

复制代码

为需要初始化的方法添加注解@PostConstruct，使其在 Bean 初始化时执行。

9.2 实现初始化接口`InitializingBean`

@Servicepublic class BService implements InitializingBean {
    @Override    public void afterPropertiesSet() throws Exception {        System.out.println("===init===");    }}

复制代码

实现InitializingBean接口，重写afterPropertiesSet方法，在该方法中可以完成初始化功能。

10. 关闭 Spring 容器前

有时候，我们需要在关闭 spring 容器之前做一些额外的工作，比如关闭资源文件。

此时你可以实现 DisposableBean 接口并重写它的 destroy 方法。

@Servicepublic class DService implements InitializingBean, DisposableBean {
    @Override    public void destroy() throws Exception {        System.out.println("DisposableBean destroy");    }
    @Override    public void afterPropertiesSet() throws Exception {        System.out.println("InitializingBean afterPropertiesSet");    }}

复制代码

这样，在 spring 容器销毁之前，会调用destroy方法做一些额外的工作。

通常我们会同时实现InitializingBean和DisposableBean接口，重写初始化方法和销毁方法。

11. 自定义`Bean`的`scope`

我们都知道 spring core 默认只支持两种Scope：

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

Spring Web 再次扩展了 Scope，添加

RequestScope：同一个请求中从 spring 容器中获取的 bean 都是同一个对象。
SessionScope：同一个 session 从 spring 容器中获取的 bean 都是同一个对象。

尽管如此，有些场景还是不符合我们的要求。

比如我们在同一个线程中要从spring容器中获取的bean都是同一个对象，怎么办？

答案：这需要一个自定义范围。

实现 Scope 接口

public class ThreadLocalScope implements Scope {    private static final ThreadLocal THREAD_LOCAL_SCOPE = new ThreadLocal();
    @Override    public Object get(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;    }
    @Override    public Object remove(String name) {        THREAD_LOCAL_SCOPE.remove();        return null;    }
    @Override    public void registerDestructionCallback(String name, Runnable callback) {    }
    @Override    public Object resolveContextualObject(String key) {        return null;    }
    @Override    public String getConversationId() {        return null;    }}

复制代码

将新定义的 Scope 注入到 Spring 容器中

@Componentpublic class ThreadLocalBeanFactoryPostProcessor implements BeanFactoryPostProcessor {    @Override    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {        beanFactory.registerScope("threadLocalScope", new ThreadLocalScope());    }}

复制代码

使用新定义的 Scope

@Scope("threadLocalScope")@Servicepublic class CService {    public void add() {    }}

复制代码

总结

本文总结了 Spring 中很常用的 11 个扩展点，可以在 Bean 创建、初始化到销毁各个阶段注入自己想要的逻辑，也有 Spring MVC 相关的拦截器等扩展点，希望对大家有帮助。

欢迎关注个人公众号——JAVA 旭阳
更多学习资料请移步：程序员成神之路

发布于: 刚刚阅读数: 4

原文链接:【http://xie.infoq.cn/article/869ca460bc5d3e8d5231c6875】。文章转载请联系作者。

JAVA旭阳

关注

欢迎关注个人公众号—— JAVA旭阳 2018-07-18 加入

旭阳，希望自己能像初升的太阳一样，对任何事情充满希望~~

发布

暂无评论

创作场景

Spring 中 11 个最常用的扩展点，你知道几个？

前言

1. 类型转换器

2. 获取容器 Bean

2.1 BeanFactoryAware

2.2 ApplicationContextAware

2.3 ApplicationListener

3. 全局异常处理

4. 自定义拦截器

5. 导入配置

5.1 通用类

5.2 配置类

5.3 ImportSelector

5.4 ImportBeanDefinitionRegistrar

6. 当工程启动时

7. 修改BeanDefinition

8. 初始化 Bean 前和后

9. 初始化方法

9.1 使用 @PostConstruct

9.2 实现初始化接口InitializingBean

10. 关闭 Spring 容器前

11. 自定义Bean的scope

总结

JAVA旭阳

评论

7. 修改`BeanDefinition`

9.1 使用 `@PostConstruct`

9.2 实现初始化接口`InitializingBean`

11. 自定义`Bean`的`scope`