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

前言

在运用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：它支撑多种源和方针类型的转化，还供给了源和方针类型的上下文。此上下文允许您依据注释或特点信息履行类型转化。

还是不明白的话，咱们举个比方吧。

界说一个用户方针

@Data
public 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容器中

@Configuration
public 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

@Service
public 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

@Service
public 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

@Service
public 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")
@RestController
public 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。

@RestControllerAdvice
public 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容器中

@Configuration
public 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)
@Configuration
public class TestConfiguration {
}

经过@Import注解引进类A，spring能够主动实例化A方针，然后在需求运用的当地经过注解@Autowired注入：

@Autowired
private A a;

5.2 装备类

这种引进办法是最复杂的，因为@Configuration支撑还支撑多种组合注解，比方：

@Import
@ImportResource
@PropertySource

public class A {
}
public class B {
}
@Import(B.class)
@Configuration
public class AConfiguration {
    @Bean
    public A a() {
        return new A();
    }
}
@Import(AConfiguration.class)
@Configuration
public 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)
@Configuration
public 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)
@Configuration
public class TestConfiguration {
}

这种办法是最灵活的。容器注册方针能够在registerBeanDefinitions办法中获取，能够手动创建BeanDefinition注册到BeanDefinitionRegistry种。

6. 当工程启动时

有时候咱们需求在项目启动的时候自界说一些额定的功能，比方加载一些系统参数，完结初始化，预热本地缓存等。咱们应该做什么？

好消息是 SpringBoot 供给了：

CommandLineRunner
ApplicationRunner

这两个接口协助咱们完结了上面的需求。

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

@Component
public 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 接口。

@Component
public 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`

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

为需求初始化的办法增加注解@PostConstruct，使其在Bean初始化时履行。

9.2 完结初始化接口`InitializingBean`

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

完结InitializingBean接口，重写afterPropertiesSet办法，在该办法中能够完结初始化功能。

10. 封闭Spring容器前

有时候，咱们需求在封闭spring容器之前做一些额定的工作，比方封闭资源文件。

此刻你能够完结 DisposableBean 接口并重写它的 destroy 办法。

@Service
public 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容器中

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

运用新界说的Scope

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

总结

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

欢迎重视个人公众号—— JAVA旭阳

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

总结

相关文章

Go异步任务处理解决方案：Asynq

白话强化学习（理论+代码）

7个原则，看懂「深色模式」设计

写给互联网人的一封信

作者信息

7. 修正`BeanDefinition`

9.1 运用 `@PostConstruct`

9.2 完结初始化接口`InitializingBean`

11. 自界说`Bean`的`scope`