Spring BeanFactoryAware源码详解（详细注释版）
1. BeanFactoryAware接口源码
/*
* BeanFactoryAware接口是Spring框架中重要的Aware接口之一
* 允许Bean获取对其运行的BeanFactory的引用
* 是Spring框架中依赖注入机制的重要组成部分
*
* BeanFactoryAware的作用：
* 1. 让Bean能够访问BeanFactory
* 2. 实现Bean与Spring容器的交互
* 3. 获取容器中的其他Bean
* 4. 访问容器的各种服务
*
* 注意事项：
* - 实现此接口会将代码与Spring框架耦合
* - 优先考虑使用@Autowired注入BeanFactory
* - 避免在业务逻辑中直接使用BeanFactory
*/
package org.springframework.beans.factory;
import org.springframework.beans.BeansException;
/**
* 当Bean需要访问其运行的BeanFactory时实现的接口
*
* 实现此接口的Bean会在BeanFactoryAwareProcessor处理时
* 调用setBeanFactory方法注入BeanFactory引用
*
* 执行时机：
* Bean实例化 -> 属性注入 -> Aware接口方法调用(setBeanFactory) ->
* ApplicationContextAware等其他Aware接口 -> BeanPostProcessor处理 ->
* InitializingBean.afterPropertiesSet() -> 自定义init-method -> Bean可使用
*
* 使用场景：
* - 获取其他Bean实例
* - 访问Bean定义信息
* - 手动注册Bean
* - 访问BeanFactory的各种服务
*
* 注意：官方推荐使用@Autowired注入BeanFactory而不是实现此接口
*/
public interface BeanFactoryAware extends Aware {
/**
* 设置此对象运行的BeanFactory
* 在普通Bean属性填充之后但在初始化回调之前调用
* 如InitializingBean的afterPropertiesSet或自定义init-method
*
* @param beanFactory 此对象要使用的BeanFactory对象
* @throws BeansException 如果BeanFactory不能被设置
*
* 使用建议：
* - 在此方法中保存BeanFactory引用
* - 避免在此方法中执行复杂的业务逻辑
* - 确保异常处理，避免影响Bean的正常创建
* - 考虑使用@Autowired替代实现此接口
*/
void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}
2. Aware接口体系
/*
* Aware接口是Spring框架中所有感知接口的根接口
* 标记接口，没有任何方法
*/
package org.springframework.beans.factory;
/**
* 标记超接口，指示Bean有资格通过回调方式由Spring容器通知
* 实际的方法由子接口定义，通常表示为set方法
*
* Aware接口的设计目的是为了让Bean能够感知到容器的存在
* 并获取容器提供的各种服务
*
* 常见的Aware接口：
* - BeanNameAware: 获取Bean名称
* - BeanFactoryAware: 获取BeanFactory
* - ApplicationContextAware: 获取ApplicationContext
* - EnvironmentAware: 获取Environment
* - EmbeddedValueResolverAware: 获取StringValueResolver
* - ResourceLoaderAware: 获取ResourceLoader
* - ApplicationEventPublisherAware: 获取ApplicationEventPublisher
* - MessageSourceAware: 获取MessageSource
*/
public interface Aware {
}
3. AbstractAutowireCapableBeanFactory中BeanFactoryAware处理
/*
* AbstractAutowireCapableBeanFactory中BeanFactoryAware的处理逻辑
*/
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
implements AutowireCapableBeanFactory {
/**
* 调用Aware接口相关方法
* 在Bean初始化过程中调用，包括BeanFactoryAware
*
* @param beanName Bean名称
* @param bean Bean实例
*/
private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
// BeanNameAware接口
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
// BeanClassLoaderAware接口
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
// BeanFactoryAware接口 - 这里是关键调用点
if (bean instanceof BeanFactoryAware) {
// 调用setBeanFactory方法，传入当前BeanFactory实例
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
/**
* 初始化Bean的核心方法
* 包含Aware接口方法的调用
*
* @param beanName Bean名称
* @param bean Bean实例
* @param mbd 合并的Bean定义
* @return 初始化完成的Bean实例
*/
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
// 调用Aware接口方法，包括BeanFactoryAware
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 应用BeanPostProcessor的前置处理
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 调用初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 应用BeanPostProcessor的后置处理
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
}
4. BeanFactoryAwareProcessor处理器
/*
* ApplicationContextAwareProcessor是处理各种Aware接口的BeanPostProcessor
* 负责在Bean初始化过程中调用相应的Aware接口方法
*/
package org.springframework.context.support;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.*;
class ApplicationContextAwareProcessor implements BeanPostProcessor {
private final ConfigurableApplicationContext applicationContext;
/**
* 构造方法
*
* @param applicationContext ApplicationContext实例
*/
public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
this.applicationContext = applicationContext;
}
/**
* 在Bean初始化前处理Aware接口
* 这是BeanFactoryAware被调用的地方（间接）
*
* @param bean Bean实例
* @param beanName Bean名称
* @return 处理后的Bean实例
* @throws BeansException 如果处理过程中发生错误
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
// 检查Bean是否实现了任何Aware接口
if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
return bean;
}
AccessControlContext acc = null;
// 如果有安全管理器，获取访问控制上下文
if (System.getSecurityManager() != null) {
acc = this.applicationContext.getBeanFactory().getAccessControlContext();
}
if (acc != null) {
// 在安全管理器下执行Aware接口方法
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareInterfaces(bean);
return null;
}, acc);
}
else {
// 直接执行Aware接口方法
invokeAwareInterfaces(bean);
}
return bean;
}
/**
* 调用各种Aware接口方法
* 按照特定顺序调用，确保依赖关系正确
*
* @param bean Bean实例
*/
private void invokeAwareInterfaces(Object bean) {
// EnvironmentAware接口
if (bean instanceof EnvironmentAware) {
((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
}
// EmbeddedValueResolverAware接口
if (bean instanceof EmbeddedValueResolverAware) {
((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(
new EmbeddedValueResolver(this.applicationContext.getBeanFactory()));
}
// ResourceLoaderAware接口
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
}
// ApplicationEventPublisherAware接口
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
}
// MessageSourceAware接口
if (bean instanceof MessageSourceAware) {
((MessageSourceAware) bean).setMessageSource(this.applicationContext);
}
// ApplicationContextAware接口 - 会间接调用BeanFactoryAware
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
}
/**
* 嵌入值解析器
* 用于解析占位符等嵌入值
*/
private static class EmbeddedValueResolver implements StringValueResolver {
private final ConfigurableBeanFactory beanFactory;
public EmbeddedValueResolver(ConfigurableBeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
@Override
public String resolveStringValue(String strVal) {
return this.beanFactory.resolveEmbeddedValue(strVal);
}
}
}
5. BeanFactoryAware的实际应用
/*
* BeanFactoryAware的实际应用场景
*/
/**
* 服务定位器模式实现
* 通过BeanFactory获取其他Bean
*/
@Component
public class ServiceLocator implements BeanFactoryAware {
private static BeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
ServiceLocator.beanFactory = beanFactory;
}
/**
* 获取Bean实例
*
* @param beanClass Bean类型
* @param <T> Bean类型泛型
* @return Bean实例
*/
public static <T> T getBean(Class<T> beanClass) {
return beanFactory.getBean(beanClass);
}
/**
* 根据名称获取Bean实例
*
* @param beanName Bean名称
* @param <T> Bean类型泛型
* @return Bean实例
*/
@SuppressWarnings("unchecked")
public static <T> T getBean(String beanName) {
return (T) beanFactory.getBean(beanName);
}
/**
* 根据名称和类型获取Bean实例
*
* @param beanName Bean名称
* @param beanClass Bean类型
* @param <T> Bean类型泛型
* @return Bean实例
*/
public static <T> T getBean(String beanName, Class<T> beanClass) {
return beanFactory.getBean(beanName, beanClass);
}
/**
* 检查Bean是否存在
*
* @param beanName Bean名称
* @return 如果存在返回true
*/
public static boolean containsBean(String beanName) {
return beanFactory.containsBean(beanName);
}
/**
* 获取Bean类型
*
* @param beanName Bean名称
* @return Bean类型
*/
public static Class<?> getType(String beanName) {
return beanFactory.getType(beanName);
}
}
/**
* 动态Bean创建服务
* 使用BeanFactory创建Bean
*/
@Component
public class DynamicBeanCreationService implements BeanFactoryAware {
private ConfigurableListableBeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
if (beanFactory instanceof ConfigurableListableBeanFactory) {
this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
} else {
throw new IllegalArgumentException("BeanFactory必须是ConfigurableListableBeanFactory类型");
}
}
/**
* 动态注册Bean定义
*
* @param beanName Bean名称
* @param beanClass Bean类
* @param propertyValues 属性值
*/
public void registerBeanDefinition(String beanName, Class<?> beanClass,
Map<String, Object> propertyValues) {
// 创建Bean定义
GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
beanDefinition.setBeanClass(beanClass);
beanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
// 设置属性值
if (propertyValues != null && !propertyValues.isEmpty()) {
MutablePropertyValues mpv = new MutablePropertyValues();
propertyValues.forEach(mpv::addPropertyValue);
beanDefinition.setPropertyValues(mpv);
}
// 注册Bean定义
beanFactory.registerBeanDefinition(beanName, beanDefinition);
}
/**
* 获取Bean定义
*
* @param beanName Bean名称
* @return Bean定义
*/
public BeanDefinition getBeanDefinition(String beanName) {
try {
return beanFactory.getBeanDefinition(beanName);
} catch (NoSuchBeanDefinitionException e) {
return null;
}
}
/**
* 获取所有Bean名称
*
* @return Bean名称数组
*/
public String[] getBeanDefinitionNames() {
return beanFactory.getBeanDefinitionNames();
}
/**
* 获取Bean定义数量
*
* @return Bean定义数量
*/
public int getBeanDefinitionCount() {
return beanFactory.getBeanDefinitionCount();
}
}
/**
* Bean生命周期管理服务
* 使用BeanFactory管理Bean生命周期
*/
@Component
public class BeanLifecycleManagementService implements BeanFactoryAware {
private ConfigurableListableBeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
if (beanFactory instanceof ConfigurableListableBeanFactory) {
this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
}
}
/**
* 手动初始化Bean
*
* @param beanName Bean名称
* @return 初始化后的Bean实例
*/
public Object initializeBean(String beanName) {
try {
Object bean = beanFactory.getBean(beanName);
if (beanFactory.containsBeanDefinition(beanName)) {
BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
if (bean instanceof InitializingBean) {
((InitializingBean) bean).afterPropertiesSet();
}
// 调用自定义初始化方法
String initMethodName = beanDefinition.getInitMethodName();
if (initMethodName != null) {
invokeInitMethod(bean, initMethodName);
}
}
return bean;
} catch (Exception e) {
throw new RuntimeException("初始化Bean失败: " + beanName, e);
}
}
/**
* 手动销毁Bean
*
* @param beanName Bean名称
*/
public void destroyBean(String beanName) {
try {
Object bean = beanFactory.getBean(beanName);
if (beanFactory.containsBeanDefinition(beanName)) {
BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
// 调用自定义销毁方法
String destroyMethodName = beanDefinition.getDestroyMethodName();
if (destroyMethodName != null) {
invokeDestroyMethod(bean, destroyMethodName);
}
if (bean instanceof DisposableBean) {
((DisposableBean) bean).destroy();
}
}
} catch (Exception e) {
throw new RuntimeException("销毁Bean失败: " + beanName, e);
}
}
/**
* 调用初始化方法
*/
private void invokeInitMethod(Object bean, String methodName) {
try {
Method method = bean.getClass().getMethod(methodName);
method.invoke(bean);
} catch (Exception e) {
throw new RuntimeException("调用初始化方法失败: " + methodName, e);
}
}
/**
* 调用销毁方法
*/
private void invokeDestroyMethod(Object bean, String methodName) {
try {
Method method = bean.getClass().getMethod(methodName);
method.invoke(bean);
} catch (Exception e) {
throw new RuntimeException("调用销毁方法失败: " + methodName, e);
}
}
/**
* 获取Bean别名
*
* @param beanName Bean名称
* @return 别名数组
*/
public String[] getAliases(String beanName) {
return beanFactory.getAliases(beanName);
}
/**
* 检查Bean是否为单例
*
* @param beanName Bean名称
* @return 如果是单例返回true
*/
public boolean isSingleton(String beanName) {
return beanFactory.isSingleton(beanName);
}
/**
* 检查Bean是否为原型
*
* @param beanName Bean名称
* @return 如果是原型返回true
*/
public boolean isPrototype(String beanName) {
return beanFactory.isPrototype(beanName);
}
}
/**
* 配置信息服务
* 访问BeanFactory的配置信息
*/
@Component
public class BeanFactoryConfigService implements BeanFactoryAware {
private ConfigurableListableBeanFactory beanFactory;
private Environment environment;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
if (beanFactory instanceof ConfigurableListableBeanFactory) {
this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
this.environment = this.beanFactory.getBean(Environment.class);
}
}
/**
* 获取BeanFactory的环境信息
*
* @return 环境信息
*/
public Environment getEnvironment() {
return environment;
}
/**
* 解析嵌入值
*
* @param value 嵌入值
* @return 解析后的值
*/
public String resolveEmbeddedValue(String value) {
return beanFactory.resolveEmbeddedValue(value);
}
/**
* 获取类型转换器
*
* @return 类型转换器
*/
public TypeConverter getTypeConverter() {
return beanFactory.getTypeConverter();
}
/**
* 转换值类型
*
* @param value 值
* @param requiredType 目标类型
* @param <T> 目标类型泛型
* @return 转换后的值
*/
public <T> T convertValue(Object value, Class<T> requiredType) {
return getTypeConverter().convertIfNecessary(value, requiredType);
}
/**
* 获取父BeanFactory
*
* @return 父BeanFactory
*/
public BeanFactory getParentBeanFactory() {
return beanFactory.getParentBeanFactory();
}
/**
* 检查是否包含本地Bean
*
* @param beanName Bean名称
* @return 如果包含返回true
*/
public boolean containsLocalBean(String beanName) {
return beanFactory.containsLocalBean(beanName);
}
}
6. 现代化替代方案
/*
* 现代化的替代方案
* 推荐使用依赖注入而不是实现Aware接口
*/
/**
* 使用@Autowired注入BeanFactory
* 推荐的现代化方式
*/
@Component
public class ModernService {
// 使用@Autowired注入BeanFactory
@Autowired
private BeanFactory beanFactory;
// 使用@Autowired注入ConfigurableBeanFactory
@Autowired
private ConfigurableBeanFactory configurableBeanFactory;
// 使用@Autowired注入其他Bean
@Autowired
private SomeOtherService someOtherService;
/**
* 获取Bean实例
*/
public void doSomething() {
// 直接使用注入的BeanFactory
SomeService someService = beanFactory.getBean(SomeService.class);
// 使用注入的其他Bean
someOtherService.performAction();
}
/**
* 动态获取Bean
*/
public <T> T getBeanDynamically(Class<T> beanClass) {
return beanFactory.getBean(beanClass);
}
/**
* 检查Bean是否存在
*/
public boolean isBeanExists(String beanName) {
return beanFactory.containsBean(beanName);
}
}
/**
* 使用构造方法注入
* 更好的依赖注入方式
*/
@Component
public class ConstructorInjectionService {
private final BeanFactory beanFactory;
private final ConfigurableBeanFactory configurableBeanFactory;
private final SomeOtherService someOtherService;
// 构造方法注入
public ConstructorInjectionService(
BeanFactory beanFactory,
ConfigurableBeanFactory configurableBeanFactory,
SomeOtherService someOtherService) {
this.beanFactory = beanFactory;
this.configurableBeanFactory = configurableBeanFactory;
this.someOtherService = someOtherService;
}
/**
* 业务方法
*/
public void doSomething() {
// 使用注入的依赖
SomeService someService = beanFactory.getBean(SomeService.class);
someOtherService.performAction();
}
}
/**
* 使用ObjectProvider延迟注入
* 更灵活的依赖注入方式
*/
@Component
public class ObjectProviderService {
// 使用ObjectProvider延迟注入
@Autowired
private ObjectProvider<SomeService> someServiceProvider;
// 使用ObjectProvider获取原型Bean
@Autowired
private ObjectProvider<PrototypeService> prototypeServiceProvider;
/**
* 获取Bean实例（延迟初始化）
*/
public SomeService getSomeService() {
return someServiceProvider.getIfAvailable();
}
/**
* 获取原型Bean实例
*/
public PrototypeService createPrototypeService() {
return prototypeServiceProvider.getObject();
}
}
/**
* 使用@Lookup注解
* 运行时动态获取Bean
*/
@Component
public abstract class LookupService {
/**
* 抽象方法，Spring会在运行时实现
* 用于获取原型Bean
*/
@Lookup
protected abstract PrototypeService createPrototypeService();
/**
* 业务方法
*/
public void doSomething() {
// 每次调用都会创建新的PrototypeService实例
PrototypeService service = createPrototypeService();
service.performAction();
}
}
7. 实际使用示例
/*
* BeanFactoryAware实际使用示例
*/
/**
* 动态Bean查找服务
*/
@Component
public class DynamicBeanLookupService implements BeanFactoryAware {
private ConfigurableListableBeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
if (beanFactory instanceof ConfigurableListableBeanFactory) {
this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
}
}
/**
* 根据类型查找Bean
*/
public <T> List<T> findBeansOfType(Class<T> type) {
Map<String, T> beans = beanFactory.getBeansOfType(type);
return new ArrayList<>(beans.values());
}
/**
* 根据注解查找Bean
*/
public List<Object> findBeansWithAnnotation(Class<? extends Annotation> annotationType) {
List<Object> beans = new ArrayList<>();
String[] beanNames = beanFactory.getBeanDefinitionNames();
for (String beanName : beanNames) {
BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
// 检查Bean定义中的注解
if (beanDefinition instanceof AnnotatedBeanDefinition) {
AnnotatedBeanDefinition abd = (AnnotatedBeanDefinition) beanDefinition;
if (abd.getMetadata().hasAnnotation(annotationType.getName())) {
beans.add(beanFactory.getBean(beanName));
}
}
}
return beans;
}
/**
* 动态获取Bean
*/
@SuppressWarnings("unchecked")
public <T> T getBeanDynamically(String beanName, Class<T> requiredType) {
try {
return (T) beanFactory.getBean(beanName);
} catch (BeansException e) {
// 处理Bean不存在的情况
System.err.println("Bean '" + beanName + "' not found: " + e.getMessage());
return null;
}
}
/**
* 获取Bean定义信息
*/
public BeanDefinitionInfo getBeanDefinitionInfo(String beanName) {
try {
BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
return new BeanDefinitionInfo(
beanName,
beanDefinition.getBeanClassName(),
beanDefinition.getScope(),
beanDefinition.isSingleton(),
beanDefinition.isPrototype()
);
} catch (NoSuchBeanDefinitionException e) {
return null;
}
}
/**
* Bean定义信息类
*/
public static class BeanDefinitionInfo {
private final String beanName;
private final String beanClassName;
private final String scope;
private final boolean singleton;
private final boolean prototype;
public BeanDefinitionInfo(String beanName, String beanClassName,
String scope, boolean singleton, boolean prototype) {
this.beanName = beanName;
this.beanClassName = beanClassName;
this.scope = scope;
this.singleton = singleton;
this.prototype = prototype;
}
// Getters
public String getBeanName() { return beanName; }
public String getBeanClassName() { return beanClassName; }
public String getScope() { return scope; }
public boolean isSingleton() { return singleton; }
public boolean isPrototype() { return prototype; }
@Override
public String toString() {
return "BeanDefinitionInfo{" +
"beanName='" + beanName + '\'' +
", beanClassName='" + beanClassName + '\'' +
", scope='" + scope + '\'' +
", singleton=" + singleton +
", prototype=" + prototype +
'}';
}
}
}
/**
* Bean工厂扩展服务
*/
@Component
public class BeanFactoryExtensionService implements BeanFactoryAware, BeanPostProcessor {
private ConfigurableListableBeanFactory beanFactory;
private final Map<String, BeanMetrics> beanMetrics = new ConcurrentHashMap<>();
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
if (beanFactory instanceof ConfigurableListableBeanFactory) {
this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
}
}
/**
* Bean后处理 - 记录Bean创建时间
*/
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
beanMetrics.computeIfAbsent(beanName, k -> new BeanMetrics())
.setCreationTime(System.currentTimeMillis());
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
BeanMetrics metrics = beanMetrics.get(beanName);
if (metrics != null) {
metrics.setInitializationTime(System.currentTimeMillis());
}
return bean;
}
/**
* 获取Bean工厂统计信息
*/
public BeanFactoryStats getBeanFactoryStats() {
BeanFactoryStats stats = new BeanFactoryStats();
stats.setTotalBeanCount(beanFactory.getBeanDefinitionCount());
stats.setBeanNames(Arrays.asList(beanFactory.getBeanDefinitionNames()));
stats.setBeanMetrics(new HashMap<>(beanMetrics));
return stats;
}
/**
* 手动注册Bean
*/
public void registerBean(String beanName, Class<?> beanClass) {
GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
beanDefinition.setBeanClass(beanClass);
beanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
beanFactory.registerBeanDefinition(beanName, beanDefinition);
}
/**
* Bean指标类
*/
public static class BeanMetrics {
private long creationTime;
private long initializationTime;
public long getCreationTime() { return creationTime; }
public void setCreationTime(long creationTime) { this.creationTime = creationTime; }
public long getInitializationTime() { return initializationTime; }
public void setInitializationTime(long initializationTime) { this.initializationTime = initializationTime; }
public long getInitializationDuration() {
return initializationTime - creationTime;
}
}
/**
* Bean工厂统计信息类
*/
public static class BeanFactoryStats {
private int totalBeanCount;
private List<String> beanNames;
private Map<String, BeanMetrics> beanMetrics;
// Getters and Setters
public int getTotalBeanCount() { return totalBeanCount; }
public void setTotalBeanCount(int totalBeanCount) { this.totalBeanCount = totalBeanCount; }
public List<String> getBeanNames() { return beanNames; }
public void setBeanNames(List<String> beanNames) { this.beanNames = beanNames; }
public Map<String, BeanMetrics> getBeanMetrics() { return beanMetrics; }
public void setBeanMetrics(Map<String, BeanMetrics> beanMetrics) { this.beanMetrics = beanMetrics; }
}
}
/**
* 配置驱动的Bean工厂服务
*/
@Component
public class ConfigurationDrivenBeanFactoryService implements BeanFactoryAware {
private ConfigurableListableBeanFactory beanFactory;
private Environment environment;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
if (beanFactory instanceof ConfigurableListableBeanFactory) {
this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
this.environment = this.beanFactory.getBean(Environment.class);
}
}
/**
* 基于配置动态创建Bean
*/
public void createBeansFromConfiguration() {
// 从配置中读取Bean定义
String[] beanNames = environment.getProperty("dynamic.beans.names", String[].class, new String[0]);
for (String beanName : beanNames) {
String className = environment.getProperty("dynamic.beans." + beanName + ".class");
String scope = environment.getProperty("dynamic.beans." + beanName + ".scope", "singleton");
try {
Class<?> beanClass = Class.forName(className);
registerDynamicBean(beanName, beanClass, scope);
} catch (ClassNotFoundException e) {
System.err.println("无法加载类: " + className);
}
}
}
/**
* 注册动态Bean
*/
private void registerDynamicBean(String beanName, Class<?> beanClass, String scope) {
GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
beanDefinition.setBeanClass(beanClass);
beanDefinition.setScope(scope);
// 设置初始化和销毁方法
if (InitializingBean.class.isAssignableFrom(beanClass)) {
beanDefinition.setInitMethodName("afterPropertiesSet");
}
if (DisposableBean.class.isAssignableFrom(beanClass)) {
beanDefinition.setDestroyMethodName("destroy");
}
beanFactory.registerBeanDefinition(beanName, beanDefinition);
System.out.println("动态注册Bean: " + beanName + " (" + beanClass.getSimpleName() + ")");
}
/**
* 获取Bean工厂配置
*/
public BeanFactoryConfiguration getConfiguration() {
BeanFactoryConfiguration config = new BeanFactoryConfiguration();
config.setAllowBeanDefinitionOverriding(
beanFactory.getBeanDefinitionDefaults().isAllowBeanDefinitionOverriding());
config.setAutoGrowNestedPaths(
beanFactory.getBeanDefinitionDefaults().isAutoGrowNestedPaths());
return config;
}
/**
* Bean工厂配置类
*/
public static class BeanFactoryConfiguration {
private boolean allowBeanDefinitionOverriding;
private boolean autoGrowNestedPaths;
// Getters and Setters
public boolean isAllowBeanDefinitionOverriding() { return allowBeanDefinitionOverriding; }
public void setAllowBeanDefinitionOverriding(boolean allowBeanDefinitionOverriding) {
this.allowBeanDefinitionOverriding = allowBeanDefinitionOverriding;
}
public boolean isAutoGrowNestedPaths() { return autoGrowNestedPaths; }
public void setAutoGrowNestedPaths(boolean autoGrowNestedPaths) {
this.autoGrowNestedPaths = autoGrowNestedPaths;
}
}
}
8. 最佳实践和注意事项
/*
* BeanFactoryAware最佳实践
*/
/**
* 正确的实现方式
*/
@Component
public class GoodExampleService implements BeanFactoryAware {
private BeanFactory beanFactory;
private final Logger logger = LoggerFactory.getLogger(GoodExampleService.class);
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
// 保存引用
this.beanFactory = beanFactory;
// 记录日志
logger.info("BeanFactory已注入到 {}", this.getClass().getSimpleName());
}
/**
* 安全地获取Bean
*/
public <T> Optional<T> getBeanSafely(Class<T> beanClass) {
try {
return Optional.of(beanFactory.getBean(beanClass));
} catch (BeansException e) {
logger.warn("无法获取Bean {}: {}", beanClass.getSimpleName(), e.getMessage());
return Optional.empty();
}
}
/**
* 检查Bean是否存在
*/
public boolean isBeanExists(String beanName) {
return beanFactory.containsBean(beanName);
}
/**
* 获取Bean类型
*/
public Class<?> getBeanType(String beanName) {
try {
return beanFactory.getType(beanName);
} catch (NoSuchBeanDefinitionException e) {
return null;
}
}
}
/**
* 避免的错误实现
*/
@Component
public class BadExampleService implements BeanFactoryAware {
private BeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
// 错误1: 在Aware方法中执行复杂业务逻辑
performComplexBusinessLogic(); // 应该避免
// 错误2: 不处理异常
Object someBean = beanFactory.getBean("nonExistentBean"); // 可能抛出异常
// 错误3: 在Aware方法中进行Bean操作
beanFactory.getBean("someService").doSomething(); // 不推荐
}
private void performComplexBusinessLogic() {
// 复杂的业务逻辑不应该在这里执行
}
}
/**
* 现代化替代方案
*/
@Component
public class ModernAlternativeService {
// 推荐使用依赖注入
@Autowired
private BeanFactory beanFactory;
@Autowired
private ConfigurableBeanFactory configurableBeanFactory;
// 使用@PostConstruct进行初始化
@PostConstruct
public void initialize() {
logger.info("服务初始化完成");
// 可以在这里执行初始化逻辑
}
// 使用@PreDestroy进行清理
@PreDestroy
public void cleanup() {
logger.info("服务清理完成");
// 可以在这里执行清理逻辑
}
}
/**
* 线程安全的实现
*/
@Component
public class ThreadSafeService implements BeanFactoryAware {
private volatile BeanFactory beanFactory;
private final Object lock = new Object();
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
synchronized (lock) {
this.beanFactory = beanFactory;
}
}
/**
* 线程安全地获取Bean
*/
public <T> T getBean(Class<T> beanClass) {
BeanFactory factory = this.beanFactory;
if (factory == null) {
throw new IllegalStateException("BeanFactory尚未注入");
}
return factory.getBean(beanClass);
}
}
/**
* 使用泛型的类型安全实现
*/
@Component
public class GenericTypeSafeService implements BeanFactoryAware {
private BeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
}
/**
* 类型安全的Bean获取
*/
public <T> T getBean(Class<T> requiredType) {
return beanFactory.getBean(requiredType);
}
/**
* 带名称的类型安全Bean获取
*/
public <T> T getBean(String name, Class<T> requiredType) {
return beanFactory.getBean(name, requiredType);
}
/**
* 安全的Bean获取
*/
public <T> Optional<T> getBeanIfAvailable(Class<T> requiredType) {
try {
return Optional.of(getBean(requiredType));
} catch (NoSuchBeanDefinitionException e) {
return Optional.empty();
}
}
}
9. 核心设计要点总结
9.1 设计目的
- 提供Bean访问BeanFactory的途径
- 实现Bean与Spring容器的交互
- 支持动态Bean查找和服务获取
9.2 调用时机
- Bean实例化完成
- 属性注入完成
- setBeanFactory方法调用
- 其他Aware接口方法调用
- BeanPostProcessor处理
- InitializingBean.afterPropertiesSet()
9.3 使用建议
- 优先使用@Autowired注入：减少与Spring框架的耦合
- 谨慎使用：避免在业务逻辑中直接使用BeanFactory
- 异常处理：适当处理可能发生的BeansException
- 性能考虑：避免频繁的Bean查找操作
9.4 替代方案
- @Autowired注入BeanFactory
- 构造方法注入
- ObjectProvider延迟注入
- @Lookup注解
- @PostConstruct和@PreDestroy处理生命周期
9.5 常见应用场景
- 动态Bean查找
- Bean定义管理
- 手动Bean注册
- Bean生命周期管理
- 配置信息访问
- 类型转换服务
9.6 最佳实践
- 实现幂等性，确保可以安全地多次调用
- 适当的异常处理和日志记录
- 避免在Aware方法中执行复杂业务逻辑
- 考虑线程安全性
- 使用现代化的依赖注入方式
BeanFactoryAware作为Spring框架的重要组成部分，为开发者提供了访问容器功能的途径，但应该谨慎使用并优先考虑现代化的替代方案。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
