springBean生命周期(有参构造)

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 解析后的值