Spring核心接口InitializingBean与SmartInitializingSingleton

Spring核心接口InitializingBean与SmartInitializingSingleton

SmartInitializingSingleton中只有一个接口afterSingletonsInstantiated()，其作用是是 在spring容器管理的所有单例对象（非懒加载对象）初始化完成之后调用的回调接口。具体实现如下：

DefaultListableBeanFactory.preInstantiateSingletons(){
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
        // Trigger initialization of all non-lazy singleton beans...
        for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) {
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    if (bean instanceof FactoryBean) {
                        final FactoryBean<?> factory = (FactoryBean<?>) bean;
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                            ((SmartFactoryBean<?>) factory)::isEagerInit,
                                    getAccessControlContext());
                        }
                        else {
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean<?>) factory).isEagerInit());
                        }
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                }
                else {
                    getBean(beanName);
                }
            }
        }

        // Trigger post-initialization callback for all applicable beans...
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                        //关键代码
                        smartSingleton.afterSingletonsInstantiated();
                        return null;
                    }, getAccessControlContext());
                }
                else {
                    //关键代码，
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }
}

InitializingBean

public interface InitializingBean {
    void afterPropertiesSet() throws Exception;
}

1、InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。
2、spring初始化bean的时候，如果bean实现了InitializingBean接口，会自动调用afterPropertiesSet方法。
3、在Spring初始化bean的时候，如果该bean实现了InitializingBean接口，并且同时在配置文件中指定了init-method，系统则是先调用afterPropertieSet()方法，然后再调用init-method中指定的方法。

扩展：

• Spring为bean提供了两种初始化bean的方式，实现InitializingBean接口，实现afterPropertiesSet方法，或者在配置文件中通过init-method指定，两种方式可以同时使用。
• 实现InitializingBean接口是直接调用afterPropertiesSet方法，比通过反射调用init-method指定的方法效率要高一点，但是init-method方式消除了对spring的依赖。
• 如果调用afterPropertiesSet方法时出错，则不调用init-method指定的方法。

Springboot核心SPI扩展机制 spring.factories机制

作用：把自定义Bean类，注入到spring容器中，与@Import注解功能类似

原理：SpringFactoriesLoader类

public final class SpringFactoriesLoader {

	public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
	
	private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
	        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
	        if (result != null) {
	            return result;
	        } else {
	            try {
	                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
	                LinkedMultiValueMap result = new LinkedMultiValueMap();
	
	                while(urls.hasMoreElements()) {
	                    URL url = (URL)urls.nextElement();
	                    UrlResource resource = new UrlResource(url);
	                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
	                    Iterator var6 = properties.entrySet().iterator();
	
	                    while(var6.hasNext()) {
	                        Entry<?, ?> entry = (Entry)var6.next();
	                        String factoryTypeName = ((String)entry.getKey()).trim();
	                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
	                        int var10 = var9.length;
	
	                        for(int var11 = 0; var11 < var10; ++var11) {
	                            String factoryImplementationName = var9[var11];
	                            result.add(factoryTypeName, factoryImplementationName.trim());
	                        }
	                    }
	                }
	
	                cache.put(classLoader, result);
	                return result;
	            } catch (IOException var13) {
	                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
	            }
	        }
	    }
}