Spring源码深度解析

5.2 缓存中获取单例bean

单例在Spring的同一个容器中只会被创建一次，后续在获取bean直接从单例缓存中获取，当然这里也只是尝试加载，首先尝试从缓存中加载，然后在尝试从singletonFactories中加载。因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，Spring创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光加入到缓存中，一旦下一个bean创建时需要依赖上个bean，则直接使用ObjectFactory

AbstractBeanFactory.doGetBean()
    public Object DefaultSingletonBeanRegistry.getSingleton(String beanName) {
        //参数true设置允许早期依赖
        return getSingleton(beanName, true);
    }
    //DefaultSingletonBeanRegistry
    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        //检查缓存中是否存在实例
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            //为空，则锁定全局变量进行处理
            synchronized (this.singletonObjects) {
                //如果次bean正在加载则不做处理
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    //当某些方法提前初始化的时候会调用 addSingletonFactory 将对应的ObjectFactory 初始化策略存储在singletonFactories
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }

上述方法涉及到循环依赖的检查，以及设计很多变量的记录存取。这个方法首先尝试从singletonObject里面获取实例，如果获取不到再从earlySingletonObjects里面获取，如果还获取不到，再尝试从singletonFactories里面后去beanName对应的ObjectFactory,然后调用ObjectFactory的getObject来创建bean，并放到earlySingletonObjects里面，并且从singletonFactories里面remove掉这个ObjectFactory。
这里涉及用于存储bean的不同map

• singletonObjects：用于保存BeanName和创建bean实例之间的关系，bean name->bean instance
• earlySingletonObjects：用于保存beanName和创建bean实例之间的关系，与singletonObjects的不同之处在于，当一个单例bean被放到这里面后，那么当bean还在创建过程中，就可以通过getBean方法获取到了，其目的是用来检查循环引用。
• singletonFactories：用于保存BeanName和创建bean工厂之间的关系

5.3 从bean的实例中获取对象

在getBean方法中，getObjectForBeanInstance 是个高频使用的方法。总之，我们得到bean的实例后要做的第一步就是调用这个方法来检测一下正确性。其实就是检测当前bean是否是FactoryBean类型的Bean，如果是，那么需要调用该bean对应的FactoryBean实例中的getObject作为返回值。
无论从缓存中获取到的bean还是通过不同的scope策略加载到的bean都只是最原始的bean状态，并不一定是我们最终想要的bean。举个例子，假如我们需要对工厂bean进行处理，那么这里得到的其实是工厂bean的初始状态，但是我们真正需要的是工厂bean中定义的factory-method方法返回的bean 。而getObjectForBeanInstance就是完成这个工作的。

AbstractAutowireCapableBeanFactory.java

    @Override
    protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
        return applyBeanPostProcessorsAfterInitialization(object, beanName);
    }
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {
        Object result = existingBean;
        for (BeanPostProcessor processor : getBeanPostProcessors()) {
            Object current = processor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

Spring在获取bean的规则中有这样一条：尽可能保证所有bean初始化后调用注册的BeanPostProcessor的postProcessAfterInitialization方法进行处理，这在实际开发中可以针对此特性设计自己的业务逻辑。

5.7.4 初始化bean

bean的配置中有个init-method的属性，这个属性的作用是在bean实例化前调用init-method指定的方法根据用户业务执行相应的实例化。

AbstractAutowireCapableBeanFactory.java

    protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                invokeAwareMethods(beanName, bean);
                return null;
            }, getAccessControlContext());
        }
        else {
            //对特殊的bean处理：Aware BeanClassLoadWare BeanFactoryAware
            invokeAwareMethods(beanName, bean);
        }
        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            //应用后处理器
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }
        try {
            //激活用户自定义init方法
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }
        if (mbd == null || !mbd.isSynthetic()) {
            //后处理器应用
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        return wrappedBean;
    }

1 激活Aware方法

spring提供了一些相关接口，比如BeanFactoryAware ApplicationContextAware ResourceLoaderAware 等。这些Aware接口的bean在被初始化之后，可以取得一些响应的资源，例如在实现BeanFactoryAware的bean在初始化后，Spring容器将注入BeanFactory实例。

public class Test implements BeanFactoryAware {
    private BeanFactory beanFactory;
    //声明 bean的时候 spring 自动注册 BeanFactory
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }
    public void testAware(){
        //从 beanFactory中获取
        final Helllo hello = (Helllo) beanFactory.getBean("hello");
        hello.say();
    }
}

2 处理器的应用

BeanPostProcessor，这是spring中一个亮点，给用户充足的权限去更改和扩展spring。BeanPostProcessor的使用位置：在调用客户自定义初始化方法前以及调用自定义初始化方法后分别调用BeanPostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization。使用户可以根据自己的业务需求进行响应的处理。

3 激活自动定义的init方法

客户定制的初始化方法除了我们熟知的使用配置init-method之外，还有使用自定义的bean实现InitializingBean 接口，并在afterPropertiesSet 中实现自己的初始化业务逻辑。
init-method 与afterPropertiesSet 都是在初始化bean时执行，执行顺序是 afterPropertiesSet 先执行，而init-method 后执行。

AbstractAutowireCapableBeanFactory.java

    protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
            throws Throwable {
        boolean isInitializingBean = (bean instanceof InitializingBean);
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (logger.isTraceEnabled()) {
                logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }
            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                        ((InitializingBean) bean).afterPropertiesSet();
                        return null;
                    }, getAccessControlContext());
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                //属性初始化后的处理
                ((InitializingBean) bean).afterPropertiesSet();
            }
        }
        if (mbd != null && bean.getClass() != NullBean.class) {
            String initMethodName = mbd.getInitMethodName();
            if (StringUtils.hasLength(initMethodName) &&
                    !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                    !mbd.isExternallyManagedInitMethod(initMethodName)) {
                //调用自定义初始化方法
                invokeCustomInitMethod(beanName, bean, mbd);
            }
        }
    }