Spring扩展点之SmartInitializingSingleton接口

执行时机

SmartInitializingSingleton主要用于在IoC容器基本启动完成时进行扩展，这时非Lazy的Singleton都已被初始化完成。所以，在该扩展点执行ListableBeanFactory#getBeansOfType()等方法不会出现因过早加载Bean出现副作用。这个扩展点Spring 4.1开始引入，其定义如下：

public interface SmartInitializingSingleton {
    void afterSingletonsInstantiated();
}

这个扩展点，可能和我们平时采用事件监听机制ApplicationListener<ContextRefreshedEvent>监听容器启动完成事件功能很类似。现在我们来看下该扩展点触发代码位置，是在DefaultListableBeanFactory#preInstantiateSingletons()方法中最后执行：

for (String beanName : beanNames) {
    Object singletonInstance = getSingleton(beanName);
    //如果实现SmartInitializingSingleton接口，则执行其afterSingletonsInstantiated方法
    if (singletonInstance instanceof SmartInitializingSingleton) {
        SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                smartSingleton.afterSingletonsInstantiated();
                return null;
            }, getAccessControlContext());
        }
        else {
            smartSingleton.afterSingletonsInstantiated();
        }
    }
}

使用场景

Spring中有个SmartInitializingSingleton接口实现类：

EventListenerMethodProcessor，主要用于完成@EventListener注解方式的事件监听。在Spring中需要监听某个事件常规方式是实现ApplicationListener接口，Spring IoC容器启动时自动会收集系统中所有ApplicationListener资料，并将其注册到Spring的事件广播器上，采用典型的订阅/发布模式。Spring 4.2引入了@EventListener注解方式，可以更加方便的对事件进行监听，使用方式如下如下，只需要在方法上使用@EventListener注解，并在方法参数上指定需要监听的事件类型即可：

@EventListener
public void onEvent(ContextRefreshedEvent event){
    System.out.println("===receive ContextRefreshedEvent===");
}

@EventListener注解的背后，Spring做了哪些工作以支持该注解功能呢？

1、首先，定义一个扩展类EventListenerMethodProcessor，继承SmartInitializingSingleton接口：

public class EventListenerMethodProcessor
  implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor

2、当IoC容器完成所有单实例Bean的初始化工作后，触发afterSingletonsInstantiated()方法执行：

public void afterSingletonsInstantiated() {
    ConfigurableListableBeanFactory beanFactory = this.beanFactory;
    Assert.state(this.beanFactory != null, "NoConfigurableListableBeanFactoryset");
    String[] beanNames = beanFactory.getBeanNamesForType(Object.class);
    for (String beanName : beanNames) {
        if (!ScopedProxyUtils.isScopedTarget(beanName)) {
            ...
                processBean(beanName, type);
            ...
            }
    }
}

该方法中，获取所有IoC容器中的实例，然后遍历使用processBean()方法进行处理，其核心代码见下面：

private void processBean(final String beanName, finalClass<?> targetType) {
    if (!this.nonAnnotatedClasses.contains(targetType) &&
        AnnotationUtils.isCandidateClass(targetType, EventListener.class) &&
        !isSpringContainerClass(targetType)) {

        Map<Method, EventListener> annotatedMethods = null;

        //查找Class上所有被@EventListener注解的方法
        annotatedMethods = MethodIntrospector.selectMethods(targetType,
                                                            (MethodIntrospector.MetadataLookup<EventListener>) method ->
                                                            AnnotatedElementUtils.findMergedAnnotation(method, EventListener.class));

        ConfigurableApplicationContextcontext = this.applicationContext;
        Assert.state(context != null, "No ApplicationContext set");
        List<EventListenerFactory> factories = this.eventListenerFactories;
        Assert.state(factories != null, "EventListenerFactory List not initialized");
        for (Methodmethod:
             annotatedMethods.keySet()) {//遍历所有被@EventListener注解的方法
            for (EventListenerFactory factory : factories) {
                if (factory.supportsMethod(method)) {//判断工厂类是否支持该方法
                    MethodmethodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
                    //利用工厂生成一个ApplicationListener实例
                    ApplicationListener<?> applicationListener =
                        factory.createApplicationListener(beanName, targetType, methodToUse);
                    //将生成的ApplicationListener实例注册到Spring事件广播器上
                    if (applicationListenerinstanceofApplicationListenerMethodAdapter) {
                        ((ApplicationListenerMethodAdapter) applicationListener).init(context, this.evaluator);
                    }
                    context.addApplicationListener(applicationListener);
                    break;
                }
            }
        }
    }
}

大致逻辑就是：

查找Class里有被@EventListener注解的方法，存储到Map<Method, EventListener> annotatedMethods中；
然后遍历Map，对每个@EventListener注解方法，使用EventListenerFactory工厂模式创建一个ApplicationListener实例，默认这里是ApplicationListenerMethodAdapter类型；
最后使用context.addApplicationListener向Spring注册事件监听器；

所以，当Spring中触发事件时，会调用ApplicationListenerMethodAdapter#onApplicationEvent()方法，而该方法内部通过反射最终可以调用到@EventListener注解方法，因为ApplicationListenerMethodAdapter内部持有@EventListener注解方法对应的Method，以及该方法所处Bean的name信息。这样，就间接实现了将@EventListener方法包装成了ApplicationListener对象。

还比如，Spring Cloud Ribbon组件中，LoadBalancerAutoConfiguration自动装配类中，就向Spring中注入了一个SmartInitializingSingleton实现类，利用该实现类，当IoC容器要启动完成时，将所有带有@LoadBalanced注解的RestTemplate对象利用RestTemplateCustomizer进行定制处理：

@LoadBalanced
@Autowired(required = false)
private List<RestTemplate> restTemplates = Collections.emptyList();

@Autowired(required = false)
private List<LoadBalancerRequestTransformer> transformers = Collections.emptyList();

@Bean
public SmartInitializingSingleton loadBalancedRestTemplateInitializerDeprecated(final ObjectProvider<List<RestTemplateCustomizer>> restTemplateCustomizers) {
    return () -> restTemplateCustomizers.ifAvailable(customizers -> {
        for (RestTemplate restTemplate : LoadBalancerAutoConfiguration.this.restTemplates) {
            for (RestTemplateCustomizer customizer : customizers) {
                customizer.customize(restTemplate);
            }
        }
    });
}

而常见的处理就是，给RestTemplate添加一个LoadBalancerInterceptor类型的拦截器:

@ConditionalOnMissingBean
public RestTemplateCustomizer restTemplateCustomizer(final LoadBalancerInterceptor loadBalancerInterceptor) {
    return restTemplate -> {
        List<ClientHttpRequestInterceptor> list = new ArrayList(
            restTemplate.getInterceptors());
        list.add(loadBalancerInterceptor);
        restTemplate.setInterceptors(list);
    };
}

该拦截器会拦截RestTemplate请求，从url地址中解析出需要请求的serviceId，当该serviceId对应多台主机时，Ribbon就会根据一定策略指定其中一台，这样就实现负载均衡功能。

public ClientHttpResponse intercept(finalHttpRequestrequest, finalbyte[] body, finalClientHttpRequestExecutionexecution) throws IOException {
    finalURIoriginalUri = request.getURI();
    StringserviceName = originalUri.getHost();
    Assert.state(serviceName != null,
                 "RequestURI does not contain a valid hostname:" + originalUri);
    returnthis.loadBalancer.execute(serviceName,
                                    this.requestFactory.createRequest(request, body, execution));
}