Spring BeanFactory体系全解
·
Spring BeanFactory体系全解
目录
- 引言
- BeanFactory接口体系
- BeanDefinition体系
- BeanPostProcessor后置处理器
- BeanFactoryPostProcessor扩展点
- FactoryBean与ObjectFactory
- BeanDefinitionRegistry注册中心
- 别名管理与BeanNameGenerator
- 源码流程解析
- 实战：自定义扩展
- 总结
引言
Spring框架的核心是IoC容器，而IoC容器的核心则是BeanFactory。理解BeanFactory及其相关接口的层次结构，是深入掌握Spring框架的必经之路。
本文将从源码层面深入剖析：
BeanFactory接口体系的完整设计BeanDefinition如何描述Bean的元数据BeanPostProcessor后置处理器的执行机制BeanFactoryPostProcessor如何修改BeanDefinitionFactoryBean与普通Bean的区别BeanDefinitionRegistry如何管理Bean注册
1. BeanFactory接口体系
1.1 核心接口层次
1.2 BeanFactory根接口
public interface BeanFactory {
/**
* Bean名称前缀常量
*/
String FACTORY_BEAN_PREFIX = "&";
/**
* 根据名称获取Bean
* @throws NoSuchBeanDefinitionException 如果不存在
*/
Object getBean(String name) throws BeansException;
/**
* 根据名称和类型获取Bean
*/
<T> T getBean(String name, Class<T> requiredType) throws BeansException;
/**
* 根据类型获取Bean
*/
<T> T getBean(Class<T> requiredType) throws BeansException;
/**
* 检查Bean是否存在
*/
boolean containsBean(String name);
/**
* 获取Bean的作用域
*/
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
/**
* 检查Bean类型
*/
boolean isTypeMatch(String name, ResolvableType typeToMatch) throws BeansException;
/**
* 获取Bean的类型
*/
Class<?> getType(String name) throws NoSuchBeanDefinitionException;
/**
* 获取Bean的所有别名
*/
String[] getAliases(String name);
}
1.3 ListableBeanFactory接口
public interface ListableBeanFactory extends BeanFactory {
/**
* 检查是否包含指定类型的Bean
*/
boolean containsBeanDefinition(Class<?> beanClass);
/**
* 获取所有BeanDefinition的数量
*/
int getBeanDefinitionCount();
/**
* 获取所有BeanDefinition的名称
*/
String[] getBeanDefinitionNames();
/**
* 根据类型获取Bean名称数组
*/
String[] getBeanNamesForType(ResolvableType type);
/**
* 根据类型获取Bean实例
*/
<T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;
/**
* 根据注解获取Bean名称
*/
String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);
/**
* 根据注解获取Bean
*/
Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType)
throws BeansException;
/**
* 查找指定Bean上的注解
*/
<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
throws NoSuchBeanDefinitionException;
}
1.4 HierarchicalBeanFactory接口
public interface HierarchicalBeanFactory extends BeanFactory {
/**
* 获取父BeanFactory
*/
BeanFactory getParentBeanFactory();
/**
* 检查当前容器是否包含指定Bean（不包含父容器）
*/
boolean containsLocalBean(String name);
}
1.5 AutowireCapableBeanFactory接口
public interface AutowireCapableBeanFactory extends BeanFactory {
/**
* 初始化Bean
*/
Object initializeBean(Object existingBean, String beanName);
/**
* 配置Bean（属性填充、自动装配、初始化）
*/
void configureBean(Object existingBean);
/**
* 创建Bean（通过自动装配）
*/
<T> T createBean(Class<T> beanClass);
/**
* 销毁Bean
*/
void destroyBean(Object existingBean);
/**
* 解析Bean名称
*/
String resolveBeanName(String beanName);
/**
* 应用BeanPostProcessor
*/
Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException;
Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException;
}
2. BeanDefinition体系
2.1 BeanDefinition接口
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
// Bean作用域常量
String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
// ==================== Bean角色 ====================
/**
* Bean角色 - 应用程序主要Bean
*/
int ROLE_APPLICATION = 0;
/**
* Bean角色 - 支持Bean（辅助配置）
*/
int ROLE_SUPPORT = 1;
/**
* Bean角色 - 基础架构Bean
*/
int ROLE_INFRASTRUCTURE = 2;
// ==================== BeanDefinition属性 ====================
void setBeanClassName(String beanClassName);
String getBeanClassName();
void setScope(String scope);
String getScope();
void setLazyInit(boolean lazyInit);
boolean isLazyInit();
void setDependsOn(String... dependsOn);
String[] getDependsOn();
void setAutowireCandidate(boolean autowireCandidate);
boolean isAutowireCandidate();
void setPrimary(boolean primary);
boolean isPrimary();
// ==================== 工厂方法 ====================
void setFactoryBeanName(String factoryBeanName);
String getFactoryBeanName();
void setFactoryMethodName(String factoryMethodName);
String getFactoryMethodName();
// ==================== 构造参数 ====================
ConstructorArgumentValues getConstructorArgumentValues();
default boolean hasConstructorArgumentValues() {
return !getConstructorArgumentValues().isEmpty();
}
// ==================== 属性值 ====================
MutablePropertyValues getPropertyValues();
default boolean hasPropertyValues() {
return !getPropertyValues().isEmpty();
}
// ==================== 生命周期回调 ====================
void setInitMethodName(String initMethodName);
String getInitMethodName();
void setDestroyMethodName(String destroyMethodName);
String getDestroyMethodName();
void setRole(int role);
int getRole();
void setDescription(String description);
String getDescription();
// ==================== 来源信息 ====================
ResolvableType getResolvableType();
boolean isSingleton();
boolean isPrototype();
boolean isAbstract();
ConfigurableBeanFactory getParentName();
}
2.2 BeanDefinition实现类层次
BeanDefinition (接口)
│
├── AbstractBeanDefinition (抽象基类)
│ │
│ ├── RootBeanDefinition (根Bean定义)
│ │ │
│ │ └── ChildBeanDefinition (子Bean定义，已废弃)
│ │
│ ├── GenericBeanDefinition (通用Bean定义)
│ │
│ └── AnnotatedBeanDefinition (带注解元数据的Bean定义)
│ │
│ └── ScannedGenericBeanDefinition (@Component扫描)
│ │
│ └── ConfigurationClassBeanDefinition (@Bean方法)
2.3 RootBeanDefinition
public class RootBeanDefinition extends AbstractBeanDefinition {
// 可合并的Bean定义
private BeanDefinitionHolder targetDefinition;
// 内部使用的Bean定义
private BeanDefinition[] innerDefinitions;
// 构造函数参数
private ConstructorArgumentValues constructorArgumentValues;
public RootBeanDefinition(Class<?> beanClass) {
super();
setBeanClass(beanClass);
}
public RootBeanDefinition(String beanClassName) {
super();
setBeanClassName(beanClassName);
}
public RootBeanDefinition(BeanDefinition original) {
super(original);
}
// 合并其他BeanDefinition
public void setTargetDefinition(BeanDefinitionHolder targetDefinition) {
this.targetDefinition = targetDefinition;
}
}
2.4 GenericBeanDefinition
public class GenericBeanDefinition extends AbstractBeanDefinition {
// 父Bean名称
private String parentName;
public GenericBeanDefinition() {
super();
}
public GenericBeanDefinition(BeanDefinition original) {
super(original);
if (original instanceof GenericBeanDefinition) {
this.parentName = ((GenericBeanDefinition) original).parentName;
}
}
@Override
public void setParentName(String parentName) {
this.parentName = parentName;
}
@Override
public String getParentName() {
return this.parentName;
}
/**
* 从GenericBeanDefinition创建RootBeanDefinition
* 这是Spring容器处理BeanDefinition的标准方式
*/
public RootBeanDefinition toRootBeanDefinition() {
RootBeanDefinition rbd = new RootBeanDefinition(this);
rbd.setTargetDefinition(this);
return rbd;
}
}
2.5 AnnotatedBeanDefinition
public interface AnnotatedBeanDefinition extends BeanDefinition {
/**
* 获取该Bean的注解元数据
*/
AnnotationMetadata getMetadata();
/**
* 获取@Bean方法的元数据
*/
MethodMetadata getFactoryMethodMetadata();
}
public class ScannedGenericBeanDefinition
extends GenericBeanDefinition
implements AnnotatedBeanDefinition {
private final AnnotationMetadata metadata;
private AnnotationMetadata factoryMethodMetadata;
public ScannedGenericBeanDefinition(MetadataReader metadataReader) {
this.metadata = metadataReader.getAnnotationMetadata();
// 从@Component注解获取Bean名称
setBeanClassName(determineBeanClassName(metadata));
// 设置默认作用域
setScope(determineScope(metadata));
}
@Override
public AnnotationMetadata getMetadata() {
return this.metadata;
}
@Override
public void setFactoryMethodMetadata(AnnotationMetadata factoryMethodMetadata) {
this.factoryMethodMetadata = factoryMethodMetadata;
}
}
3. BeanPostProcessor后置处理器
3.1 接口定义
public interface BeanPostProcessor {
/**
* Bean初始化之前调用
* @param bean 原始Bean实例
* @param beanName Bean名称
* @return 处理后的Bean（可以是原始Bean或代理对象）
*/
@Nullable
default Object postProcessBeforeInitialization(
Object bean, String beanName) throws BeansException {
return bean;
}
/**
* Bean初始化之后调用
* @param bean 已初始化的Bean实例
* @param beanName Bean名称
* @return 处理后的Bean（可以是原始Bean或代理对象）
*/
@Nullable
default Object postProcessAfterInitialization(
Object bean, String beanName) throws BeansException {
return bean;
}
}
3.2 执行时机
BeanPostProcessor执行时序图：
┌─────────────────────────────────────────────────────────────────┐
│ Bean初始化完整流程 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ Bean实例化 │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────┐ │
│ │ 实例化前处理 │ │
│ │ InstantiationAwareBeanPostProcessor │ │
│ │ .postProcessBeforeInstantiation() │ │
│ └─────────────┬───────────────────────┘ │
│ │ │
│ ▼ │
│ 构造函数执行（new） │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────┐ │
│ │ 实例化后处理 │ │
│ │ InstantiationAwareBeanPostProcessor │ │
│ │ .postProcessAfterInstantiation() │ │
│ └─────────────┬───────────────────────┘ │
│ │ │
│ ▼ │
│ 属性填充（@Autowired, @Value等） │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────┐ │
│ │ 初始化前处理 │ ← BeanPostProcessor │
│ │ .postProcessBeforeInitialization() │ .postProcessBefore │
│ └─────────────┬───────────────────────┘ │
│ │ │
│ ▼ │
│ 初始化（InitializingBean, init-method） │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────┐ │
│ │ 初始化后处理 │ ← BeanPostProcessor │
│ │ .postProcessAfterInitialization() │ .postProcessAfter │
│ └─────────────┬───────────────────────┘ │
│ │ │
│ ▼ │
│ Bean就绪 │
│ │
└─────────────────────────────────────────────────────────────────┘
3.3 内置BeanPostProcessor
Spring框架内置了多个重要的BeanPostProcessor：
// 1. AutowiredAnnotationBeanPostProcessor
// 处理@Autowired、@Value注解
class AutowiredAnnotationBeanPostProcessor
extends InstantiationAwareBeanPostProcessorAdapter {
private final AutowiredAnnotationBeanInfo attributeInfo;
@Override
public PropertyValues postProcessProperties(
PropertyValues pvs, Object bean, String beanName) {
// 1. 查找带@Autowired的属性
// 2. 执行依赖注入
// 3. 返回处理后的PropertyValues
}
}
// 2. CommonAnnotationBeanPostProcessor
// 处理@Resource、@PostConstruct、@PreDestroy
class CommonAnnotationBeanPostProcessor
extends InstantiationAwareBeanPostProcessorAdapter {
@Override
public PropertyValues postProcessProperties(
PropertyValues pvs, Object bean, String beanName) {
// 处理@Resource注解
}
}
// 3. RequiredAnnotationBeanPostProcessor
// 检查@Required注解（Spring 5.1已废弃）
class RequiredAnnotationBeanPostProcessor
extends AbstractBeanFactoryAwareAdvisingPostProcessor {
// ...
}
// 4. ApplicationContextAwareProcessor
// 注入ApplicationContext等感知接口
class ApplicationContextAwareProcessor
implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(
Object bean, String beanName) {
if (bean instanceof EnvironmentAware) {
((EnvironmentAware) bean).setEnvironment(
getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware) {
// ...
}
if (bean instanceof ResourceLoaderAware) {
// ...
}
if (bean instanceof ApplicationEventPublisherAware) {
// ...
}
if (bean instanceof MessageSourceAware) {
// ...
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(
getApplicationContext());
}
return bean;
}
}
// 5. AsyncAnnotationBeanPostProcessor
// 处理@Async注解
class AsyncAnnotationBeanPostProcessor
extends AbstractBeanFactoryAwareAdvisingPostProcessor {
// ...
}
3.4 自定义BeanPostProcessor
@Component
public class TimingBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(
Object bean, String beanName) {
// 可以在初始化前做一些处理
return bean;
}
@Override
public Object postProcessAfterInitialization(
Object bean, String beanName) {
// 记录Bean创建时间
System.out.println("Bean创建完成: " + beanName +
", 类型: " + bean.getClass().getName());
// 返回原始Bean或代理对象
return bean;
}
}
3.5 代理后置处理器
最重要的BeanPostProcessor——创建AOP代理：
class AutowiredAnnotationBeanPostProcessor
extends InstantiationAwareBeanPostProcessorAdapter {
// ...
}
// 真正的代理创建由AnnotationAwareAspectJAutoProxyCreator完成
public class AnnotationAwareAspectJAutoProxyCreator
extends AspectJAwareAdvisorAutoProxyCreator {
@Override
public Object postProcessAfterInitialization(
Object bean, String beanName) {
// 如果需要代理，创建代理
if (this.advisedBeans.isEligible(beanName, bean)) {
// 创建代理
return createProxy(
bean.getClass(), beanName,
this.advisors, new SingletonTargetSource(bean));
}
return bean;
}
}
4. BeanFactoryPostProcessor扩展点
4.1 接口定义
@FunctionalInterface
public interface BeanFactoryPostProcessor {
/**
* 在容器实例化Bean之前修改BeanDefinition
* @param beanFactory BeanFactory
*/
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
throws BeansException;
}
4.2 BeanFactoryPostProcessor vs BeanPostProcessor
┌─────────────────────────────────────────────────────────────────┐
│ BeanFactoryPostProcessor vs BeanPostProcessor │
├─────────────────────────────────────────────────────────────────┤
│ │
│ BeanFactoryPostProcessor: │
│ ┌─────────────────────────────────────────────────────────────┐│
│ │ 执行时机：BeanDefinition加载后，Bean实例化前 ││
│ │ 作用对象：BeanDefinition（Bean的蓝图） ││
│ │ 典型应用：修改Bean属性值、注册新的BeanDefinition ││
│ │ 执行次数：每个BeanFactoryPostProcessor只执行一次 ││
│ └─────────────────────────────────────────────────────────────┘│
│ │
│ BeanPostProcessor: │
│ ┌─────────────────────────────────────────────────────────────┐│
│ │ 执行时机：Bean实例化后，初始化前后 ││
│ │ 作用对象：Bean实例 ││
│ │ 典型应用：依赖注入、AOP代理、属性转换 ││
│ │ 执行次数：每个Bean实例创建时都会执行 ││
│ └─────────────────────────────────────────────────────────────┘│
│ │
│ 执行顺序： │
│ BeanFactoryPostProcessor → Bean实例化 → BeanPostProcessor │
│ │
└─────────────────────────────────────────────────────────────────┘
4.3 内置BeanFactoryPostProcessor
// 1. PropertySourcesPlaceholderConfigurer
// 处理${...}占位符
class PropertySourcesPlaceholderConfigurer
extends PlaceholderConfigurerSupport
implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(
ConfigurableListableBeanFactory beanFactory) {
// 1. 加载属性源
PropertySources propertySources = getAppliedPropertySources();
// 2. 遍历所有BeanDefinition
String[] beanNames = beanFactory.getBeanDefinitionNames();
for (String beanName : beanNames) {
BeanDefinition bd = beanFactory.getBeanDefinition(beanName);
// 3. 替换BeanDefinition中的占位符
resolveProperties(bd);
}
}
}
// 2. PropertyOverrideConfigurer
// 覆盖Bean属性
class PropertyOverrideConfigurer
extends PropertySourcesPlaceholderConfigurer {
@Override
public void postProcessBeanFactory(
ConfigurableListableBeanFactory beanFactory) {
// 从配置文件中覆盖Bean属性值
}
}
// 3. CustomEditorConfigurer
// 注册属性编辑器
class CustomEditorConfigurer
implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(
ConfigurableListableBeanFactory beanFactory) {
// 注册自定义属性编辑器
beanFactory.addPropertyEditorRegistrar(registry -> {
registry.registerCustomEditor(Date.class,
new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"), false));
});
}
}
4.4 自定义BeanFactoryPostProcessor
@Component
public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(
ConfigurableListableBeanFactory beanFactory) {
// 1. 获取所有BeanDefinition
String[] beanNames = beanFactory.getBeanDefinitionNames();
for (String beanName : beanNames) {
BeanDefinition bd = beanFactory.getBeanDefinition(beanName);
// 2. 修改BeanDefinition属性
if (bd.getBeanClassName() != null
&& bd.getBeanClassName().contains("Service")) {
// 设置懒加载
bd.setLazyInit(true);
// 设置依赖
bd.setDependsOn("loggingService");
}
}
// 3. 注册新的BeanDefinition
GenericBeanDefinition newBd = new GenericBeanDefinition();
newBd.setBeanClass(MyHelperService.class);
beanFactory.registerBeanDefinition(
"myHelperService", newBd);
}
}
4.5 BeanDefinitionRegistryPostProcessor
更强大的扩展点，可以添加新的BeanDefinition：
public interface BeanDefinitionRegistryPostProcessor
extends BeanFactoryPostProcessor {
/**
* 在标准BeanFactoryPostProcessor之前执行
* 可以注册新的BeanDefinition
*/
void postProcessBeanDefinitionRegistry(
BeanDefinitionRegistry registry) throws BeansException;
}
@Component
public class CustomBeanDefinitionRegistryPostProcessor
implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanDefinitionRegistry(
BeanDefinitionRegistry registry) {
// 在这里可以添加、修改、移除BeanDefinition
GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
beanDefinition.setBeanClass(MyBean.class);
beanDefinition.setPropertyValues(new MutablePropertyValues() {{
add("name", "default");
}});
registry.registerBeanDefinition("myBean", beanDefinition);
}
@Override
public void postProcessBeanFactory(
ConfigurableListableBeanFactory beanFactory) {
// 标准BeanFactoryPostProcessor逻辑
}
}
5. FactoryBean与ObjectFactory
5.1 FactoryBean接口
public interface FactoryBean<T> {
/**
* 返回创建的Bean对象
*/
T getObject() throws Exception;
/**
* 返回创建的Bean类型
*/
Class<?> getObjectType();
/**
* 是否是单例
*/
default boolean isSingleton() {
return true;
}
}
5.2 FactoryBean vs BeanFactory
┌─────────────────────────────────────────────────────────────────┐
│ FactoryBean vs BeanFactory │
├─────────────────────────────────────────────────────────────────┤
│ │
│ BeanFactory：IoC容器（工厂） │
│ ┌─────────────────────────────────────────────────────────────┐│
│ │ Spring IoC容器的核心接口 ││
│ │ 管理所有Bean的创建和生命周期 ││
│ │ getBean() → 返回Bean实例 ││
│ └─────────────────────────────────────────────────────────────┘│
│ │
│ FactoryBean：Bean的工厂（产品） │
│ ┌─────────────────────────────────────────────────────────────┐│
│ │ 一个特殊的Bean，用于创建复杂Bean ││
│ │ 创建的Bean由Spring管理生命周期 ││
│ │ getBean("&beanName") → 返回FactoryBean本身 ││
│ │ getBean("beanName") → 返回getObject()创建的对象 ││
│ └─────────────────────────────────────────────────────────────┘│
│ │
│ 使用场景： │
│ • 创建第三方库的Bean │
│ • 创建需要复杂初始化的Bean │
│ • 创建代理对象 │
│ │
└─────────────────────────────────────────────────────────────────┘
5.3 FactoryBean使用示例
// 示例1：创建SqlSessionFactory
public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory> {
private String configLocation;
private String dataSource;
@Override
public SqlSessionFactory getObject() throws Exception {
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
return builder.build(loadConfig());
}
@Override
public Class<SqlSessionFactory> getObjectType() {
return SqlSessionFactory.class;
}
@Override
public boolean isSingleton() {
return true;
}
}
// 使用
@Bean
public SqlSessionFactoryBean sqlSessionFactory() {
SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
factory.setConfigLocation("classpath:mybatis-config.xml");
return factory;
}
// 示例2：创建动态代理
public class JdkProxyFactoryBean implements FactoryBean<Object> {
private Object target;
private Class<?> interfaceClass;
@Override
public Object getObject() throws Exception {
return Proxy.newProxyInstance(
interfaceClass.getClassLoader(),
new Class[] { interfaceClass },
(proxy, method, args) -> {
// 代理逻辑
System.out.println("调用方法: " + method.getName());
return method.invoke(target, args);
}
);
}
@Override
public Class<?> getObjectType() {
return interfaceClass;
}
}
5.4 获取FactoryBean本身
@Autowired
private BeanFactory beanFactory;
// 获取FactoryBean本身（以&开头）
@Test
public void testGetFactoryBeanItself() {
// 获取sqlSessionFactory这个FactoryBean本身
Object factory = beanFactory.getBean("&sqlSessionFactory");
assertTrue(factory instanceof SqlSessionFactoryBean);
// 获取FactoryBean创建的SqlSessionFactory
SqlSessionFactory sqlSessionFactory = beanFactory.getBean("sqlSessionFactory");
assertTrue(sqlSessionFactory instanceof SqlSessionFactory);
}
5.5 ObjectFactory接口
@FunctionalInterface
public interface ObjectFactory<T> {
/**
* 创建或获取对象
*/
T getObject();
}
// ObjectFactory的使用场景：延迟初始化
@Component
public class LazyBeanReference {
@Autowired
private ObjectFactory<HeavyService> heavyServiceFactory;
public void doSomething() {
// 真正需要时才创建HeavyService
HeavyService service = heavyServiceFactory.getObject();
service.process();
}
}
6. BeanDefinitionRegistry注册中心
6.1 接口定义
public interface BeanDefinitionRegistry
extends AliasRegistry {
/**
* 注册新的BeanDefinition
*/
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException;
/**
* 移除BeanDefinition
*/
void removeBeanDefinition(String beanName)
throws NoSuchBeanDefinitionException;
/**
* 获取BeanDefinition
*/
BeanDefinition getBeanDefinition(String beanName)
throws NoSuchBeanDefinitionException;
/**
* 检查是否包含BeanDefinition
*/
boolean containsBeanDefinition(String beanName);
/**
* 获取所有BeanDefinition名称
*/
String[] getBeanDefinitionNames();
/**
* 获取BeanDefinition数量
*/
int getBeanDefinitionCount();
/**
* 检查Bean名称是否已使用
*/
boolean isBeanNameInUse(String beanName);
}
6.2 AliasRegistry接口
public interface AliasRegistry {
/**
* 注册别名
*/
void registerAlias(String name, String alias);
/**
* 移除别名
*/
void removeAlias(String alias);
/**
* 判断是否是别名
*/
boolean isAlias(String name);
/**
* 获取别名列表
*/
String[] getAliases(String name);
}
6.3 实现类：DefaultListableBeanFactory
public class DefaultListableBeanFactory
extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory,
BeanDefinitionRegistry {
// BeanDefinition注册表
private final Map<String, BeanDefinition> beanDefinitionMap =
new ConcurrentHashMap<>(256);
// Bean名称列表（按注册顺序）
private volatile List<String> beanDefinitionNames =
new ArrayList<>(256);
@Override
public void registerBeanDefinition(String beanName,
BeanDefinition beanDefinition) {
// 1. 校验BeanDefinition
if (beanDefinition instanceof AbstractBeanDefinition) {
((AbstractBeanDefinition) beanDefinition).validate();
}
// 2. 检查是否已存在
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
// 覆盖或报错
if (!existingDefinition.equals(beanDefinition)) {
this.beanDefinitionMap.put(beanName, beanDefinition);
}
} else {
// 3. 注册新的BeanDefinition
if (hasBeanCreationStarted()) {
// 容器已启动，需要同步
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
}
} else {
// 容器未启动
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
}
}
}
@Override
public BeanDefinition getBeanDefinition(String beanName) {
BeanDefinition bd = this.beanDefinitionMap.get(beanName);
if (bd == null) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("No bean named '" + beanName + "' found in " + this);
}
throw new NoSuchBeanDefinitionException(beanName);
}
return bd;
}
}
7. 别名管理与BeanNameGenerator
7.1 别名注册
// 方式1：通过@Bean注册别名
@Configuration
public class AppConfig {
@Bean(name = {"userService", "userServiceAlias", "us"})
public UserService userService() {
return new UserServiceImpl();
}
}
// 方式2：通过@Qualifier指定别名
@Service("userService")
public class UserServiceImpl implements UserService {}
@Service
public class AnotherService {
@Autowired
@Qualifier("userServiceAlias")
private UserService userService;
}
// 方式3：使用AliasRegistry
@Component
public class AliasRegistrar implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanDefinitionRegistry(
BeanDefinitionRegistry registry) {
// 注册别名
registry.registerAlias("userService", "userServiceAlias");
registry.registerAlias("userService", "us");
}
}
7.2 BeanNameGenerator
public interface BeanNameGenerator {
/**
* 生成Bean名称
* @param definition Bean定义
* @param registry BeanDefinitionRegistry
* @return Bean名称
*/
String generateBeanName(BeanDefinition definition,
BeanDefinitionRegistry registry);
}
// Spring内置的默认实现
public class AnnotationBeanNameGenerator implements BeanNameGenerator {
@Override
public String generateBeanName(
BeanDefinition definition,
BeanDefinitionRegistry registry) {
if (definition instanceof AnnotatedBeanDefinition) {
// 从注解中获取Bean名称
String beanName = determineBeanNameFromAnnotation(
((AnnotatedBeanDefinition) definition).getMetadata());
if (StringUtils.hasText(beanName)) {
return beanName;
}
}
// 使用类的简名作为Bean名称
return buildDefaultBeanName(definition, registry);
}
protected String buildDefaultBeanName(
BeanDefinition definition,
BeanDefinitionRegistry registry) {
String beanClassName = definition.getBeanClassName();
Assert.state(beanClassName != null, "Bean class name must not be null");
// UserServiceImpl → userServiceImpl
// UserService → userService
return Introspector.decapitalize(
ClassUtils.getShortName(beanClassName));
}
}
7.3 自定义BeanNameGenerator
// 示例1：带前缀的Bean名称
public class PrefixedBeanNameGenerator implements BeanNameGenerator {
private String prefix = "app.";
public void setPrefix(String prefix) {
this.prefix = prefix;
}
@Override
public String generateBeanName(
BeanDefinition definition,
BeanDefinitionRegistry registry) {
BeanDefinitionGenerator generator =
new AnnotationBeanNameGenerator();
String name = generator.generateBeanName(definition, registry);
return prefix + name;
}
}
// 配置使用
@Configuration
@ComponentScan(
nameGenerator = PrefixedBeanNameGenerator.class)
public class AppConfig {}
// 结果：所有Bean名称都会带"app."前缀
8. 源码流程解析
8.1 容器初始化完整流程
┌─────────────────────────────────────────────────────────────────┐
│ DefaultListableBeanFactory 初始化流程 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 1. 创建DefaultListableBeanFactory │
│ │ │
│ ▼ │
│ 2. 设置parentBeanFactory │
│ │ │
│ ▼ │
│ 3. customizeBeanFactory() │
│ │ ├─ 设置allowBeanDefinitionOverriding │
│ │ ├─ 设置allowCircularReferences │
│ │ └─ 设置securityContextProvider │
│ │ │
│ ▼ │
│ 4. loadBeanDefinitions() │
│ │ │
│ ├─ XML: XmlBeanDefinitionReader.loadBeanDefinitions() │
│ │ │
│ └─ 注解: AnnotatedBeanDefinitionReader.registerBean() │
│ │ │
│ ▼ │
│ 5. BeanFactoryPostProcessor执行 │
│ │ ├─ BeanDefinitionRegistryPostProcessor │
│ │ └─ BeanFactoryPostProcessor │
│ │ │
│ ▼ │
│ 6. BeanDefinition合并 │
│ │ └─ RootBeanDefinition = ChildBeanDefinition + Parent │
│ │ │
│ ▼ │
│ 7. BeanPostProcessor注册 │
│ │ └─ 添加到beanPostProcessors列表 │
│ │ │
│ ▼ │
│ 8. 初始化MessageSource │
│ │ │
│ ▼ │
│ 9. 初始化事件多播器 │
│ │ │
│ ▼ │
│ 10. onRefresh() → WebServer创建 │
│ │ │
│ ▼ │
│ 11. finishRefresh() │
│ │ ├─ clearResourceCaches() │
│ │ ├─ initLifecycleProcessor() │
│ │ ├─ publishEvent(new ContextRefreshedEvent()) │
│ │ └─ LiveBeansView.registerApplicationContext() │
│ │ │
│ 12. resetCommonCaches() │
│ │
└─────────────────────────────────────────────────────────────────┘
8.2 getBean()核心逻辑
// AbstractBeanFactory.getBean()
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
protected <T> T doGetBean(
String name,
Class<T> requiredType,
Object[] args,
boolean typeCheckOnly) throws BeansException {
// 1. 转换Bean名称（处理&前缀）
String beanName = transformedBeanName(name);
// 2. 尝试从单例缓存获取
Object bean = getSingleton(beanName);
if (bean != null) {
// 单例Bean直接返回
return getObjectForBeanInstance(bean, name, beanName, null);
}
// 3. 原型Bean处理
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 4. 检查父容器
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null) {
return parentBeanFactory.getBean(requiredType);
}
// 5. 获取并合并BeanDefinition
BeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 6. 处理depends-on
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
registerDependentBean(dep, beanName);
getBean(dep); // 先创建依赖的Bean
}
}
// 7. 根据作用域创建Bean
if (mbd.isSingleton()) {
// 单例创建
return createBean(beanName, mbd, args);
} else if (mbd.isPrototype()) {
// 原型创建
return createBean(beanName, mbd, args);
} else {
// 其他作用域
return createBean(beanName, mbd, args);
}
}
9. 实战：自定义扩展
9.1 自定义BeanDefinitionRegistryPostProcessor
/**
* 自动扫描并注册带特定注解的类为Bean
*/
@Component
public class CustomComponentRegistrar
implements BeanDefinitionRegistryPostProcessor {
private static final String BASE_PACKAGE = "com.example.custom.beans";
@Override
public void postProcessBeanDefinitionRegistry(
BeanDefinitionRegistry registry) {
// 扫描指定包
ClassPathScanner scanner = new ClassPathScanner(registry);
scanner.setResourceLoader(new DefaultResourceLoader());
scanner.scan(BASE_PACKAGE);
}
@Override
public void postProcessBeanFactory(
ConfigurableListableBeanFactory beanFactory) {
// 可以在这里对BeanFactory进行后处理
}
}
class ClassPathScanner {
private final BeanDefinitionRegistry registry;
private ResourceLoader resourceLoader;
public ClassPathScanner(BeanDefinitionRegistry registry) {
this.registry = registry;
}
public void setResourceLoader(ResourceLoader resourceLoader) {
this.resourceLoader = resourceLoader;
}
public void scan(String basePackage) {
// 实现包扫描逻辑
String packageSearchPath = "classpath:" +
basePackage.replace('.', '/') + "/**/*.class";
// ... 扫描并注册BeanDefinition
}
}
9.2 自定义属性编辑器
@Component
public class CustomEditorConfigurer
implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(
ConfigurableListableBeanFactory beanFactory) {
beanFactory.addPropertyEditorRegistrar(registry -> {
// 注册日期编辑器
registry.registerCustomEditor(
Date.class,
new CustomDateEditor(
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"),
false
)
);
// 注册自定义类型编辑器
registry.registerCustomEditor(
Money.class,
new MoneyEditor()
);
});
}
}
public class MoneyEditor extends PropertyEditorSupport {
@Override
public void setAsText(String text) throws IllegalArgumentException {
if (StringUtils.hasText(text)) {
String[] parts = text.split(" ");
if (parts.length == 2) {
setValue(new Money(
new BigDecimal(parts[0]),
Currency.getInstance(parts[1])
));
}
}
}
@Override
public String getAsText() {
Money money = (Money) getValue();
return money != null ?
money.getAmount() + " " + money.getCurrency() : "";
}
}
总结
本文深入剖析了Spring BeanFactory体系的完整设计：
接口体系：
BeanFactory是根接口，定义了IoC容器的基本能力ListableBeanFactory支持批量查询HierarchicalBeanFactory支持层级结构AutowireCapableBeanFactory支持自动装配
BeanDefinition体系：
BeanDefinition描述了Bean的元数据RootBeanDefinition用于合并后的Bean定义GenericBeanDefinition支持父子BeanAnnotatedBeanDefinition支持注解元数据
后置处理器：
BeanPostProcessor在Bean初始化前后执行BeanFactoryPostProcessor在Bean创建前修改BeanDefinitionBeanDefinitionRegistryPostProcessor可以注册新的BeanDefinition
FactoryBean：
FactoryBean用于创建复杂Bean- 通过
&前缀可以获取FactoryBean本身 ObjectFactory支持延迟初始化
掌握这些核心接口和类，是深入理解Spring框架的必备知识。
汇聚全球AI编程工具，助力开发者即刻编程。
更多推荐
8
0- 0
已为社区贡献17条内容
所有评论(0)