SpringFramework源码剖析——DefaultListableBeanFactory
大家都知道Spring框架主要提供了IoC与AOP两种能力，而IoC能力主要涉及到Bean的注册，AOP更多的是与上下文相关的配置。Bean的注册主要由BeanFactory负责，而ApplicationContext则负责程序完整上下文管理，从继承关系也可以看出来ApplicationContext是BeanFactory的超集，ApplicationContext是BeanFactory功能的拓展。
public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
@Nullable
String getId();
String getApplicationName();
String getDisplayName();
long getStartupDate();
@Nullable
ApplicationContext getParent();
AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
}
BeanFactory
官网介绍：https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-beanfactory
官网介绍
总结：
- BeanFactory是IoC的基础，DefaultListableBeanFactory是关键的实现(看DefaultListableBeanFactory就行了)
- BeanFactory与其他组件交互主要通过 BeanFactoryAware, InitializingBean, DisposableBean这些类
- 底层BeanFactory不会感知配置的方式(通过xml还是注解来实现配置)，配置的感知由拓展类(XmlBeanDefinitionReader 、AutowiredAnnotationBeanPostProcessor)实现。
DefaultListableBeanFactory源码
从DefaultListableBeanFactory开始，整个继承关系如下：
各个类、接口功能大概描述一下：
AliasRegistry：别名注册接口，定义别名增删改查动作
SimpleAliasRegistry：管理一个aliasMap，注册别名
SingletonBeanRegistry：定义单例的注册获取相关动作
DefaultSingletonBeanRegistry：SingletonBeanRegistry的最简单实现，实现了单例bean的注册，著名的三层缓存解决循环依赖在源码中也有体现。
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
synchronized(this.singletonObjects) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
BeanFactory：BeanFactory的基本定义，特殊前缀 FACTORY_BEAN_PREFIX = “&”;
FactoryBeanRegistrySupport：继承DefaultSingletonBeanRegistry，实际上也是一个单例的注册器，只不过是针对FactoryBean特殊处理的，维护一个factoryBeanObjectCache的Map
ConfigurableBeanFactory：提供了配置化Bean的实现，在HierarchicalBeanFactory, SingletonBeanRegistry基础上，增加了SCOPE类型(singleton\prototype)，增加了Bean的额外的配置信息
AutowireCapableBeanFactory：提供了自动装配Bean的实现，提供bean创建(带有构造函数解析)、属性填充、连接(包括自动装配)和初始化。处理运行时bean引用、解析托管集合、调用初始化方法等。支持自动装配构造函数、按名称的属性和按类型的属性。
ListableBeanFactory：提供了一系列枚举Bean的方法，比如根据Type把相关的Bean列出来、根据Annotation把相关Bean列出来等。
ConfigurableListableBeanFactory：整合ConfigurableBeanFactory、AutowireCapableBeanFactory、ListableBeanFactory。
AbstractBeanFactory：支持管理FactoryBean与通过配置的方式注册的Bean的抽象类。
AbstractAutowireCapableBeanFactory：继承了AbstractBeanFactory与实现了AutowireCapableBeanFactory接口，支持管理通过autowire自动装配注册的bean与配置方式注册的Bean。
DefaultListableBeanFactory：spring中最基础的BeanFactory实现类，官方API描述：Spring’s default implementation of the ConfigurableListableBeanFactory and BeanDefinitionRegistry interfaces: a full-fledged bean factory based on bean definition metadata, extensible through post-processors.
关键代码
resolveBean方法：根据Type获取对应的NameBean实例
private <T> T resolveBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) {
NamedBeanHolder<T> namedBean = this.resolveNamedBean(requiredType, args, nonUniqueAsNull);//先本Factory处理
if (namedBean != null) {
return namedBean.getBeanInstance();//若本Factory含有对应name的bean，则直接返回
} else {
BeanFactory parent = this.getParentBeanFactory();//若没有，则从parentFactory找
if (parent instanceof DefaultListableBeanFactory) {
return ((DefaultListableBeanFactory)parent).resolveBean(requiredType, args, nonUniqueAsNull);//如果parent依然是DefaultListableBeanFactory默认实现，则继续调用resolveBean方法递归
} else if (parent != null) {
ObjectProvider<T> parentProvider = parent.getBeanProvider(requiredType);//若parent不是默认的DefaultListableBeanFactory，则需要从BeanProvider列表中找到对用的BeanProvider
if (args != null) {
return parentProvider.getObject(args);//若args不为空，则直接调用provider的getObject方法
} else {
return nonUniqueAsNull ? parentProvider.getIfUnique() : parentProvider.getIfAvailable();//getBean传入nonUniqueAsNull为false，说明如果有多个实例，不会抛异常，可以根据某些条件返回，提供更宽松的注入方式
}
} else {
return null;
}
}
}
@Nullable
private <T> NamedBeanHolder<T> resolveNamedBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) throws BeansException {
Assert.notNull(requiredType, "Required type must not be null");
String[] candidateNames = this.getBeanNamesForType(requiredType);//根据class找到所有已加载的Bean，包括继承关系、实现等，具体可看doGetBeanNamesForType方法，关键方法isTypeMatch，底层调用Class.isAssignableFrom本地方法
String[] var6;
int var7;
int var8;
String beanName;
if (candidateNames.length > 1) {
List<String> autowireCandidates = new ArrayList(candidateNames.length);
var6 = candidateNames;
var7 = candidateNames.length;
for(var8 = 0; var8 < var7; ++var8) {
beanName = var6[var8];
if (!this.containsBeanDefinition(beanName) || this.getBeanDefinition(beanName).isAutowireCandidate()) {
autowireCandidates.add(beanName);
}
}
//优先选取autowire方式加载的Bean
if (!autowireCandidates.isEmpty()) {
candidateNames = StringUtils.toStringArray(autowireCandidates);
}
}
//若候选Bean长度为1，则直接返回
if (candidateNames.length == 1) {
String beanName = candidateNames[0];
return new NamedBeanHolder(beanName, this.getBean(beanName, requiredType.toClass(), args));
} else {
if (candidateNames.length > 1) {
Map<String, Object> candidates = CollectionUtils.newLinkedHashMap(candidateNames.length);
var6 = candidateNames;
var7 = candidateNames.length;
for(var8 = 0; var8 < var7; ++var8) {
beanName = var6[var8];
//如果是单例，则判断是否为空，获取实例塞进候选实例map
if (this.containsSingleton(beanName) && args == null) {
Object beanInstance = this.getBean(beanName);
candidates.put(beanName, beanInstance instanceof NullBean ? null : beanInstance);
} else {
//否则直接根据BeanName获取实例塞进map
candidates.put(beanName, this.getType(beanName));
}
}
//
String candidateName = this.determinePrimaryCandidate(candidates, requiredType.toClass());//调用getMergedLocalBeanDefinition合并bean的parent所有属性，判断是否配置为primary，如果有设置primary则优先使用，若有多个primary则抛异常
if (candidateName == null) {
candidateName = this.determineHighestPriorityCandidate(candidates, requiredType.toClass());//若不存在primary，则根据priority查找优先级最高的
}
if (candidateName != null) {
Object beanInstance = candidates.get(candidateName);
if (beanInstance == null || beanInstance instanceof Class) {
beanInstance = this.getBean(candidateName, requiredType.toClass(), args);
}
return new NamedBeanHolder(candidateName, beanInstance);
}
if (!nonUniqueAsNull) {
throw new NoUniqueBeanDefinitionException(requiredType, candidates.keySet());
}
}
return null;
}
}
createBean方法：初始化生成bean实例过程
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);//根据beanName获取bean的class，可能存在继承关系需要逐层解析
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
mbdToUse.prepareMethodOverrides();//如有涉及方法重载，则把方法的overloaded属性设置为false
} catch (BeanDefinitionValidationException var9) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
}
Object beanInstance;
try {
//执行InstantiationAwareBeanPostProcessor，执行完后，bean对象已经实例化好，但未初始化
beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
//若有代理，则直接返回代理对象
if (beanInstance != null) {
return beanInstance;
}
} catch (Throwable var10) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
}
try {
//调用doCreateBean创建Bean实例，涉及到SmartInstantiationAwareBeanPostProcessor可以拓展
beanInstance = this.doCreateBean(beanName, mbdToUse, args);
if (this.logger.isTraceEnabled()) {
this.logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
} catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
throw var7;
} catch (Throwable var8) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
}
}
关键方法：this.resolveBeforeInstantiation(beanName, mbdToUse)，调用注册的所有InstantiationAwareBeanPostProcessor，分别在实例化前与实例化后执行一个回调方法，感知bean实例化，实现注入、返回代理对象等(AOP)操作。
实现AOP关键代码：
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
Object cacheKey = this.getCacheKey(beanClass, beanName);
if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}
if (this.isInfrastructureClass(beanClass) || this.shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
TargetSource targetSource = this.getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
if (StringUtils.hasLength(beanName)) {
this.targetSourcedBeans.add(beanName);
}
//根据beanName与beanClass获取所有的advice
Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
//创建proxy并返回
Object proxy = this.createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
} else {
return null;
}
}
initializeBean方法
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(() -> {
this.invokeAwareMethods(beanName, bean);
return null;
}, this.getAccessControlContext());
} else {
//执行BeanFactory注册的Aware方法——这也是个比较重要的特性
this.invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//调用注册的BeanProcessor的初始化前方法：postProcessBeforeInitialization
wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}
try {
//执行定义的Init方法
this.invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable var6) {
throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
}
if (mbd == null || !mbd.isSynthetic()) {
//调用注册的BeanProcessor的初始化后方法：postProcessAfterInitialization
wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
invokeAwareMethods方法：通过实现接口，spring自动识别向bean中注入beanName\beanFactory等
private void invokeAwareMethods(String beanName, Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
((BeanNameAware)bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = this.getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
}
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware)bean).setBeanFactory(this);
}
}
}
BeanPostProcessorCache类
在AbstractBeanFactory里面有一个Cache类，里面缓存了多种BeanPostProcessor，Spring中BeanFactory的灵活拓展正是通过BeanPostProcessor实现
static class BeanPostProcessorCache {
final List<InstantiationAwareBeanPostProcessor> instantiationAware = new ArrayList();
final List<SmartInstantiationAwareBeanPostProcessor> smartInstantiationAware = new ArrayList();
final List<DestructionAwareBeanPostProcessor> destructionAware = new ArrayList();
final List<MergedBeanDefinitionPostProcessor> mergedDefinition = new ArrayList();
BeanPostProcessorCache() {
}
}
总结
杂七杂八的写了挺多的，感觉看完DefaultListableBeanFactory这个类之后对Spring框架对Bean的加载过程有了比较深刻的理解，之前看过一些文章提到的Bean生命周期、BeanPostProcessor的执行、AOP实现的原理等在上文都有一丢丢的体现。以上纯属个人理解，如有错误欢迎指出交流，看完一遍后感觉有了大概了雏形，如果要有更深刻的理解可能得多读几遍源码。
2807
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
