1 ClassPathXmlApplicationContext
独立的XML应用程序上下文,从类路径获取上下文定义文件,将普通路径解释为类路径资源名,其中包含包路径
// 最终调用的是AbstractApplicationContext的构造方法
super(parent);
// 生成上下文的一个StandardEnvironment实例,并加载了系统和环境属性
// 替换给定的配置文件中的占位符(${})
setConfigLocations(configLocations);
if (refresh) {
// 容器初始化
refresh();
}
Image 1 观察者模式
如果想在容器不同的阶段做不同的事情,那么怎么处理?
Image 2 refresh
refresh()是 Spring 最核心的方法
2 AbstractApplicationContext
简单地实现公共上下文功能。使用模板方法设计模式简单地实现公共上下文功能。使用模板方法设计模式,需要具体的子类来实现抽象方法。
// 根据bean标签中的定义获取或创建bean
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
}
// 完成此上下文的bean工厂的初始化,初始化所有剩余的单例bean。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}
3 DefaultListableBeanFactory
在访问bean之前,先注册所有的bean定义(可能从bean定义文件中读取)。因此,在本地Bean定义表中,按名称查找Bean是一种廉价的操作,操作于预先解析的Bean定义元数据对象
public void preInstantiateSingletons() throws BeansException {
// 遍历xml以允许初始化方法,而初始化方法又会注册新的bean定义。
// 获取所有beanid
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 根据id获取bean标签中所有的属性并封装成一个RootBeanDefinition对象
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 回调,调用创建bean的方法
getBean(beanName);
}
4 AbstractBeanFactory
BeanFactory实现的抽象基类;这个类提供了一个单例缓存(通过它的基类DefaultSingletonBeanRegistry、单例/原型确定、FactoryBean处理、别名、子bean定义的bean定义合并和bean销毁)。DisposableBean接口,自定义销毁方法)。此外,它可以通过实现org.springframework.beans.factory.HierarchicalBeanFactory接口来管理bean工厂层次结构(如果是未知的bean,则将其委托给父级)。有两个子类DefaultListableBeanFactory和AbstractAutowireCapableBeanFactory
// 返回一个bean的实例
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
// 将xml中的字符串转为bean名
String beanName = transformedBeanName(name);
// 率先直接从单例缓存或objectFactory中提取bean,容器内部初始化和非初始化(手动调用)过程也都被调用
Object sharedInstance = getSingleton(beanName);
/**
* if 判断值是否为空,参数为否为空
* else 判断是否为原型,且该bean是否被标记为正在创建中
* if 原型模式下如果存在循环依赖的情况,那么直接抛出异常
*/
//检查该工厂中是否存在bean定义
BeanFactory parentBeanFactory = getParentBeanFactory();
if (!typeCheckOnly) {
// 为指定的bean删除合并的bean定义,在下次访问时重新创建它
// 将指定的bean标记为已经创建(或即将创建)。
markBeanAsCreated(beanName);
}
// 获取Bean的定义信息
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查给定的合并bean定义,可能会抛出验证异常
checkMergedBeanDefinition(mbd, beanName, args);
// 判断bean是否为单例后,开启调用创建bean实例的方法
// 通过lomba表达式,判断该Bean是否AOP
sharedInstance = getSingleton(beanName, () -> {
// 调用创建bean的方法
return createBean(beanName, mbd, args);
}
}
// 解析Bean类
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
throws ClassNotFoundException {
// 在BeanDefinition中缓存结果
return mbd.resolveBeanClass(beanClassLoader);
}
5 DefaultSingletonBeanRegistry
共享bean实例的通用注册中心,实现SingletonBeanRegistry。允许注册应该为注册中心的所有调用者共享的单例实例,并通过bean名获得
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
// 从一级缓存中获取值
Object singletonObject = this.singletonObjects.get(beanName);
// 里面有两个set类型的集合,防止多次创建代理对象,导致对象不同
// inCreationCheckExclusions:标记为正在创建中的集合
// singletonsCurrentlyInCreation; 正在创建的bean集合
beforeSingletonCreation(beanName);
/**
* 回调,创建bean
*/
singletonObject = singletonFactory.getObject();
}
)
6 AbstractAutowireCapableBeanFactory
实现默认bean创建的抽象bean工厂超类,具有RootBeanDefinition类指定的全部功能。除了AbstractBeanFactory的createBean方法之外,还实现了AutowireCapableBeanFactory接口
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// 获取bean的定义信息
RootBeanDefinition mbdToUse = mbd;
// 解析bean名,获取bean的全类名
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
// 调用创建bean的方法
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
}
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// 工厂方法、构造函数自动装配或简单实例化
instanceWrapper = createBeanInstance(beanName, mbd, args);
// 获取全类名
Class<?> beanType = instanceWrapper.getWrappedClass();
// bean属性赋值
populateBean(beanName, mbd, instanceWrapper);
// 对于传统定义的bean,从createBean调用,对于现有的bean实例,从initializeBean调用
// bean 初始化
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
// 调用对象的构造方法实例化对象
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 解析的bean类
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// if 候选构造函数,如果没有指定则为空
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
// else 自动装配构造函数
return autowireConstructor(beanName, mbd, ctors, args);
}
// 创建一个新实例的BeanWrapper
protected BeanWrapper autowireConstructor(
String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}
7 ConstructorResolver
解析构造函数和工厂方法。
通过实参匹配执行构造函数解析
// 创建一个新实例的BeanWrapper
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
// 初始化 用于创建和填充bean实例的BeanWrappers
this.beanFactory.initBeanWrapper(bw);
// 通过反射获取所有的构造方法并存放
Constructor<?>[] candidates = chosenCtors
// 确定是应用setter自动装配还是构造函数自动装配
mbd.getResolvedAutowireMode()
// 获取此bean的构造函数参数值
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
// 构造方法(有参赋值)
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
// 获取参数类型
Class<?>[] paramTypes = candidate.getParameterTypes();
// 获取用户声明的构造函数
getUserDeclaredConstructor(candidate)
// 得到可转让的参数
argsHolder.getAssignabilityWeight(paramTypes)
// 快速储存值
argsHolderToUse.storeCache(mbd, constructorToUse);
// bean实例化
bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
}
// 将此bean的构造函数参数解析到resolvedValues对象中。这可能涉及到查找其他bean(本类中,存在其他类且为成员变量)
private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd, BeanWrapper bw,
ConstructorArgumentValues cargs, ConstructorArgumentValues resolvedValues) {
// 当前遍历的参数值没有转换过,那么对参数值进行转换,然后添加到resolvedValues中
Object resolvedValue =
valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
ConstructorArgumentValues.ValueHolder resolvedValueHolder = new ConstructorArgumentValues.ValueHolder(
resolvedValue, valueHolder.getType(), valueHolder.getName());
resolvedValueHolder.setSource(valueHolder);
resolvedValues.addGenericArgumentValue(resolvedValueHolder);
}
Image 1 bean实例化
Image 2 有参构造
赋值
Image 4 赋值结果
8 AbstractBeanDefinition
自动连接常数与AutowireCapableBeanFactory接口中定义的常数相匹配
public Class<?> resolveBeanClass(@Nullable ClassLoader classLoader) throws ClassNotFoundException {
// 获取所提供名称的类实例
Class<?> resolvedClass = ClassUtils.forName(className, classLoader);
}
9 ClassUtils
工具方法
// 所提供名称的类实例
public static Class<?> forName(String name, @Nullable ClassLoader classLoader)
throws ClassNotFoundException, LinkageError {
return Class.forName(name, false, clToUse);
}
10 BeanDefinitionValueResolver
将包含在bean定义对象中的值解析为应用到目标bean实例的实际值
// 给定一个PropertyValue,返回一个值,在必要时解析对工厂中其他bean的任何引用
public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
// 解析值
TypedStringValue typedStringValue = (TypedStringValue) value;
// 类型
Class<?> resolvedTargetType = resolveTargetType(typedStringValue);
}
// 解析后的值
protected Object evaluate(TypedStringValue value) {
Object result = doEvaluate(value.getValue());
}
Image 1 解析后的值