Spring 源码解析三：Bean 的注册、解析、实例化机制

Spring 源码解析三：Bean 的注册、解析、实例化机制

上一篇解析了上下文组件(WebApplicationContext)，但留下一些点待解析：

• ConfigurableListableBeanFactory如何加载、实例化 bean
• ResourceEditorRegistrar如何注册属性编辑器、属性编辑器如何解析为对象
• PathMatchingResourcePatternResolver如何解析、加载 locationPattern 指定的资源
• PropertySourcesPropertyResolver如何是解析路径的
• XmlBeanDefinitionReader如何是解析 bean 定义的
• AnnotatedBeanDefinitionReader是如何注册 bean 的
• ClassPathBeanDefinitionScanner是如何扫描包的

Bean 的注册、解析、实例化主要是 ConfigurableListableBeanFactory 完成的，但ConfigurableListableBeanFactory只是一个接口，DefaultListableBeanFactory 是其默认实现

先来看看 DefaultListableBeanFactory 的继承关系

- SimpleAliasRegistry
  - DefaultSingletonBeanRegistry
    - FactoryBeanRegistrySupport
      - AbstractBeanFactory
        - AbstractAutowireCapableBeanFactory
          - DefaultListableBeanFactory

1. SimpleAliasRegistry

SimpleAliasRegistry
简单的 bean 别名管理器

public class SimpleAliasRegistry implements AliasRegistry {}

先来看看接口AliasRegistry

public interface AliasRegistry {
    // 注册bean别名
    void registerAlias(String name, String alias);

    // 移除bean别名
    void removeAlias(String alias);

    // 检查是否是bean别名
    boolean isAlias(String name);

    // 获取bean别名
    String[] getAliases(String name);
}

SimpleAliasRegistry
是 AliasRegistry 的简单实现

public class SimpleAliasRegistry implements AliasRegistry {
    // 别名容器，使用ConcurrentHashMap实现
    private final Map aliasMap = new ConcurrentHashMap<>(16);

    @Override
    public void registerAlias(String name, String alias) {
        synchronized (this.aliasMap) {
            if (alias.equals(name)) {
                // 如果名字与别名相同，则删除别名
                this.aliasMap.remove(alias);
            }
            else {
                // 载入别名
                this.aliasMap.put(alias, name);
            }
        }
    }

    @Override
    public void removeAlias(String alias) {
        synchronized (this.aliasMap) {
            String name = this.aliasMap.remove(alias);
        }
    }

    @Override
    public boolean isAlias(String name) {
        return this.aliasMap.containsKey(name);
    }

    @Override
    public String[] getAliases(String name) {
        List result = new ArrayList<>();
        synchronized (this.aliasMap) {
            // 根据名字反向找别名
            retrieveAliases(name, result);
        }
        return StringUtils.toStringArray(result);
    }
}

2. DefaultSingletonBeanRegistry

DefaultSingletonBeanRegistry
默认的单例管理器

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {}

先来看看接口SingletonBeanRegistry

public interface SingletonBeanRegistry {
    // 注册单例bean
    void registerSingleton(String beanName, Object singletonObject);

    // 获取单例bean
    Object getSingleton(String beanName);
}

DefaultSingletonBeanRegistry
是 SingletonBeanRegistry 的默认实现

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    // 单例对象Map: bean name => bean instance
    private final Map singletonObjects = new ConcurrentHashMap<>(256);

    // 单例生成工厂Map: bean name => ObjectFactory
    private final Map> singletonFactories = new HashMap<>(16);

    // 单例对象Map: bean name => bean instance（解决循环依赖）
    private final Map earlySingletonObjects = new ConcurrentHashMap<>(16);

    // 已注册单例对象bean name集合
    private final Set registeredSingletons = new LinkedHashSet<>(256);

    // 可销毁单例对象Map: bean name => bean instance
    private final Map disposableBeans = new LinkedHashMap<>();

    // 单例对象拥有内部单例集合Map: bean name => bean instance set（比如class是一个bean，class内部的方法也是一个bean）
    private final Map> containedBeanMap = new ConcurrentHashMap<>(16);

    // 单例对象的被依赖集合Map: bean name => bean instance set（其他bean依赖这个bean）
    private final Map> dependentBeanMap = new ConcurrentHashMap<>(64);

    // 单例对象的依赖集合Map: bean name => bean instance set
    private final Map> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
}

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    // 注入单例对象，如果已存在，则报错
    @Override
    public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
        synchronized (this.singletonObjects) {
            Object oldObject = this.singletonObjects.get(beanName);
            if (oldObject != null) {
                throw new IllegalStateException("Could not register object [" + singletonObject +
                        "] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
            }
            addSingleton(beanName, singletonObject);
        }
    }

    protected void addSingleton(String beanName, Object singletonObject) {
        synchronized (this.singletonObjects) {
            // 注入，临时和定义都去掉
            this.singletonObjects.put(beanName, singletonObject);
            this.singletonFactories.remove(beanName);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    // 获取单例
    public Object getSingleton(String beanName) {
        return getSingleton(beanName, true);
    }

    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        // 先尝试从singletonObjects中获取
        Object singletonObject = this.singletonObjects.get(beanName);
        // 如果没有，单例已经在创建中，还没有完成
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            // 从早期集合中找（可能依赖没有完成）
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                // 如果仍然没有，锁住singletonObjects对象，从singletonFactories中创建
                synchronized (this.singletonObjects) {
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
                            ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                            if (singletonFactory != null) {
                                // 从创建工厂创建单例对象
                                singletonObject = singletonFactory.getObject();
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }
        return singletonObject;
    }

    // 获取单例，如果不存在，就用singletonFactory创建一个新的
    public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
        synchronized (this.singletonObjects) {
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                boolean newSingleton = false;
                try {
                    // ... 代码省略
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                }
                catch (IllegalStateException ex) {
                    // ... 代码省略
                }
                catch (BeanCreationException ex) {
                    // ... 代码省略
                }
                finally {
                    // ... 代码省略
                }
                if (newSingleton) {
                    addSingleton(beanName, singletonObject);
                }
            }
            return singletonObject;
        }
    }
}

3. FactoryBeanRegistrySupport

FactoryBeanRegistrySupport
的主要功能是实现对 FactoryBean
的支持

先来看看接口 FactoryBean 有哪些方法

public interface FactoryBean {
    // 获取对象实例
    T getObject() throws Exception;

    // 获取对象类型
    Class getObjectType();
}

与 DefaultSingletonBeanRegistry
中的对象生成接口 ObjectFactory
不同的是，FactoryBean 多了一个 getObjectType 用来获取对象类型，这样就可以不用实例化也可以知道 bean 的类型，这对诸如 autowiring 自动装配对象这类功能非常有用

来看看 FactoryBeanRegistrySupport 的具体实现

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {
    // FactoryBeans实例缓存: FactoryBean name => object
    private final Map factoryBeanObjectCache = new ConcurrentHashMap<>(16);

    // 获取factoryBean所代表的bean的类型
    protected Class getTypeForFactoryBean(FactoryBean factoryBean) {
        try {
            // 如果有JVM安全检查，绕过
            if (System.getSecurityManager() != null) {
                return AccessController.doPrivileged(
                        (PrivilegedAction>) factoryBean::getObjectType, getAccessControlContext());
            }
            else {
                return factoryBean.getObjectType();
            }
        }
        catch (Throwable ex) {
            // ... 代码省略
        }
    }

    // 获取factoryBean所代表的bean的实例
    protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName, boolean shouldPostProcess) {
        // 如果是单例，并且已经创建过
        if (factory.isSingleton() && containsSingleton(beanName)) {
            // 锁住父类的singletonObjects
            synchronized (getSingletonMutex()) {
                Object object = this.factoryBeanObjectCache.get(beanName);
                if (object == null) {
                    // 创建实例
                    object = doGetObjectFromFactoryBean(factory, beanName);
                    // 并发处理，有其他线程创建了，就舍弃自己创建的
                    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                    if (alreadyThere != null) {
                        object = alreadyThere;
                    }
                    else {
                        if (shouldPostProcess) {
                            // ... 代码省略
                            try {
                                object = postProcessObjectFromFactoryBean(object, beanName);
                            }
                            catch (Throwable ex) {
                                // ... 代码省略
                            }
                            finally {
                                // ... 代码省略
                            }
                        }
                        if (containsSingleton(beanName)) {
                            this.factoryBeanObjectCache.put(beanName, object);
                        }
                    }
                }
                return object;
            }
        }
        else {
            // 如果非单例，或者单例未创建过，直接创建
            Object object = doGetObjectFromFactoryBean(factory, beanName);
            if (shouldPostProcess) {
                try {
                    // 后置处理
                    object = postProcessObjectFromFactoryBean(object, beanName);
                }
                catch (Throwable ex) {
                    // ... 代码省略
                }
            }
            return object;
        }
    }

    // 创建bean
    private Object doGetObjectFromFactoryBean(FactoryBean factory, String beanName) throws BeanCreationException {
        Object object;
        try {
            // 如果有JVM安全检查，绕过
            if (System.getSecurityManager() != null) {
                AccessControlContext acc = getAccessControlContext();
                try {
                    object = AccessController.doPrivileged((PrivilegedExceptionAction