从源码了解spring bean实例化过程

初始化示例

我们先来看下spring如何手动初始化一个对象

ClassPathResource res = new ClassPathResource("beans.xml");
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
reader.loadBeanDefinitions(res);
User user=(User) factory.getBean("user");

spring源码解析

所以我们先从DefaultListableBeanFactory开始了解

AbstractBeanFactory

public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
        return doGetBean(name, requiredType, args, false);
}

    protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {

1.去掉&开头

        final String beanName = transformedBeanName(name);

    protected String transformedBeanName(String name) {
        return canonicalName(BeanFactoryUtils.transformedBeanName(name));
    }

2.如果是单例且存在，就直接取过来

        Object bean;
        //拿到缓存的单例实例
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            ....
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }

3.不存在单例缓存里面却处于创建状态，可能是循环引用，抛出异常

        else {
            //可能是一个循环引用，因为拿不到bean但是却处于创建状态
            if (isPrototypeCurrentlyInCreation(beanName)) {
                //Requested bean is currently in creation: Is there an unresolvable circular reference?
                throw new BeanCurrentlyInCreationException(beanName);
            }

4.在父BeanFactory查找

            BeanFactory parentBeanFactory = getParentBeanFactory();
//本beanfactory找不到
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                // 找不到拿原始名去找
                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);
                }
            }

5.创建标记，（用于清除）

            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }

6.寻找bean定义信息，并针对bean定义进行验证

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

7.处理依赖信息，这里会针对xml定义中的depends-on进行处理

                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    for (String dependsOnBean : dependsOn) {
                        if (isDependent(beanName, dependsOnBean)) {
                        ....
                    registerDependentBean(dependsOnBean, beanName);
                        getBean(dependsOnBean);
                    }
                }

具体通过这个私有方法来解决依赖的假设A依赖于B，那么在创建A之前，必须保证B先被创建。在创建了B之后，这里会进行依赖信息存储。后面在递归调用一下，不过依赖关系反过来。 dependentBeanMap放 A->［B,C,D］（A所依赖的B,C,D）

private boolean isDependent(String beanName, String dependentBeanName, Set<String> alreadySeen) {
        if (alreadySeen != null && alreadySeen.contains(beanName)) {
            return false;
        }
        String canonicalName = canonicalName(beanName);
        Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
        if (dependentBeans == null) {
            return false;
        }
        if (dependentBeans.contains(dependentBeanName)) {
            return true;
        }
        for (String transitiveDependency : dependentBeans) {
            if (alreadySeen == null) {
                alreadySeen = new HashSet<String>();
            }
            alreadySeen.add(beanName);
            if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
                return true;
            }
        }
        return false;
    }

单例模式就调用getSingleton(String beanName, ObjectFactory<?> singletonFactory)

                // 单例
                if (mbd.isSingleton()) {
                    ....
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }

    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
              ....
//private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
        synchronized (this.singletonObjects) {
            Object singletonObject = this.singletonObjects.get(beanName);
                ....
                beforeSingletonCreation(beanName);
                ....
                    singletonObject = singletonFactory.getObject();
                ....
                    addSingleton(beanName, singletonObject);

            }
            return (singletonObject != NULL_OBJECT ? singletonObject : null);
        }
    }

原型模式，来一次创一个

                else if (mbd.isPrototype()) {
                    Object prototypeInstance = null;
                    try {
                        beforePrototypeCreation(beanName);
                        prototypeInstance = createBean(beanName, mbd, args);
                    }
                    finally {
                        afterPrototypeCreation(beanName);
                    }
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }

其他模式，比如scope=request

                else {
                    String scopeName = mbd.getScope();
//private final Map<String, Scope> scopes = new LinkedHashMap<String, Scope>(8);
                    final Scope scope = this.scopes.get(scopeName);
                    ....
                    try {
                        Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                            @Override
                            public Object getObject() throws BeansException {
                                beforePrototypeCreation(beanName);
                                try {
                                    return createBean(beanName, mbd, args);
                                }
                                finally {
                                    afterPrototypeCreation(beanName);
                                }
                            }
                        });
                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    }
                    ....
                }
            }
            ....
        }

8.无论哪种模式都会进入AbstractAutowireCapableBeanFactory的createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)

                ....
                RootBeanDefinition mbdToUse = mbd;
        // 解析beanDefinition，以确保bean定义中的class可以被正确解析
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        // 准备和验证配置的方法注入，若验证失败抛出BeanDefinitionValidationException
        try {
            mbdToUse.prepareMethodOverrides();
        }
        ....

        try {
            // 如果实现了InstantiationAwareBeanPostProcessor就先postProcessBeforeInstantiation(Class<?> beanClass, String beanName)->postProcessAfterInitialization(Object bean, String beanName)
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        }
        ....

        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        ....
        }
        return beanInstance;

9.Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)

    if (instanceWrapper == null) {
        //反射出类
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }            
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    mbd.resolvedTargetType = beanType;

    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                //获取所有MergedBeanDefinitionPostProcessor，调用一遍postProcessMergedBeanDefinition
                //这里将会调用@PostConstruct注解的方法
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Post-processing of merged bean definition failed", ex);
            }
            mbd.postProcessed = true;
        }
    }
    ....
    if (exposedObject != null) {
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    ....

10.Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd)

        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(new PrivilegedAction<Object>() {
                @Override
                public Object run() {
                       //setBeanName#BeanNameAware
                       //->setBeanClassLoader#BeanClassLoaderAware
                       //->setBeanFactory#BeanFactoryAware
                    invokeAwareMethods(beanName, bean);
                    return null;
                }
            }, getAccessControlContext());
        }
        else {
            invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
                    //->postProcessBeforeInitialization#BeanPostProcessor
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        try {
                        //->afterPropertiesSet#InitializingBean
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        ....

        if (mbd == null || !mbd.isSynthetic()) {
                    //->postProcessAfterInitialization#BeanPostProcessor
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        return wrappedBean;

    private void invokeAwareMethods(final String beanName, final Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware) bean).setBeanName(beanName);
            }
            if (bean instanceof BeanClassLoaderAware) {
                ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
            }
            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
            }
        }
    }

    protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
            throws Throwable {

        boolean isInitializingBean = (bean instanceof InitializingBean);
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            ....
            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                        @Override
                        public Object run() throws Exception {
                            ((InitializingBean) bean).afterPropertiesSet();
                            return null;
                        }
                    }, getAccessControlContext());
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                ((InitializingBean) bean).afterPropertiesSet();
            }
        }

        if (mbd != null) {
            String initMethodName = mbd.getInitMethodName();
            if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                    !mbd.isExternallyManagedInitMethod(initMethodName)) {
                invokeCustomInitMethod(beanName, bean, mbd);
            }
        }
    }

10.destroyBean

@Override
public void destroyBean(Object existingBean) {
   new DisposableBeanAdapter(existingBean, getBeanPostProcessors(), getAccessControlContext()).destroy();
}

@Override
public void destroy() {
    if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
        //获取所有DestructionAwareBeanPostProcessor 调用postProcessBeforeDestruction
        //@PreDestroy
        for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
            processor.postProcessBeforeDestruction(this.bean, this.beanName);
        }
    }

    //调用DisposableBean#destroy
    if (this.invokeDisposableBean) {
        if (logger.isDebugEnabled()) {
            logger.debug("Invoking destroy() on bean with name '" + this.beanName + "'");
        }
        try {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                    @Override
                    public Object run() throws Exception {
                        ((DisposableBean) bean).destroy();
                        return null;
                    }
                }, acc);
            }
            else {
                ((DisposableBean) bean).destroy();
            }
        }
        catch (Throwable ex) {
            String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'";
            //...
        }
    }
         //xml的destroy-method
    if (this.destroyMethod != null) {
        invokeCustomDestroyMethod(this.destroyMethod);
    }
    else if (this.destroyMethodName != null) {
        Method methodToCall = determineDestroyMethod();
        if (methodToCall != null) {
            invokeCustomDestroyMethod(methodToCall);
        }
    }
}

public class InitAndDestroySeqBean implements InitializingBean,DisposableBean,BeanPostProcessor,InstantiationAwareBeanPostProcessor {

    public InitAndDestroySeqBean() {
        System.out.println("构造方法");
    }

    @PostConstruct
    public void postConstruct(){
        System.out.println("@PostConstruct");
    }

    @Override public void afterPropertiesSet() throws Exception {
        System.out.println("afterPropertiesSet()#InitializingBean");

    }

    public void initMethod(){
        System.out.println("init-method");

    }

    @PreDestroy
    public void preDestroy(){
        System.out.println("@PreDestroy");
    }

    @Override public void destroy() throws Exception {
        System.out.println("destroy()#DisposableBean");
    }

    public void destroyMethod(){
        System.out.println("destroy-method");
    }

    @Override public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("postProcessBeforeInitialization(Object bean, String beanName)#BeanPostProcessor");
        return bean;
    }

    @Override public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("postProcessAfterInitialization(Object bean, String beanName)#BeanPostProcessor");
        return bean;
    }

    @Override public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
            throws BeansException {
        System.out.println("postProcessBeforeInstantiation(Class<?> beanClass, String beanName)#InstantiationAwareBeanPostProcessor");
        return null;
    }

    @Override public boolean postProcessAfterInstantiation(Object bean, String beanName)
            throws BeansException {
        System.out.println("postProcessAfterInstantiation(Object bean, String beanName)#InstantiationAwareBeanPostProcessor");

        return false;
    }

    @Override public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds,
            Object bean, String beanName) throws BeansException {
        System.out.println("postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds,\n"
                + "            Object bean, String beanName)#InstantiationAwareBeanPostProcessor");

        return null;
    }
}

20170308:11:34:52.866 [main] INFO   Using TestExecutionListeners: [org.springframework.test.context.web.ServletTestExecutionListener@49c43f4e, org.springframework.test.context.support.DirtiesContextBeforeModesTestExecutionListener@290dbf45, org.springframework.test.context.support.DependencyInjectionTestExecutionListener@12028586, org.springframework.test.context.support.DirtiesContextTestExecutionListener@17776a8, org.springframework.test.context.transaction.TransactionalTestExecutionListener@69a10787, org.springframework.test.context.jdbc.SqlScriptsTestExecutionListener@2d127a61]20170308:11:34:52.972 [main] INFO   Loading XML bean definitions from URL [file:/Users/dsc/IdeaProjects/firDemo/firdemo/web/target/classes/init.xml]
20170308:11:34:53.105 [main] INFO   Refreshing org.springframework.context.support.GenericApplicationContext@2b4a2ec7: startup date [Wed Mar 08 11:34:53 CST 2017]; root of context hierarchy
构造方法
@PostConstruct
afterPropertiesSet()#InitializingBean
init-method
beanName)#InstantiationAwareBeanPostProcessor**guavaCache
postProcessAfterInstantiation(Object bean, String beanName)#InstantiationAwareBeanPostProcessor**guavaCache
postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds,
            Object bean, String beanName)#InstantiationAwareBeanPostProcessor**guavaCache
postProcessBeforeInitialization(Object bean, String beanName)#BeanPostProcessor**guavaCache
afterPropertiesSet#InitializingBean**guavaCache
postProcessAfterInitialization(Object bean, String beanName)#BeanPostProcessor**guavaCache
20170308:11:34:53.286 [Thread-0] INFO   Closing org.springframework.context.support.GenericApplicationContext@2b4a2ec7: startup date [Wed Mar 08 11:34:53 CST 2017]; root of context hierarchy
@PreDestroy
destroy()#DisposableBean
destroy-method

Spring生命周期

通过源码我们清晰的看到

拿到应用中所有实现了InstantiationAwareBeanPostProcessor接口的类，就先postProcessBeforeInstantiation(Class<?> beanClass, String beanName)->postProcessAfterInitialization(Object bean, String beanName)

如果已经能拿到相应的bean则直接返回不进行下面的操作

本bean如果
- 实现了BeanNameAware就调用setBeanName把bean名字放入
- 实现了BeanClassLoaderAware就调用setBeanClassLoader把ClassLoader放入
- 实现了BeanFactoryAware调用setBeanFactory把BeanFactory放入
拿到应用中所有实现了BeanPostProcessor接口的类，调用postProcessBeforeInstantiation(Class<?> beanClass, String beanName)拿到bean
反射实例化bean
@PostConstruct注解的方法
本bean如果实现了InitializingBean接口，则调用afterPropertiesSet
本bean如果在xml里面配置了init-method则调用
拿到应用中所有实现了BeanPostProcessor接口的类，调用postProcessAfterInitialization(Object bean, String beanName) 拿到bean返回，就是最终在容器里面的bean
@PreDestroy注解的方法
本bean如果实现了DisposableBean则调用destroy()
本bean如果在xml里面配置了destroy-method则调用

刚才反复提到了几个接口，我们来单独看下他们的使用：

InstantiationAwareBeanPostProcessor接口

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

    Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;

    boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException;

    PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException;
}

BeanNameAware接口，通过实现这个接口可以获取到bean的id名

public interface BeanNameAware extends Aware {

   void setBeanName(String name);

}

BeanClassLoaderAware接口，可以获取到bean的ClassLoader

public interface BeanClassLoaderAware extends Aware {

   void setBeanClassLoader(ClassLoader classLoader);

}

BeanFactoryAware接口，通过实现这个接口可以获取到beanFactory

public interface BeanFactoryAware extends Aware {

   void setBeanFactory(BeanFactory beanFactory) throws BeansException;

}

ApplicationContextAware接口，获取ApplicationContext

public interface ApplicationContextAware extends Aware {

   void setApplicationContext(ApplicationContext applicationContext) throws BeansException;

}

BeanPostProcessor接口

public interface BeanPostProcessor {

    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

}

InitializingBean接口

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

DisposableBean接口

public interface DisposableBean {
    void destroy() throws Exception;
}

www1350 / javaweb