spring-beanFactory二

上一篇只是将xml解析为bean definitions，这一篇来看getBean通过bean definition得到实例。

//以XmlBeanFactory为例
BeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring/spring-test.xml"));
MyBean bean = (MyBean) factory.getBean("myBean");
System.out.println(bean.getBeanName());//myBean

public class MyBean {
    private String beanName = "myBean";
    public String getBeanName() {
        return beanName;
    }
    public void setBeanName(String beanName) {
        this.beanName = beanName;
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="myBean" class="com.zyong.spring.beanfactory.MyBean"/>
</beans>

public Object getBean(String name) throws BeansException {
    //name, requiredType, args, typeCheckOnly
    return doGetBean(name, null, null, false);
}

//doGetBean会真正的实例化对象，并回调beanFactory（BeanPostProcessor）、
//bean（init，@PostConstruct和@PreDestroy通过CommonAnnotationBeanPostProcessor或开启<context:annotation-config />来支持）的相关方法
protected <T> T doGetBean(
        final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
        throws BeansException {
        
    // Eagerly check singleton cache for manually registered singletons.
    //尝试从缓存中获取，首先会尝试从singletonObjects获取，再尝试从singletonFactories中获取获取beanFactory（beanName是beanFactory的名字），如果获取到则调用getObject获得bean
    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实例中获取对象，可能是bean实例自身，如果bean实例是一个beanFactory，则返回beanFactroy创建的对象
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }else{
        // Check if bean definition exists in this factory.
        BeanFactory parentBeanFactory = getParentBeanFactory();
        //如果本beanFactory不包含该beanName的bean definition，则从父级beanFactory获取bean
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            String nameToLookup = originalBeanName(name);
            return (T) parentBeanFactory.getBean(nameToLookup, args);
        }
        
        final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
        checkMergedBeanDefinition(mbd, beanName, args);

        // Guarantee initialization of beans that the current bean depends on.
        //这里只是为当前bean注册依赖，并没有注入，注册依赖是为了在销毁当前bean之前，先销毁依赖（为了实现该功能，需要2个注册表，一个是bean->dependences，另一个是dependence->beans）
        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);
                //递归创建依赖bean
                getBean(dep);
            }
        }
        
        //从这里开始真正创建bean
        // Create bean instance.
        if (mbd.isSingleton()) {
            sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {//策略模式，ObjectFactory不同，创建bean的策略也会有差异
                @Override
                public Object getObject() throws BeansException {
                    try {
                        //重要方法
                        return createBean(beanName, mbd, args);
                    }
                    catch (BeansException ex) {
                        // Explicitly remove instance from singleton cache: It might have been put there
                        // eagerly by the creation process, to allow for circular reference resolution.
                        // Also remove any beans that received a temporary reference to the bean.
                        destroySingleton(beanName);
                        throw ex;
                    }
                }
            });
            //与之前从缓存获取bean实例类似
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        }else if(mbd.isPrototype()){
            ......
        }else{
            ......
        }
        
    }//else

}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null) {
        singletonObject = singletonFactory.getObject();//getObject会回调createBean
        //注册bean实例，即放入map中
        addSingleton(beanName, singletonObject);
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

//createBean的主要逻辑，这里就真正开始创建bean的各种“花招”了
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    // 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.
    //加载bean的class，并存入bean definition
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }
    // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    //如果bean实现了InstantiationAwareBeanPostProcessor，
    //这里就会调用InstantiationAwareBeanPostProcessor的Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)接口来创建bean，
    //如果返回非null，则继续调用boolean postProcessAfterInstantiation(Object bean, String beanName)接口
    //PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)有机会在注入前执行
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    //如果通过InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法得到一个实例，直接返回
    if (bean != null) {
        return bean;
    }
    //如果通过InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation方法无法得到一个实例，则进行常规实例化工作（实例化、注入、BeanPostProcessor等）
    //重要方法
    Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    return beanInstance;
}

//doCreateBean的主要逻辑
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
    throws BeanCreationException {
    //使用工厂方法、构造器注入、简单实例化等策略实例化bean（不是策略模式，只是通过bean definition来决定使用哪种策略，类似switch）
    //BeanWrapper是bean的包装类，beanWrapper提供了便捷的方法去更新bean的字段、访问bean的方法，用于注入
    BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);//离我们很近
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    //MergedBeanDefinitionPostProcessor的void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName)
    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    // Initialize the bean instance.
    //exposedObject即暴露的bean、原生的bean
    Object exposedObject = bean;
    //先执行InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation，
    //再执行InstantiationAwareBeanPostProcessor的postProcessPropertyValues，最后再进行xml注入。
    //所谓populateBean就是根据该bean在xml的配置信息来填充bean，这些信息已经被解析为BeanDefinition。
    populateBean(beanName, mbd, instanceWrapper);
    //什么情况下bean==null？
    if (exposedObject != null) {
        //初始化bean
        //invokeAwareMethods（回调BeanNameAware、BeanClassLoaderAware、BeanFactoryAware的相关方法）、
        //applyBeanPostProcessorsBeforeInitialization（回调BeanPostProcessor的postProcessBeforeInitialization方法）、
        //invokeInitMethods（回调InitializingBean的afterPropertiesSet，以及init-method）、
        //applyBeanPostProcessorsAfterInitialization（回调BeanPostProcessor的postProcessAfterInitialization方法）
        exposedObject = initializeBean(beanName, exposedObject, mbd);//离我们很近
    }
    // Register bean as disposable.
    registerDisposableBeanIfNecessary(beanName, bean, mbd);
}