目录
一、概述
二、主要功能
三、核心功能解析
Bean定义的存储结构
ConcurrentHashMap的使用和意义
四、总结
一、概述
DefaultListableBeanFactory 是 Spring 框架中的一个核心类，它继承自AbstractAutowireCapableBeanFactory类，实现了 ListableBeanFactory 接口，并提供了一些额外的方法用于注册和获取Bean的定义。该类提供了 Spring 应用上下文中的 bean 定义和实例的管理功能。它是 Spring 容器的基础，负责管理 bean 的生命周期、依赖注入等核心功能。
二、主要功能
- Bean 定义管理 ：
DefaultListableBeanFactory存储了所有的 bean 定义，这些定义通常来自于 XML 配置文件、注解或其他配置方式。 - Bean 实例化：根据 bean 的定义，容器负责实例化它们。
- 依赖注入：容器负责自动装配 bean 之间的依赖关系。
- 生命周期管理：容器负责管理 bean 的生命周期，从创建到销毁。
- 事件发布：容器负责发布与 bean 相关的各种事件，如初始化、销毁等。
三、关键代码分析
- Bean 定义存储
java
private final Map<String, RootBeanDefinition>
beanDefinitionMap = new ConcurrentHashMap<>(256);这里使用了一个 ConcurrentHashMap 来存储所有的 bean 定义。键是 bean 的名称，值是 RootBeanDefinition 对象，它包含了 bean 的完整定义信息。
- Bean 实例化
当需要实例化一个 bean 时，DefaultListableBeanFactory 会使用 getBean() 方法。这个方法首先检查请求的 bean 是否已经存在实例，如果存在则直接返回；如果不存在，它会调用 createBean() 方法来创建 bean 的实例。
- 依赖注入
在创建 bean 的实例后，DefaultListableBeanFactory 会自动检测该 bean 的所有依赖项，并注入这些依赖。这个过程通过反射实现，利用了 Java 的 Field 和 Method 类来访问和修改对象的属性。
- 事件发布
当 bean 的生命周期发生变化时（如初始化、销毁等），DefaultListableBeanFactory 会发布相应的事件。这些事件会被注册的监听器捕获并处理。事件的发布通过 Spring 的事件机制实现，基于发布-订阅模式。
- 其他关键方法
addBeanPostProcessor: 用于添加后处理器，可以在 bean 创建后对其进行进一步处理。registerBeanDefinition: 用于注册一个新的 bean 定义。removeBeanDefinition: 用于移除一个已注册的 bean 定义。getBeanNamesForType: 根据给定的类型获取所有相关的 bean 名称。getBeansOfType: 根据给定的类型获取所有相关的 bean 实例。getAliases: 获取指定名称的所有别名。
四、总结
DefaultListableBeanFactory 是 Spring 框架中非常重要的一个类，它提供了基础的 bean 管理功能，使得开发者能够专注于业务逻辑而不是底层的bean 管理。通过对它的源码分析，我们可以深入了解 Spring 的核心工作原理，从而更好地利用这个框架来构建企业级应用。
下面是DefaultListableBeanFactory的精简源码：
java
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的功能。