从源码了解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");

Paste_Image.png

spring源码解析

所以我们先从DefaultListableBeanFactory开始了解

AbstractBeanFactory

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

    protected  T doGetBean(final String name, final Class 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 alreadySeen) {
        if (alreadySeen != null && alreadySeen.contains(beanName)) {
            return false;
        }
        String canonicalName = canonicalName(beanName);
        Set 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();
            }
            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 singletonObjects = new ConcurrentHashMap(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 scopes = new LinkedHashMap(8);
                    final Scope scope = this.scopes.get(scopeName);
                    ....
                    try {
                        Object scopedInstance = scope.get(beanName, new ObjectFactory