Spring源码解析(四) -- getBean(String name, Class<T> requiredType)

前言

　　早在分析beanFactoryPostProcessor的时候，就出现了BeanFactory.getBean方法，因为每一个beanFactoryPostProcessor也是spring管理的bean，也是要经过spring实例化和初始化才能够使用的，只是当时该方法还不是要分析的重点。

　　这里多提一句 在初始化过程中容易被忽略的一个方法

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

这一步是注册listener，一般可以监听spring的context容器启动完成等情况的，一般开发者也不太会用到

1 查询缓存

final String beanName = transformedBeanName(name);
        Object bean;

        // Eagerly check singleton cache for manually registered singletons.
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            if (logger.isDebugEnabled()) {
                if (isSingletonCurrentlyInCreation(beanName)) {
                    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                            "' that is not fully initialized yet - a consequence of a circular reference");
                }
                else {
                    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }

这部分是先查询该bean是否在之前有过缓存，有就直接使用了，还有一种情况是该bean是一个beanFactory那么就调用beanFactory的getObject方法

2 从父容器中初始化bean

// Fail if we're already creating this bean instance:
            // We're assumably within a circular reference.
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            // Check if bean definition exists in this factory.
            BeanFactory parentBeanFactory = getParentBeanFactory();
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // Not found -> check parent.
                String nameToLookup = originalBeanName(name);
                if (args != null) {
                    // Delegation to parent with explicit args.
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else {
                    // No args -> delegate to standard getBean method.
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
            }

代码的作用比较清晰

3 开始实例化

try {
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);

                // Guarantee initialization of beans that the current bean depends on.
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    for (String dep : dependsOn) {
                        if (isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
                        registerDependentBean(dep, beanName);
                        getBean(dep);
                    }
                }

　　先说一说这个BeanDefinition，BD只是一个接口，常用的实现类是

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
        implements BeanDefinition, Cloneable 

　　比如在容器启动的最开始通过BeanDefinitionReader读取的最原始的bd就都是AbstractBeanDefinition

　　到这里也能够看到 会把 AbstractBeanDefinition 变成了 RootBeanDefinition 

　　注意这里的mergedBeanDefinition，根据文档beanDefinition也是有继承关系的。注意不是真的类的继承关系，我写的代码测试B继承A，但是还是两个BeanDefinition。

　mergedBeanDefinitions 是在 AbstractBeanFactory里的

private final Map<String, RootBeanDefinition> mergedBeanDefinitions =
            new ConcurrentHashMap<String, RootBeanDefinition>(256);

　　而保存所有的beanDefinition是在 DefaultListableBeanFactory的 

/** Map of bean definition objects, keyed by bean name */
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);

　　总之一句话，一个beanDefinition会经过转换变成mergedBeanDefinition，尽管大多数的beanDefinition还是保持着原样。那么什么情况下会出现需要mergedBeanDefinition呢？如下这种，当然绝大多数没人这么用。

<bean id="baseUser" class="com.yh.stu.spring.sourcestu._01ioc.ch1_base.mergebd.BaseUser">
    </bean>
    <bean id="user" class="com.yh.stu.spring.sourcestu._01ioc.ch1_base.mergebd.User" parent="baseUser"/>

　　而接下来的实例化一个bean就是使用mergedBeanDefinition。

　　这里做的第二件事是实例化该bean所依赖的bean。注意这里的dependon并不是指@Autowired这种依赖注入，而是大概这种方式

<bean id="cat" class="com.lyc.cn.day08.Cat" p:name="美美" depends-on="dog"/>

<bean id="helloApi" class="com.feng.spring.chapter2.helloworld.HelloApi">
</bean>
<bean id="decorator"  
    class="cn.javass.spring.chapter3.bean.HelloApiDecorator"  
    depends-on="helloApi">  
    <property name="helloApi"><ref bean="helloApi"/></property>  
</bean>  

　　同样的上面说的mergedBeanDefinition也不是指两个类之间的继承关系，而是这种通过配置文件配出来的两个bean的关系

<bean id="parentBean" abstract="true">
        <property name="name" value="我是父亲"/>
    </bean>
    <bean id="sunBean" class="com.lyc.cn.day08.SunBean" parent="parentBean">
        <property name="age" value="18"/>
    </bean>

　　接下来就是正式的实例化过程了

4 AbstractAutowireCapableBeanFactory.createBean

第一部分 准备工作

　　if (logger.isDebugEnabled()) {
            logger.debug("Creating instance of bean '" + beanName + "'");
        }
        RootBeanDefinition mbdToUse = mbd;

        // Make sure bean class is actually resolved at this point, and
        // clone the bean definition in case of a dynamically resolved Class
        // which cannot be stored in the shared merged bean definition.
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        // Prepare method overrides.
        try {
            mbdToUse.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                    beanName, "Validation of method overrides failed", ex);
        }

        try {
            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                    "BeanPostProcessor before instantiation of bean failed", ex);
        }

　　特别注意，// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. 大多数情况下Spring的动态代理并不是在这里完成的，除非在配置文件里显式的配了

TargetSources，才会走到这里

第二部分 开始实例化

 AbstractAutowireCapableBeanFactory.doCreateBean 

// Instantiate the bean.
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }

　　真正进行实例化的代码就在 createBeanInstance 里，

　　beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent); 对于绝大部分bean来说都是通过反射，利用class拿到构造方法，再用构造方法实例化对象，这里不再展开。

　　回到doCreateBean继续分析

缓存需要依赖注入的元信息

// Allow post-processors to modify the merged bean definition.
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                            "Post-processing of merged bean definition failed", ex);
                }
                mbd.postProcessed = true;
            }
        }

　　applyMergedBeanDefinitionPostProcessors 的是就是这样的，那么  MergedBeanDefinitionPostProcessor的实现类有哪些呢？还真有一个比较有名的AutowiredAnnotationBeanPostProcessor。AutowiredAnnotationBeanPostProcessor是能够处理@Autowired和@Value这样的注解的。这也和之前介绍BeanPostProcessor里提到的呼应起来了，BeanPostProcessor有两个最特别的子类

　　1  InstantiationAwareBeanPostProcessor

　　2  MergedBeanDefinitionPostProcessor

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof MergedBeanDefinitionPostProcessor) {
                MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
                bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
            }
        }
    }

　　我们来看看 AutowiredAnnotationBeanPostProcessor的 postProcessMergedBeanDefinition干了啥。

@Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        if (beanType != null) {
            InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
            metadata.checkConfigMembers(beanDefinition);
        }
    }

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, PropertyValues pvs) {
        // Fall back to class name as cache key, for backwards compatibility with custom callers.
        String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
        // Quick check on the concurrent map first, with minimal locking.
        InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            synchronized (this.injectionMetadataCache) {
                metadata = this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                    if (metadata != null) {
                        metadata.clear(pvs);
                    }
                    try {
                        metadata = buildAutowiringMetadata(clazz);
                        this.injectionMetadataCache.put(cacheKey, metadata);
                    }

findAutowiringMetadata方法是很长的，这里只截取一段代码看看意思。

buildAutowiringMetadata构造出来一个要注入的元数据对象，同时缓存在 injectionMetadataCache里面，缓存的key就是

String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());

InjectionMetadata 是什么呢，就是一个对象里哪个属性是需要注入的（其他的由Spring管理的对象，而不是基本类型）。

这些缓存信息AutowiredAnnotationBeanPostProcessor在后续代码执行中会用到的。

　　再次回到doCreateBean继续分析

解决循环依赖的

// Eagerly cache singletons to be able to resolve circular references
        // even when triggered by lifecycle interfaces like BeanFactoryAware.
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            if (logger.isDebugEnabled()) {
                logger.debug("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            addSingletonFactory(beanName, new ObjectFactory<Object>() {
                @Override
                public Object getObject() throws BeansException {
                    return getEarlyBeanReference(beanName, mbd, bean);
                }
            });
        }

　　这部分就是解决循环依赖的关键点，把一个实例化好了的bean放进三级缓存里。

属性注入及初始化

　　最重要的两个方法，populateBean和initializeBean

　　populateBean是解决一个bean属性注入的。

　　initializeBean是调用初始化方法的，比如@PostConstruct，配置文件里的init-method，和实现了InitializingBean接口的接口方法

Object exposedObject = bean;
        try {
            populateBean(beanName, mbd, instanceWrapper);
            if (exposedObject != null) {
                exposedObject = initializeBean(beanName, exposedObject, mbd);
            }
        }
        catch (Throwable ex) {
            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
                throw (BeanCreationException) ex;
            }
            else {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
            }
        }

分析下populateBean

　　　　if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

            // Add property values based on autowire by name if applicable.
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }

            // Add property values based on autowire by type if applicable.
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }

            pvs = newPvs;
        }
　　　　　//上面的代码现在几乎不会走到，都是为了兼容老代码的，而且像@Autowired等注解也不走到里面
        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

        if (hasInstAwareBpps || needsDepCheck) {
            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            if (hasInstAwareBpps) {
                for (BeanPostProcessor bp : getBeanPostProcessors()) {//循环遍历每一个beanPostProcessor调用他们的postProcessPropertyValues
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvs == null) {
                            return;
                        }
                    }
                }
            }

　　不妨我们还是以AutowiredAnnotationBeanPostProcessor的 方法来举例

public PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {

        InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
        try {
            metadata.inject(bean, beanName, pvs);
        }
        catch (BeanCreationException ex) {
            throw ex;
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
        }
        return pvs;
    }

之前在 缓存需要依赖注入的元信息 这个小节交代过了， 实例化后会处理一个bean中的标签@Autowired并缓存起来。

现在就可以直接用了

拿到 InjectionMetadata metadata 后就调用  inject。

对于autowired来说他对应的 方法是这样的

@Override
        protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
            Field field = (Field) this.member;
            Object value;
            if (this.cached) {
                value = resolvedCachedArgument(beanName, this.cachedFieldValue);
            }
            else {
                DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
                desc.setContainingClass(bean.getClass());
                Set<String> autowiredBeanNames = new LinkedHashSet<String>(1);
                TypeConverter typeConverter = beanFactory.getTypeConverter();
                try {
                    value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);//把依赖的值解析出来
                }
                catch (BeansException ex) {
                    throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
                }
                synchronized (this) {
                    if (!this.cached) {
                        if (value != null || this.required) {
                            this.cachedFieldValue = desc;
                            registerDependentBeans(beanName, autowiredBeanNames);
                            if (autowiredBeanNames.size() == 1) {
                                String autowiredBeanName = autowiredBeanNames.iterator().next();
                                if (beanFactory.containsBean(autowiredBeanName)) {
                                    if (beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
                                        this.cachedFieldValue = new ShortcutDependencyDescriptor(
                                                desc, autowiredBeanName, field.getType());
                                    }
                                }
                            }
                        }
                        else {
                            this.cachedFieldValue = null;
                        }
                        this.cached = true;
                    }
                }
            }
            if (value != null) {
                ReflectionUtils.makeAccessible(field);
                field.set(bean, value);//反射方法直接塞进去
            }
        }

　　再说明一下另一个常用的自动注入注解@Resource，也是在 populateBean 中生效的

　　在CommonAnnotationBeanPostProcessor中方法 buildResourceMetadata中的代码段中

else if (field.isAnnotationPresent(Resource.class)) {
                        if (Modifier.isStatic(field.getModifiers())) {
                            throw new IllegalStateException("@Resource annotation is not supported on static fields");
                        }
                        if (!ignoredResourceTypes.contains(field.getType().getName())) {
                            currElements.add(new ResourceElement(field, field, null));
                        }
                    }

　　如果一个字段头顶有@Resource会保存起来，等待后续处理

上面是处理自动注入其他Bean的逻辑，最后还会执行一下属性静态值的注入，所谓的静态值就是配置文件里明确配了的值，这部分值会在装在BeanDefinition的时候就缓存在BD中

　　 applyPropertyValues(beanName, mbd, bw, pvs); 这部分就不详细说了。

initializeBean

　　到了执行初始化方法的时候了，这里说的初始化有三种，@PostConstruct，bean实现了initializingBean接口，和配置了init-method方法，这三种情况的执行。

　　先看代码

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(new PrivilegedAction<Object>() {
                @Override
                public Object run() {
                    invokeAwareMethods(beanName, bean);
                    return null;
                }
            }, getAccessControlContext());
        }
        else {
            invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);//就在这里执行的@PostConstruct
        }

        try {
            invokeInitMethods(beanName, wrappedBean, mbd);//先initializingBean接口，而后才是init-method方法

        }
        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原bean
        }
        return wrappedBean;
    }

调用applyBeanPostProcessorsBeforeInitialization过程中会调用InitDestroyAnnotationBeanPostProcessor.postProcessBeforeInitialization

InitDestroyAnnotationBeanPostProcessor实现了接口 MergedBeanDefinitionPostProcessor 所以呢？在一个Bean实例化成一个空对象的时候，首先就执行过一次

MergedBeanDefinitionPostProcessor的 postProcessMergedBeanDefinition 对元数据进行了缓存，此时就正好拿出来直接使用了

@Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
        try {
            metadata.invokeInitMethods(bean, beanName);
        }
        catch (InvocationTargetException ex) {
            throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
        }
        return bean;
    }

　　最终调用 

private LifecycleMetadata buildLifecycleMetadata(final Class<?> clazz) {
        final boolean debug = logger.isDebugEnabled();
        LinkedList<LifecycleElement> initMethods = new LinkedList<LifecycleElement>();
        LinkedList<LifecycleElement> destroyMethods = new LinkedList<LifecycleElement>();
        Class<?> targetClass = clazz;

        do {
            final LinkedList<LifecycleElement> currInitMethods = new LinkedList<LifecycleElement>();
            final LinkedList<LifecycleElement> currDestroyMethods = new LinkedList<LifecycleElement>();

            ReflectionUtils.doWithLocalMethods(targetClass, new ReflectionUtils.MethodCallback() {
                @Override
                public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
                    if (initAnnotationType != null) {
                        if (method.getAnnotation(initAnnotationType) != null) {
                            LifecycleElement element = new LifecycleElement(method);
                            currInitMethods.add(element);
                            if (debug) {
                                logger.debug("Found init method on class [" + clazz.getName() + "]: " + method);
                            }
                        }
                    }

initAnnotationType是在子类中赋值的，

public CommonAnnotationBeanPostProcessor() {
        setOrder(Ordered.LOWEST_PRECEDENCE - 3);
        setInitAnnotationType(PostConstruct.class);
        setDestroyAnnotationType(PreDestroy.class);
        ignoreResourceType("javax.xml.ws.WebServiceContext");
    }

所以，处理PostConstruct的就是CommonAnnotationBeanPostProcessor。并且面试中常问的初始化顺序问题通过源码也能够知道了。

applyBeanPostProcessorsBeforeInitialization先执行，然后 invokeInitMethods才执行。所以PostConstruct最早执行。

<bean id="helloApi" class="com.feng.spring.chapter2.helloworld.HelloApi">
</bean>
<bean id="decorator"  
    class="cn.javass.spring.chapter3.bean.HelloApiDecorator"  
    depends-on="helloApi">  
    <property name="helloApi"><ref bean="helloApi"/></property>  
</bean>