How SF uses BeanDefinition to achieve its target IoC, we understand by tracking the use of BeanDefinition.
Use starting point
Tracking the SF initialization process, the first point is: DefaultListableBeanFactory.preInstantiateSingletons. As shown below:
RootBeanDefinition is the bean definition used by Spring BeanFactory at runtime. It may be created by merging multiple mutually inherited original BeanDefinitions (generated from configuration metadata). Essentially, RootBeanDefinition can be used as a "unified" bean definition view at runtime.
Note: The bd (RootBeanDefinition) generated here is not passed to the method getBean(beanName) because it is cached in the beanFactory after the first generation. You can get it directly from the cache next time.
Class-RootBeanDefinition
RootBeanDefinition inherits from AbstractBeanDefinition, with main enhancements or limitations:
1. There cannot be inheritance (all are merged): setParentName is always null;
2. Determine the bean parser, including annotations, reflection types, classes, factory methods and suppliers;
3. Manage external Manager: Member, initialization method and destruction method, etc.;
@SuppressWarnings("serial")
public class RootBeanDefinition extends AbstractBeanDefinition {
//省略属性及11种构建函数
/* ParentName操作：ParentName必须为空(所有的继承类都合并成一个bean，这是RootBeanDefinition 的本质) */
@Override
public String getParentName() {
return null;
}
@Override
public void setParentName(@Nullable String parentName) {
if (parentName != null) {
throw new IllegalArgumentException("Root bean cannot be changed into a child bean with parent reference");
}
}
/* BeanDefinitionHolder(bean id、alias与BeanDefinition对应关系)操作*/
public void setDecoratedDefinition(@Nullable BeanDefinitionHolder decoratedDefinition) {
this.decoratedDefinition = decoratedDefinition;
}
@Nullable
public BeanDefinitionHolder getDecoratedDefinition() {
return this.decoratedDefinition;
}
/* bean的注解元素(含bean的所有注解)操作 */
public void setQualifiedElement(@Nullable AnnotatedElement qualifiedElement) {
this.qualifiedElement = qualifiedElement;
}
@Nullable
public AnnotatedElement getQualifiedElement() {
return this.qualifiedElement;
}
/** bean对应的解析类操作
解析类可以是ResolvableType 或者Class
ResolvableType：是Java.lang.reflect.Type的封装，最终将beanDefinition解析到对应Class的能力
Class：bean直接对应的Class
*/
public void setTargetType(@Nullable ResolvableType targetType) {
this.targetType = targetType;
}
public void setTargetType(@Nullable Class<?> targetType) {
this.targetType = (targetType != null ? ResolvableType.forClass(targetType) : null);
}
@Nullable
public Class<?> getTargetType() {
if (this.resolvedTargetType != null) {
return this.resolvedTargetType;
}
ResolvableType targetType = this.targetType;
return (targetType != null ? targetType.resolve() : null);
}
@Override
public ResolvableType getResolvableType() {
ResolvableType targetType = this.targetType;
if (targetType != null) {
return targetType;
}
ResolvableType returnType = this.factoryMethodReturnType;
if (returnType != null) {
return returnType;
}
Method factoryMethod = this.factoryMethodToIntrospect;
if (factoryMethod != null) {
return ResolvableType.forMethodReturnType(factoryMethod);
}
return super.getResolvableType();
}
/* 获得用于默认构造的首选构造函数（可以是多个）。如有必要，构造函数参数可以自动注入 */
@Nullable
public Constructor<?>[] getPreferredConstructors() {
return null;
}
/* 设置非重载方法工厂方法名称*/
public void setUniqueFactoryMethodName(String name) {
Assert.hasText(name, "Factory method name must not be empty");
setFactoryMethodName(name);
this.isFactoryMethodUnique = true;
}
/* 设置重载方法工厂方法名称 */
public void setNonUniqueFactoryMethodName(String name) {
Assert.hasText(name, "Factory method name must not be empty");
setFactoryMethodName(name);
this.isFactoryMethodUnique = false;
}
/* 判定是否是工厂方法 */
public boolean isFactoryMethod(Method candidate) {
return candidate.getName().equals(getFactoryMethodName());
}
/* 设置工厂方法的解析方法器（Java Method） */
public void setResolvedFactoryMethod(@Nullable Method method) {
this.factoryMethodToIntrospect = method;
if (method != null) {
setUniqueFactoryMethodName(method.getName());
}
}
/* 获取工厂方法的解析方法器（Java Method） */
@Nullable
public Method getResolvedFactoryMethod() {
return this.factoryMethodToIntrospect;
}
/* 设置bean的实例生产者 */
@Override
public void setInstanceSupplier(@Nullable Supplier<?> supplier) {
super.setInstanceSupplier(supplier);
Method factoryMethod = (supplier instanceof InstanceSupplier<?> instanceSupplier ?
instanceSupplier.getFactoryMethod() : null);
if (factoryMethod != null) {
setResolvedFactoryMethod(factoryMethod);
}
}
// 标识BeanDefinition是否已被MergedBeanDefinitionPostProcessor处理过
public void markAsPostProcessed() {
synchronized (this.postProcessingLock) {
this.postProcessed = true;
}
}
// 注册外部管理的Member(Member代表a field or a method or a constructor)
public void registerExternallyManagedConfigMember(Member configMember) {
synchronized (this.postProcessingLock) {
if (this.externallyManagedConfigMembers == null) {
this.externallyManagedConfigMembers = new LinkedHashSet<>(1);
}
this.externallyManagedConfigMembers.add(configMember);
}
}
// 判断是否外部管理Member
public boolean isExternallyManagedConfigMember(Member configMember) {
synchronized (this.postProcessingLock) {
return (this.externallyManagedConfigMembers != null &&
this.externallyManagedConfigMembers.contains(configMember));
}
}
// 获得外部管理Set<Member>
public Set<Member> getExternallyManagedConfigMembers() {
synchronized (this.postProcessingLock) {
return (this.externallyManagedConfigMembers != null ?
Collections.unmodifiableSet(new LinkedHashSet<>(this.externallyManagedConfigMembers)) :
Collections.emptySet());
}
}
// 注册外部管理的初始化方法（例如，用JSR-250的注解是用jakarta.annotation.PostConstruct初始化）
public void registerExternallyManagedInitMethod(String initMethod) {
synchronized (this.postProcessingLock) {
if (this.externallyManagedInitMethods == null) {
this.externallyManagedInitMethods = new LinkedHashSet<>(1);
}
this.externallyManagedInitMethods.add(initMethod);
}
}
// 判断是否是外部管理的初始化方法
public boolean isExternallyManagedInitMethod(String initMethod) {
synchronized (this.postProcessingLock) {
return (this.externallyManagedInitMethods != null &&
this.externallyManagedInitMethods.contains(initMethod));
}
}
// 判断是否是外部管理的初始化方法（忽略方法的可见性）
boolean hasAnyExternallyManagedInitMethod(String initMethod) {
synchronized (this.postProcessingLock) {
if (isExternallyManagedInitMethod(initMethod)) {
return true;
}
if (this.externallyManagedInitMethods != null) {
for (String candidate : this.externallyManagedInitMethods) {
int indexOfDot = candidate.lastIndexOf('.');
if (indexOfDot >= 0) {
String methodName = candidate.substring(indexOfDot + 1);
if (methodName.equals(initMethod)) {
return true;
}
}
}
}
return false;
}
}
// 获得外部管理的初始化方法
public Set<String> getExternallyManagedInitMethods() {
synchronized (this.postProcessingLock) {
return (this.externallyManagedInitMethods != null ?
Collections.unmodifiableSet(new LinkedHashSet<>(this.externallyManagedInitMethods)) :
Collections.emptySet());
}
}
// 解析可推测的bean销毁方法
public void resolveDestroyMethodIfNecessary() {
setDestroyMethodNames(DisposableBeanAdapter
.inferDestroyMethodsIfNecessary(getResolvableType().toClass(), this));
}
// 注册外部管理的销毁方法
public void registerExternallyManagedDestroyMethod(String destroyMethod) {
synchronized (this.postProcessingLock) {
if (this.externallyManagedDestroyMethods == null) {
this.externallyManagedDestroyMethods = new LinkedHashSet<>(1);
}
this.externallyManagedDestroyMethods.add(destroyMethod);
}
}
// 判断是否是外部管理的销毁方法
public boolean isExternallyManagedDestroyMethod(String destroyMethod) {
synchronized (this.postProcessingLock) {
return (this.externallyManagedDestroyMethods != null &&
this.externallyManagedDestroyMethods.contains(destroyMethod));
}
}
// 判断是否是外部管理的销毁方法（忽略方法的可见性）
boolean hasAnyExternallyManagedDestroyMethod(String destroyMethod) {
synchronized (this.postProcessingLock) {
if (isExternallyManagedDestroyMethod(destroyMethod)) {
return true;
}
if (this.externallyManagedDestroyMethods != null) {
for (String candidate : this.externallyManagedDestroyMethods) {
int indexOfDot = candidate.lastIndexOf('.');
if (indexOfDot >= 0) {
String methodName = candidate.substring(indexOfDot + 1);
if (methodName.equals(destroyMethod)) {
return true;
}
}
}
}
return false;
}
}
// 获得外部管理的销毁方法
public Set<String> getExternallyManagedDestroyMethods() {
synchronized (this.postProcessingLock) {
return (this.externallyManagedDestroyMethods != null ?
Collections.unmodifiableSet(new LinkedHashSet<>(this.externallyManagedDestroyMethods)) :
Collections.emptySet());
}
}
//克隆一个新的RootBeanDefinition
@Override
public RootBeanDefinition cloneBeanDefinition() {
return new RootBeanDefinition(this);
}
//类相等判断
@Override
public boolean equals(@Nullable Object other) {
return (this == other || (other instanceof RootBeanDefinition && super.equals(other)));
}
//类串化判断
@Override
public String toString() {
return "Root bean: " + super.toString();
}
}
Method - getMergedLocalBeanDefinition(String beanName)
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
// 从缓存获取
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null && !mbd.stale) {
return mbd;
}
// 新建RootBeanDefinition
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
/* 过渡类 */
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
throws BeanDefinitionStoreException {
return getMergedBeanDefinition(beanName, bd, null);
}
/** 真正实现合并BeanDefinition（主要合并继承关系）
* @param beanName：要合并的beanName
* @param bd：bean定义解析生成的BeanDefinition
* @param containingBd：对于内部类情况，包容该bean的BeanDefinition
*/
protected RootBeanDefinition getMergedBeanDefinition(
String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
throws BeanDefinitionStoreException {
//同步执行
synchronized (this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
RootBeanDefinition previous = null;
// 不是内部类bean，从缓存获取一次（两次检测）
if (containingBd == null) {
mbd = this.mergedBeanDefinitions.get(beanName);
}
/* 合并处理 mbd.stale-需要合并标志 */
if (mbd == null || mbd.stale) {
// 处理前的mbd
previous = mbd;
if (bd.getParentName() == null) {
// bd没有父级
// Use copy of given root bean definition.
if (bd instanceof RootBeanDefinition rootBeanDef) {
// 如果bd已经是RootBeanDefinition，直接克隆一份
mbd = rootBeanDef.cloneBeanDefinition();
}
else {
// 用bd生成RootBeanDefinition
mbd = new RootBeanDefinition(bd);
}
}
else {
// bd还有父级
// Child bean definition: needs to be merged with parent.
BeanDefinition pbd;
try {
String parentBeanName = transformedBeanName(bd.getParentName());
if (!beanName.equals(parentBeanName)) {
// 有真正的父级bean，合并方式生成父级BeanDefinition （此处是递归调用，因此可以合并所有继承关系）
pbd = getMergedBeanDefinition(parentBeanName);
}
else {
// 父级beanName同本身beanName相同，可能来自父级BeanFactory，从父级BeanFactory合并方式生成BeanDefinition
if (getParentBeanFactory() instanceof ConfigurableBeanFactory parent) {
pbd = parent.getMergedBeanDefinition(parentBeanName);
}
else {
throw new NoSuchBeanDefinitionException(parentBeanName,
"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
"': cannot be resolved without a ConfigurableBeanFactory parent");
}
}
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
}
// 以父级bean生成新RootBeanDefinition，然后用孩子bd的重写(子类有的就覆盖父类)，这样就把父子合并了（因为是递归调用，因此可以合并所有继承关系）
mbd = new RootBeanDefinition(pbd);
mbd.overrideFrom(bd);
}
// Set default singleton scope, if not configured before.
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(SCOPE_SINGLETON);
}
// 如果是内部类，scope同包容bean的scope
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
// 非内部类进行缓存 (isCacheBeanMetadata()代表来自缓存的元数据)
if (containingBd == null && isCacheBeanMetadata()) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
if (previous != null) {
//处理前的mbd进行相关性处理（主要同bean解析器和工厂方法相关）
copyRelevantMergedBeanDefinitionCaches(previous, mbd);
}
return mbd;
}
}
private void copyRelevantMergedBeanDefinitionCaches(RootBeanDefinition previous, RootBeanDefinition mbd) {
if (ObjectUtils.nullSafeEquals(mbd.getBeanClassName(), previous.getBeanClassName()) &&
ObjectUtils.nullSafeEquals(mbd.getFactoryBeanName(), previous.getFactoryBeanName()) &&
ObjectUtils.nullSafeEquals(mbd.getFactoryMethodName(), previous.getFactoryMethodName())) {
ResolvableType targetType = mbd.targetType;
ResolvableType previousTargetType = previous.targetType;
if (targetType == null || targetType.equals(previousTargetType)) {
mbd.targetType = previousTargetType;
mbd.isFactoryBean = previous.isFactoryBean;
mbd.resolvedTargetType = previous.resolvedTargetType;
mbd.factoryMethodReturnType = previous.factoryMethodReturnType;
mbd.factoryMethodToIntrospect = previous.factoryMethodToIntrospect;
}
}
}
Create bean instance using
This is where BeanDefinition really comes into play. The entry point is AbstractAutowireCapableBeanFactory.createBean.
Create portal
/* 创建bean实例 */
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
//获取bean定义对应的Class
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
//如果mbd还没有解析Class，写回
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
// 对override方法做覆盖处理
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 实例化前处理
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// 创建实例 注1
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
Note 1: doCreateBean creates instance method path: doCreateBean->createBeanInstance->instantiateBean. The intermediate method is to deal with various situations, and finally actually generate bean instances in instantiateBean
AbstractAutowireCapableBeanFactory.resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>… typesToMatch)
Parse the Class corresponding to RootBeanDefinition
// 过渡类
@Nullable
protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch)
throws CannotLoadBeanClassException {
try {
if (mbd.hasBeanClass()) {
return mbd.getBeanClass();
}
return doResolveBeanClass(mbd, typesToMatch);
}
catch (ClassNotFoundException ex) {
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
}
catch (LinkageError err) {
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
}
}
// 解析bean的Class
@Nullable
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
throws ClassNotFoundException {
ClassLoader beanClassLoader = getBeanClassLoader();
ClassLoader dynamicLoader = beanClassLoader;
boolean freshResolve = false;
if (!ObjectUtils.isEmpty(typesToMatch)) {
// 如果仅做类型检查（不生成bean实例），用临时ClassLoader检查处理。
ClassLoader tempClassLoader = getTempClassLoader();
if (tempClassLoader != null) {
dynamicLoader = tempClassLoader;
// freshResolve 为true，后续会进行Class解析
freshResolve = true;
if (tempClassLoader instanceof DecoratingClassLoader dcl) {
for (Class<?> typeToMatch : typesToMatch) {
dcl.excludeClass(typeToMatch.getName());
}
}
}
}
String className = mbd.getBeanClassName();
if (className != null) {
//className用表达式方式进行解析，解析出同mbd相关的class
Object evaluated = evaluateBeanDefinitionString(className, mbd);
if (!className.equals(evaluated)) {
/* 解析结果同className不一样 */
if (evaluated instanceof Class<?> clazz) {
// 解析出的是Class
return clazz;
}
else if (evaluated instanceof String name) {
// 解析出的是String
className = name;
freshResolve = true;
}
else {
throw new IllegalStateException("Invalid class name expression result: " + evaluated);
}
}
if (freshResolve) {
if (dynamicLoader != null) {
try {
//用动态加载器加载className对应的Class
return dynamicLoader.loadClass(className);
}
catch (ClassNotFoundException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex);
}
}
}
//用spring的ClassUtils加载className对应的Class
return ClassUtils.forName(className, dynamicLoader);
}
}
// 返回null (className不为空，前面处理了；为空，该方法实际也返回null
return mbd.resolveBeanClass(beanClassLoader);
}
truly create
doCreateBean creates instance method path: doCreateBean->createBeanInstance->instantiateBean. The intermediate method is to deal with various situations and finally generate bean instances in instantiateBean
/** SF中，BeanWrapper是JavaBean的封装器，可提供分析和操作标准JavaBeans的操作：
1、能够获取和设置属性值（单独或批量）
2、获取属性描述符以及查询属性的可读性/可写性
*/
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
try {
// 初始化一个bean实例 注1
Object beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
// 封装bean实例
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, ex.getMessage(), ex);
}
}
Note 1: SF’s bean instance initializer is CglibSubclassingInstantiationStrategy. For details on how to initialize, see: Learn SF Framework Series 5.8-Module Beans-bean Instantiation Tracking