Spring中11個最常用的擴充套件點，你知道幾個？

JAVA旭陽發表於2022-12-19
Spring套件

前言

在使用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：它支援多種源和目標型別的轉換，還提供了源和目標型別的上下文。 此上下文允許您根據註釋或屬性資訊執行型別轉換。

還是不明白的話，我們舉個例子吧。

  1. 定義一個使用者物件
@Data
public class User {
    private Long id;
    private String name;
    private Date registerDate;
}
  1. 實現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;
    }
}
  1. 將新定義的型別轉換器注入到Spring容器中
@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {
    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(new DateConverter());
    }
}
  1. 呼叫介面測試
@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。

如果有授權鑑權、日誌、統計等場景，可以使用該攔截器，我們來演示下吧。

  1. 寫一個類繼承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;
    }
}
  1. 將攔截器註冊到spring容器中
@Configuration
public class WebAuthConfig extends WebMvcConfigurerAdapter {

    @Bean
    public AuthInterceptor getAuthInterceptor() {
        return new AuthInterceptor();
    }
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new AuthInterceptor());
    }
}
  1. 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的方式有很多種：

  1. 使用@PostConstruct註解
  2. 實現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都是同一個物件，怎麼辦？

答案：這需要一個自定義範圍。

  1. 實現 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;
    }
}
  1. 將新定義的Scope注入到Spring容器中
@Component
public class ThreadLocalBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        beanFactory.registerScope("threadLocalScope", new ThreadLocalScope());
    }
}
  1. 使用新定義的Scope
@Scope("threadLocalScope")
@Service
public class CService {
    public void add() {
    }
}

總結

本文總結了Spring中很常用的11個擴充套件點，可以在Bean建立、初始化到銷燬各個階段注入自己想要的邏輯，也有Spring MVC相關的攔截器等擴充套件點，希望對大家有幫助。

歡迎關注個人公眾號——JAVA旭陽
更多學習資料請移步：程式設計師成神之路

相關文章