执行时机

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, "No ConfigurableListableBeanFactory set");
    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, final Class<?> 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));

    ConfigurableApplicationContext context = this.applicationContext;
    Assert.state(context != null, "No ApplicationContext set");
    List<EventListenerFactory> factories = this.eventListenerFactories;
    Assert.state(factories != null, "EventListenerFactory List not initialized");
     for (Method method : annotatedMethods.keySet()) {//遍历所有被@EventListener注解的方法
      for (EventListenerFactory factory : factories) {
       if (factory.supportsMethod(method)) {//判断工厂类是否支持该方法
        Method methodToUse = AopUtils.selectInvocableMethod(method, context.getType(beanName));
                       //利用工厂生成一个ApplicationListener实例
        ApplicationListener<?> applicationListener =
          factory.createApplicationListener(beanName, targetType, methodToUse);
                       //将生成的ApplicationListener实例注册到Spring事件广播器上
        if (applicationListener instanceof ApplicationListenerMethodAdapter) {
         ((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(final HttpRequest request, final byte[] body,
  final ClientHttpRequestExecution execution) throws IOException {
 final URI originalUri = request.getURI();
 String serviceName = originalUri.getHost();
 Assert.state(serviceName != null,
   "Request URI does not contain a valid hostname: " + originalUri);
 return this.loadBalancer.execute(serviceName,
   this.requestFactory.createRequest(request, body, execution));
}