Spring鉤子方法和鉤子接口的使用詳解

[TOC]

前言

SpringFramework其實具有很高的擴展性，只是很少人喜歡挖掘那些擴展點，而且官方的Refrence也很少提到那些Hook類或Hook接口，至于是不是Spring官方有意為之就不得而知。本文淺析一下筆者目前看到的Spring的一些對外開放的擴展點、Hook接口或者Hook類，如果有什么錯誤，希望多多交流指正，一切以Spring的源碼為準，文章編寫使用的Spring版本為4.3.8.Release,對應SpringBoot的版本為1.5.3.RELEASE

1、Aware接口族

Spring中提供了各種Aware接口，方便從上下文中獲取當前的運行環境，比較常見的幾個子接口有：
BeanFactoryAware,BeanNameAware,ApplicationContextAware,EnvironmentAware，BeanClassLoaderAware等，這些Aware的作用都可以從命名得知，并且其使用也是十分簡單。

例如我們經常看到SpringContext工具類：

@Component
public final class SpringContextAssisor implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        SpringContextAssisor.applicationContext = applicationContext;
    }

    public static Object getBeanDefinition(String name) {
        return applicationContext.getBean(name);
    }

    public static <T> T getBeanDefinition(String name, Class<T> clazz) {
        return applicationContext.getBean(name, clazz);
    }

}

實現ApplicationContextAware接口可以獲取ApplicationContext

又例如想獲取到當前的一個Spring Bean的BeanFactory：

@Component
public class OneBean implements BeanFactoryAware {
    private BeanFactory beanFactory;
 
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }
}

一般來說，拿到的應該是DefaultListableBeanFactory，因為這個BeanFactory是BeanFactory一族的最底層的BeanFactory實現類，擁有所有父BeanFactory的功能。

其他的Aware可以自己嘗試下功能。

PS：Aware是可以自定義擴展的，具體可以參考下面這篇的博客：

http://www.cnblogs.com/RunForLove/p/5828916.html

2、InitializingBean接口和DisposableBean接口

InitializingBean接口只有一個方法#afterPropertiesSet，作用是：當一個Bean實現InitializingBean，#afterPropertiesSet方法里面可以添加自定義的初始化方法或者做一些資源初始化操作(Invoked by a BeanFactory after it has set all bean properties supplied ==> "當BeanFactory 設置完所有的Bean屬性之后才會調用#afterPropertiesSet方法")。
DisposableBean接口只有一個方法#destroy，作用是：當一個單例Bean實現DisposableBean，#destroy可以添加自定義的一些銷毀方法或者資源釋放操作(Invoked by a BeanFactory on destruction of a singleton ==>"單例銷毀時由BeanFactory調用#destroy")

使用例子:

@Component
public class ConcreteBean implements InitializingBean,DisposableBean {

    @Override
    public void destroy() throws Exception {
        System.out.println("釋放資源");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("初始化資源");
    }
}

3、ImportBeanDefinitionRegistrar接口

功能：

先看官方的注釋

/**
 * Interface to be implemented by types that register additional bean definitions when
 * processing @{@link Configuration} classes. Useful when operating at the bean definition
 * level (as opposed to {@code @Bean} method/instance level) is desired or necessary.
 *
 * <p>Along with {@code @Configuration} and {@link ImportSelector}, classes of this type
 * may be provided to the @{@link Import} annotation (or may also be returned from an
 * {@code ImportSelector}).
 *
 * <p>An {@link ImportBeanDefinitionRegistrar} may implement any of the following
 * {@link org.springframework.beans.factory.Aware Aware} interfaces, and their respective
 * methods will be called prior to {@link #registerBeanDefinitions}:
 * <ul>
 * <li>{@link org.springframework.context.EnvironmentAware EnvironmentAware}</li>
 * <li>{@link org.springframework.beans.factory.BeanFactoryAware BeanFactoryAware}
 * <li>{@link org.springframework.beans.factory.BeanClassLoaderAware BeanClassLoaderAware}
 * <li>{@link org.springframework.context.ResourceLoaderAware ResourceLoaderAware}
 * </ul>
 *
 * <p>See implementations and associated unit tests for usage examples.

翻譯一下大概如下：

1.當處理Java編程式配置類(使用了@Configuration的類)的時候，ImportBeanDefinitionRegistrar接口的實現類可以注冊額外的bean definitions;
2.ImportBeanDefinitionRegistrar接口的實現類必須提供給@Import注解或者是ImportSelector接口返回值
3.ImportBeanDefinitionRegistrar接口的實現類可能還會實現下面org.springframework.beans.factory.Aware接口中的一個或者多個，它們各自的方法優先于ImportBeanDefinitionRegistrar#registerBeanDefinitions被調用
org.springframework.beans.factory.Aware的部分接口如下：

• org.springframework.context.EnvironmentAware(讀取或者修改Environment的變量)
• org.springframework.beans.factory.BeanFactoryAware (獲取Bean自身的Bean工廠)
• org.springframework.beans.factory.BeanClassLoaderAware(獲取Bean自身的類加載器)
• org.springframework.context.ResourceLoaderAware(獲取Bean自身的資源加載器)

個人理解：

1.首先需要自定義一個類去實現ImportBeanDefinitionRegistrar接口， #registerBeanDefinitions方法的參數有(使用了@Import的類型)元注解AnnotationMetadata以及BeanDefinitionRegistry(Bean注冊相關方法的提供接口)，通過BeanDefinitionRegistry的方法可以實現BeanDefinition注冊、移除等相關操作；

2.為了保證1生效，必須定義一個Java配置類(帶有注解@Configuration)通過@Import指定1中定義的實現類

一個例子：

目標是通過自定義注解@EnableThrowable里面的targets屬性指定需要注冊進去Spring容器的class，當注解使用在@Configuration的類上，實現指定class的注冊，然后可以使用@Autowire實現自動注入。
定義ImportBeanDefinitionRegistrar的實現類EnableThrowableRegistrar：

public class EnableThrowableRegistrar implements ImportBeanDefinitionRegistrar, EnvironmentAware {

    @Override
    public void setEnvironment(Environment environment) {
        System.out.println("JAVA_HOME:" + environment.getProperty("JAVA_HOME"));
    }

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
                                        BeanDefinitionRegistry registry) {
        Map<String, Object> annotationAttributes
                = importingClassMetadata.getAnnotationAttributes(EnableThrowable.class.getCanonicalName());
        Class<?>[] targets = (Class<?>[]) annotationAttributes.get("targets");
        if (null != targets && targets.length > 0) {
            for (Class<?> target : targets) {
                BeanDefinition beanDefinition = BeanDefinitionBuilder
                        .genericBeanDefinition(target)
                        .getBeanDefinition();
                registry.registerBeanDefinition(beanDefinition.getBeanClassName(),
                        beanDefinition);
            }
        }
    }
}

定義一個注解@EnableThrowable：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(value = {EnableThrowableRegistrar.class})
public @interface EnableThrowable {

    Class<?>[] targets() default {};
}

定義一個Java配置類ConcreteConfiguration：

@Configuration
@EnableThrowable(targets = {ConcreteService.class})
public class ConcreteConfiguration {

}

定義一個非Spring管理的Service類ConcreteService：

public class ConcreteService {

    public void sayHello(){
        System.out.println("ConcreteService say hello!");
    }
}

測試代碼：

@SpringBootTest(classes = Application.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class ConcreteServiceTest {

    @Autowired
    private ConcreteService concreteService;

    @Test
    public void sayHello() throws Exception {
        concreteService.sayHello();
    }

}

結果：

01.png

可以看到讀取Environment屬性成功，同時普通Java類ConcreteService成功注冊到Spring容器并且自動注入和調用成功。

4、BeanPostProcessor接口和BeanFactoryPostProcessor接口

一般我們叫這兩個接口為Spring的Bean后置處理器接口,作用是為Bean的初始化前后提供可擴展的空間。先看接口的方法：

BeanPostProcessor

public interface BeanPostProcessor {
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
  
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

BeanFactoryPostProcessor

public interface BeanFactoryPostProcessor {
 void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;  
}

BeanFactoryPostProcessor可以對bean的定義（配置元數據）進行處理。也就是說，Spring IoC容器允許BeanFactoryPostProcessor在容器實際實例化任何其它的bean之前讀取配置元數據，并有可能修改它。如果你愿意，你可以配置多個BeanFactoryPostProcessor。你還能通過設置'order'屬性來控制BeanFactoryPostProcessor的執行次序。(大概可以這樣理解:Spring容器加載了bean的定義文件之后，在bean實例化之前執行的)

實現BeanPostProcessor接口可以在Bean(實例化之后)初始化的前后做一些自定義的操作，但是拿到的參數只有BeanDefinition實例和BeanDefinition的名稱，也就是無法修改BeanDefinition元數據,這里說的Bean的初始化是：
1）bean實現了InitializingBean接口，對應的方法為afterPropertiesSet
2）在bean定義的時候，通過init-method設置的方法
PS:BeanFactoryPostProcessor回調會先于BeanPostProcessor

使用例子：
實現一個BeanPostProcessor==>ConcreteBeanPostProcessor

@Order(1)
@Component
public class ConcreteBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.contains("postBean"))
        System.out.println(String.format("Bean初始化之前,bean:%s,beanName:%s", bean.toString(), beanName));
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.contains("postBean"))
        System.out.println(String.format("Bean初始化之后,bean:%s,beanName:%s", bean.toString(), beanName));
        return bean;
    }
}

實現一個BeanFactoryPostProcessor==>ConcreteBeanFactoryPostProcessor

@Component
public class ConcreteBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition("postBean");
        MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
        propertyValues.addPropertyValue("author", "throwable");
    }
}

定義一個Spring的Bean

@Component
public class PostBean {

    private String author;

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public void sayhello() {
        System.out.println(String.format("author %s say hello!", author));
    }
}

測試類：

@SpringBootTest(classes = Application.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class PostBeanTest {
    @Autowired
    private PostBean postBean;
    
    @Test
    public void sayhello() throws Exception {
        postBean.sayhello();
    }
}

結果：

02.png

PS:有興趣可以看下Spring內置的一些實現了后置處理器接口的類，大概有下面這些：

AnnotationAwareAspectJAutoProxyCreator
AspectJAwareAdvisorAutoProxyCreator
InitDestroyAnnotationBeanPostProcessor
ApplicationContextAwareProcessor
AutowiredAnnotationBeanPostProcessor
CommonAnnotationBeanPostProcessor
RequiredAnnotationBeanPostProcessor
PersistenceAnnotationBeanPostProcessor

...

5、BeanDefinitionRegistryPostProcessor 接口

BeanDefinitionRegistryPostProcessor 接口可以看作是BeanFactoryPostProcessor和ImportBeanDefinitionRegistrar的功能集合，既可以獲取和修改BeanDefinition的元數據，也可以實現BeanDefinition的注冊、移除等操作。

例子：

定義一個BeanDefinitionRegistryPostProcessor==>ConcreteBeanDefinitionRegistryPostProcessor

@Component
public class ConcreteBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    private static final String beanName = "concreteRPBean";

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        BeanDefinition beanDefinition = BeanDefinitionBuilder
                .genericBeanDefinition(ConcreteRPBean.class)
                .getBeanDefinition();
        registry.registerBeanDefinition(beanName, beanDefinition);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
        MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
        propertyValues.addPropertyValue("author", "throwable");
    }
}

定義一個普通的Java類：

public class ConcreteRPBean {

    private String author;

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public void sayHello(){
        System.out.println(String.format("ConcreteRPBean call sayhello method ==> author %s say hello!", author));
    }
}

測試類：

@SpringBootTest(classes = Application.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class ConcreteRPBeanTest {

    @Autowired
    private ConcreteRPBean concreteRPBean;

    @Test
    public void sayHello() throws Exception {
        concreteRPBean.sayHello();
    }

}

結果：

03.png

6、FactoryBean接口

首先第一眼要注意，是FactoryBean接口而不是BeanFactory接口。一般情況下，Spring通過反射機制利用bean的class屬性指定實現類來實例化bean ，實例化bean過程比較復雜。FactoryBean接口就是為了簡化此過程，把bean的實例化定制邏輯下發給使用者。

在該接口中還定義了以下3個方法。
T getObject()：返回由FactoryBean創建的bean實例，如果isSingleton()返回true，則該實例會放到Spring容器中單實例緩存池中。
boolean isSingleton()：返回由FactoryBean創建的bean實例的作用域是singleton還是prototype。
Class<T> getObjectType()：返回FactoryBean創建的bean類型。

注意一點：通過Spring容器的getBean()方法返回的不是FactoryBean本身，而是FactoryBean#getObject()方法所返回的對象，相當于FactoryBean#getObject()代理了getBean()方法。如果希望獲取CarFactoryBean的實例，則需要在使用getBean(beanName) 方法時在beanName前顯示的加上 "&" 前綴。

一個例子：

實體類：

public class Fruit {

    private String name;
    private String color;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Fruit{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

自定義FactoryBean:

@Component
public class FruitFactoryBean implements FactoryBean<Fruit> {

    @Override
    public Fruit getObject() throws Exception {
        Fruit fruit = new Fruit();
        fruit.setColor("red");
        fruit.setName("apple");
        return fruit;
    }

    @Override
    public Class<?> getObjectType() {
        return Fruit.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

測試類：

@SpringBootTest(classes = Application.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class FruitFactoryBeanTest {

    @Autowired
    private FruitFactoryBean fruitFactoryBean;

    @Autowired
    private ApplicationContext applicationContext;

    @Test
    public void getObject() throws Exception {
        //直接通過#getObject獲取實例
        Fruit apple = fruitFactoryBean.getObject();
        System.out.println(apple.toString());
        //通過Spring上下文獲取實例
        Fruit fruit = (Fruit) applicationContext.getBean("fruitFactoryBean");
        System.out.println(fruit);
        //獲取FruitFactoryBean自身的實例
        FruitFactoryBean bean = (FruitFactoryBean) applicationContext.getBean("&fruitFactoryBean");
        System.out.println(bean);
    }

}

結果：

04.png

結果和預期一樣，通過ApplicationContext#getBean(beanName)獲取到的實際上是FactoryBean#getObject的實例，ApplicationContext#getBean(“&” + beanName)獲取到的才是FruitFactoryBean本身的實例。

7.ApplicationListener

ApplicationListener是一個接口，里面只有一個onApplicationEvent(E event)方法，這個泛型E必須是ApplicationEvent的子類，而ApplicationEvent是Spring定義的事件，繼承于EventObject，構造要求必須傳入一個Object類型的source，這個source可以作為一個存儲對象。將會在ApplicationListener的onApplicationEvent里面得到回調。如果在上下文中部署一個實現了ApplicationListener接口的bean，那么每當在一個ApplicationEvent發布到 ApplicationContext時，這個bean得到通知。其實這就是標準的Oberver設計模式。另外，ApplicationEvent的發布由ApplicationContext通過#publishEvent方法完成。其實這個實現從原理和代碼上看都有點像Guava的eventbus。

貼一個例子：
EmailEvent:

public class EmailEvent extends ApplicationEvent {

    private String author;
    private String content;
    private String date;

    public EmailEvent(Object source, String author, String content, String date) {
        super(source);
        this.author = author;
        this.content = content;
        this.date = date;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }
}

EmailApplicationListener：

@Component
public class EmailApplicationListener implements ApplicationListener<EmailEvent> {

    @Override
    public void onApplicationEvent(EmailEvent event) {
        System.out.println("EmailApplicationListener callback!!");
        System.out.println("EmailEvent --> source: " + event.getSource());
        System.out.println("EmailEvent --> author: " + event.getAuthor());
        System.out.println("EmailEvent --> content: " + event.getContent());
        System.out.println("EmailEvent --> date: " + event.getDate());
    }
}

測試類：

@SpringBootTest(classes = Application.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class EmailApplicationListenerTest {

    @Autowired
    private ApplicationContext applicationContext;

    @Test
    public void onApplicationEvent() throws Exception {
        applicationContext.publishEvent(new EmailEvent("this is source",
                "throwable","here is emailEvent","2017-5-16"));
    }

}

控制臺輸出：

EmailApplicationListener callback!!
EmailEvent --> source: this is source
EmailEvent --> author: throwable
EmailEvent --> content: here is emailEvent
EmailEvent --> date: 2017-5-16

然后發覺簡書竟然沒有markdown的[toc]，有點不方便，吐槽一下。

Updated on 2017-5-16 23:56.
Help yourselves!
我是throwable,在廣州奮斗,白天上班,晚上和雙休不定時加班,晚上有空堅持寫下博客。
希望我的文章能夠給你帶來收獲,共勉。