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 的 FieldMethod 类来访问和修改对象的属性。
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的功能。

你可能感兴趣的:(Spring,java,spring,java)