Spring DefaultListableBeanFactory源码分析

目录
一、概述
二、主要功能
三、核心功能解析
Bean定义的存储结构
ConcurrentHashMap的使用和意义
四、总结

一、概述

DefaultListableBeanFactory 是 Spring 框架中的一个核心类，它继承自AbstractAutowireCapableBeanFactory类，实现了 ListableBeanFactory 接口，并提供了一些额外的方法用于注册和获取Bean的定义。该类提供了 Spring 应用上下文中的 bean 定义和实例的管理功能。它是 Spring 容器的基础，负责管理 bean 的生命周期、依赖注入等核心功能。

二、主要功能

1. Bean 定义管理：DefaultListableBeanFactory 存储了所有的 bean 定义，这些定义通常来自于 XML 配置文件、注解或其他配置方式。
2. Bean 实例化：根据 bean 的定义，容器负责实例化它们。
3. 依赖注入：容器负责自动装配 bean 之间的依赖关系。
4. 生命周期管理：容器负责管理 bean 的生命周期，从创建到销毁。
5. 事件发布：容器负责发布与 bean 相关的各种事件，如初始化、销毁等。

三、关键代码分析

1. Bean 定义存储

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

这里使用了一个 ConcurrentHashMap 来存储所有的 bean 定义。键是 bean 的名称，值是 RootBeanDefinition 对象，它包含了 bean 的完整定义信息。
2. Bean 实例化

当需要实例化一个 bean 时，DefaultListableBeanFactory 会使用 getBean() 方法。这个方法首先检查请求的 bean 是否已经存在实例，如果存在则直接返回；如果不存在，它会调用 createBean() 方法来创建 bean 的实例。
3. 依赖注入

在创建 bean 的实例后，DefaultListableBeanFactory 会自动检测该 bean 的所有依赖项，并注入这些依赖。这个过程通过反射实现，利用了 Java 的 Field 和 Method 类来访问和修改对象的属性。
4. 事件发布

当 bean 的生命周期发生变化时（如初始化、销毁等），DefaultListableBeanFactory 会发布相应的事件。这些事件会被注册的监听器捕获并处理。事件的发布通过 Spring 的事件机制实现，基于发布-订阅模式。
5. 其他关键方法

• addBeanPostProcessor: 用于添加后处理器，可以在 bean 创建后对其进行进一步处理。
• registerBeanDefinition: 用于注册一个新的 bean 定义。
• removeBeanDefinition: 用于移除一个已注册的 bean 定义。
• getBeanNamesForType: 根据给定的类型获取所有相关的 bean 名称。
• getBeansOfType: 根据给定的类型获取所有相关的 bean 实例。
• getAliases: 获取指定名称的所有别名。

四、总结

DefaultListableBeanFactory 是 Spring 框架中非常重要的一个类，它提供了基础的 bean 管理功能，使得开发者能够专注于业务逻辑而不是底层的bean 管理。通过对它的源码分析，我们可以深入了解 Spring 的核心工作原理，从而更好地利用这个框架来构建企业级应用。

下面是DefaultListableBeanFactory的精简源码：

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements BeanDefinitionRegistry {
    
    // 用于保存Bean定义的Map
    private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();
    
    // 用于保存Bean实例的Map
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
    
    // 用于保存Bean的作用域的Map
    private final Map<String, Scope> scopes = new ConcurrentHashMap<>();
    
    // 用于保存Bean的后置处理器的List
    private final List<BeanPostProcessor> beanPostProcessors = new ArrayList<>();
    
    // 用于保存Bean的初始化方法的Map
    private final Map<String, String> initMethods = new ConcurrentHashMap<>();
    
    // 用于保存Bean的销毁方法的Map
    private final Map<String, String> destroyMethods = new ConcurrentHashMap<>();
    
    // 用于保存Bean的销毁回调的List
    private final List<Runnable> destroyCallbacks = new CopyOnWriteArrayList<>();
    
    // 用于保存Bean的依赖关系的Map
    private final Map<String, Set<String>> dependentBeans = new ConcurrentHashMap<>();
    
    // 用于保存Bean的依赖关系反转的Map
    private final Map<String, Set<String>> dependenciesForBean = new ConcurrentHashMap<>();
    
    // 用于保存Bean的别名的Map
    private final Map<String, String> aliases = new ConcurrentHashMap<>();
    
    // 用于保存Bean的类型的Map
    private final Map<String, Class<?>> types = new ConcurrentHashMap<>();
    
    // 用于保存Bean的标记的List
    private final List<String> alreadyCreated = new CopyOnWriteArrayList<>();
    
    // 用于保存Bean的ClassLoader
    private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
    
    // 用于保存Bean的属性编辑器的Map
    private final Map<Class<?>, PropertyEditor> customEditors = new ConcurrentHashMap<>();
    
    // 用于保存Bean的TypeConverter
    private TypeConverter typeConverter;
    
    // ... 其他成员变量和方法省略 ...
    
    @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
        Assert.notNull(beanName, "Bean name must not be null");
        Assert.notNull(beanDefinition, "BeanDefinition must not be null");
        if (containsBeanDefinition(beanName)) {
            throw new BeanDefinitionStoreException("Bean definition for bean '" + beanName + "' already exists");
        }
        beanDefinitionMap.put(beanName, beanDefinition);
        if (beanDefinition instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) beanDefinition).hasBeanClass()) {
            Class<?> beanClass = ((AbstractBeanDefinition) beanDefinition).getBeanClass();
            types.put(beanName, beanClass);
        }
        if (beanDefinition instanceof AnnotatedBeanDefinition) {
            MethodMetadata factoryMethodMetadata = ((AnnotatedBeanDefinition) beanDefinition).getFactoryMethodMetadata();
            if (factoryMethodMetadata != null && beanDefinition instanceof AbstractBeanDefinition) {
                ((AbstractBeanDefinition) beanDefinition).setResolvedFactoryMethod(factoryMethodMetadata);
            }
        }
        // 发布Bean定义注册事件
        if (hasBeanCreationStarted()) {
            // 如果容器已经开始创建Bean，则立即初始化该Bean
            finishBeanFactoryInitialization();
        }
    }
    
    @Override
    public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
        Assert.notNull(beanName, "Bean name must not be null");
        BeanDefinition bd = beanDefinitionMap.get(beanName);
        if (bd == null) {
            throw new NoSuchBeanDefinitionException(beanName);
        }
        return bd;
    }
    
    @Override
    public boolean containsBeanDefinition(String beanName) {
        Assert.notNull(beanName, "Bean name must not be null");
        return beanDefinitionMap.containsKey(beanName);
    }
    
    // ... 其他方法省略 ...
    
    protected void processBeanDefinition(BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
        if (beanDefinition instanceof AbstractBeanDefinition) {
            AbstractBeanDefinition abstractBeanDefinition = (AbstractBeanDefinition) beanDefinition;
            if (abstractBeanDefinition.hasBeanClass()) {
                if (!abstractBeanDefinition.isSynthetic()) {
                    validateBeanDefinition(abstractBeanDefinition);
                }
                prepareMethodOverrides(abstractBeanDefinition);
            }
        }
    }
    
    // ... 其他方法省略 ...
    
    @Override
    protected void initBeanWrapper(BeanWrapper bw) {
        bw.setConversionService(getConversionService());
    }
    
    @Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
        // 实例化Bean
        Object bean = resolveBeforeInstantiation(beanName, mbd);
        if (bean != null) {
            return bean;
        }
        return doCreateBean(beanName, mbd, args);
    }
    
    // ... 其他方法省略 ...
    
}

以上是DefaultListableBeanFactory的源码核心部分。它主要通过使用Java的集合类来存储和管理Bean的定义、实例、作用域、后置处理器等信息。它实现了BeanDefinitionRegistry接口，可以注册和获取Bean的定义。它还继承自AbstractAutowireCapableBeanFactory类，提供了创建和初始化Bean的功能。