再读spring，说下自己的理解
核心过程分三步：
1 定义资源（Resource）
2 定义工厂 (BeanFactory)
3 配置资源读取器（BeanDefinitionReader）把资源与工厂整合起来。让资源为工厂服务，工厂为客户服务。这就是spring的核心思路。
之后由资源读取器BeanDefinitionParserDelegate进行委托解析xml文件，进行bean定义的读取。形成BeanDefinition.存入工厂的 concurrentHashMap中，完成bean初始化的一些定义性的工作。
再进行bean创建，创建前需要进行一些准备工作，这个是比较复杂的，包括读取bean定中的一些特殊的配置。决定用jdk的动态代理，还是cglib的动态代理。看是否有aop的配置。从而决定在生产代理的class时候，代理方法前后执行的业务逻辑。
spring可以这样理解为是一个大的工厂，这个工厂是一个产玩具鸡蛋的。
- 首先定义鸡蛋的定义（xml 文件：有壳，有黄，有清，材制）
- 定义产蛋的工厂标准（BeanFactory 可以产：木蛋，铁蛋，铜蛋，金蛋）
- 把蛋的标准拿来放以工厂里 (BeanDefinitionReader)
- 工厂读到蛋的标准后，会生产，生产蛋的模子（BeanDefinition）,这里就很灵活了，可以决定在生蛋之前或之后做什么操作（模板方法），可以决定在蛋滚动的时候做什么工作（AOP 前置方法，或后置方法）。
- 在客户需要蛋的时候，去工厂里拿。工厂发现这个蛋如果没有就现生产一个给客户。
- 下面是具体的代码层面的细节，希望大家一起学习交流。
容器初始化阶段
先来一段简单的代码
//1 定义资源 获取资源
Resource resource = new ClassPathResource("applicationContext.xml");
//2 定义工厂 获取 BeanFactory
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
//3 定义Bean资源读取器，把工厂与资源联系起来 根据新建的 BeanFactory 创建一个BeanDefinitionReader 对象，该 Reader 对象为资源的解析器
BeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
//4 加载资源 装载资源
reader.loadBeanDefinitions(resource);
//5 从工厂中获取bean
Student stu = (Student) factory.getBean("student");
System.out.println(stu.getName());
System.out.println(stu.getAge());整个过程分为四个步骤：资源定位、装载、解析、注册
资源定位部分比较简单,了解Resource、ResourceLoader接口以及常用实现类即可
装载时序图
从reader.loadBeanDefinitions(resource)开始
1、调用org.springframework.beans.factory.xml#XmlBeanDefinitionReader(资源解析器)的loadBeanDefinitions方法
2、将resource包装成org.springframework.core.io.support.EncodedResource对象,主要是为了对 Resource 进行编码，保证内容读取的正确性
5、通过encodedResource.getResource().getInputStream()获取InputStream,再通过new InputSource(inputStream)包装成org.xml.sax.InputSource对象,方便后续解析xml
8、通过getEntityResolver()获取org.xml.sax.EntityResolver接口的实现类,该实现类是为了寻找xml的验证文件,也就是.dtd 、.xsd文件,Spring对EntityResolver接口的实现类是
org.springframework.beans.factory.xml.BeansDtdResolver
org.springframework.beans.factory.xml.PluggableSchemaResolver
9、获取验证模式,主要是为了保证xml的正确性,以下是根据xml的内容获取的结果,也可以手动指定
// 禁用验证模式
public static final int VALIDATION_NONE = XmlValidationModeDetector.VALIDATION_NONE;
// 自动获取验证模式
public static final int VALIDATION_AUTO = XmlValidationModeDetector.VALIDATION_AUTO;
// DTD 验证模式
public static final int VALIDATION_DTD = XmlValidationModeDetector.VALIDATION_DTD;
// XSD 验证模式
public static final int VALIDATION_XSD = XmlValidationModeDetector.VALIDATION_XSD;
10、通过org.springframework.beans.factory.xml.DefaultDocumentLoader类最终调用jdk的 javax.xml 库进行解析返回org.w3c.dom.Document接口实现类
至此装载部分完成,接下来会对document进行解析,生成 BeanDefinition
解析document时序图
接上一个时序图,我们先看一下源码执行的位置
//org.springframework.beans.factory.xml.XmlBeanDefinitionReader
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
//获取Document实例
Document doc = doLoadDocument(inputSource, resource);
//注册document
int count = registerBeanDefinitions(doc, resource);
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + count + " bean definitions from " + resource);
}
return count;
}
//...省略无关代码
}
上一个时序图执行到获取Document实例,接下来通过registerBeanDefinitions方法完成document解析,生成BeanDefinition并且注册
从上述图中可以看出,整个过程主要用到了4个类(实际解析过程远比上图复杂)
XmlBeanDefinitionReader:
xml资源解析器,主要负责从xml文件中解析出document
XmlReaderContext:
解析过程中的上下文,包含了解析过程中的用到的配置资源、回调事件等
DefaultBeanDefinitionDocumentReader:
document解析类,包含了上下文XmlReaderContextBean和DefinitionParserDelegate,并且最后完成BeanDefinition注册
DefinitionParserDelegate:
解析document生成BeanDefinition
1、通过反射创建DefaultBeanDefinitionDocumentReader
4、创建上下文XmlReaderContext
8、创建DefinitionParserDelegate
11、初始化DefinitionParserDelegate,解析xml节点,获取lazyInit、merge、autowire、autowireCandidates、initMethod、destroyMethod等值
12、判断节点的命名空间是否是默认命名空间(“http://www.springframework.org/schema/beans”),如果是,则调用parseDefaultElement解析
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
//import
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
//alias
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
//bean
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
//beans
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}
14、如果不是默认命名空间,例如<tx:annotation-driven />,则调用parseCustomElement
最终会寻找META-INF/spring.handlers文件,根据命令空间可以找到相应的处理器进行解析,这里就是通过TxNamespaceHandler对<tx:annotation-driven />进行解析
因为篇幅原因,没有具体展开解析的细节,建议大家主要细看第12步中对bean节点的解析,在这个过程中会生成BeanDefinition,并且完成注册
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// 进行 bean 元素解析。
// <1> 如果解析成功，则返回 BeanDefinitionHolder 对象。而 BeanDefinitionHolder 为 name 和 alias 的 BeanDefinition 对象
// 如果解析失败，则返回 null 。
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// <2> 进行自定义标签处理
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// <3> 进行 BeanDefinition 的注册
// Register the final decorated instance.
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
//<4> 发出响应事件，通知相关的监听器，已完成该 Bean 标签的解析。
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
到这里为止解析和注册完结,但是这个时候得到的是BeanDefinition对象,里面只是装载了生成bean所需的参数和配置,并不是真正的bean,下面进入第二部分Bean 的加载
Bean 的加载
经过容器初始化阶段后，应用程序中定义的 bean 信息已经全部加载到系统中了，当我们显示或者隐式地调用 BeanFactory#getBean(…) 方法时，则会触发加载 Bean 阶段,例如下面这句
CyclicA cyclicA = (CyclicA) factory.getBean("cyclicA");
- 总体来说Bean 的加载大致分为四个阶段
准备工作、bean实例化、bean属性填充、bean初始化
准备工作时序图
时序图标号好像有点问题,先凑合看吧…
从上图可以看出bean创建前的准备工作还是挺多的,这里列举了一些比较重要的项
1、应用程序调用getBean,开始加载bean的流程
2、doGetBean(final String name, @Nullable final Class requiredType,
@Nullable final Object[] args, boolean typeCheckOnly)
- Class requiredType表示返回的结果转换成requiredType类型
- Object[] args 创建 Bean 时传递的参数。这个参数仅限于创建 Bean 时使用
- boolean typeCheckOnly 是否为类型检查
3、因为传入的name有可能是别名,通过这个方法找到真正的beanName(bean的唯一标示)
5、尝试从单例缓存中拿到bean对象,如果成功,则直接进入流程18,然后结束
8、判断在原型模式下是否存在循环依赖,如果有则会抛出异常,因为原型模式是没法使用缓存的,所以没办法处理循环依赖
9、这里会获取父类容器,如果在当前容器找不到相应的BeanDefinition,则去父容器寻找
11、因为之前创建的BeanDefinition实例是GenericBeanDefinition,这里需要转换成
RootBeanDefinition 对象,方便后续处理,如果父类 bean 不为空的话，则会一并合 并父类的属性
14、处理所依赖的 bean 这里指的是depends-on属性,depends-on适用于表面上看起来两个bean之间没有使用属性之类的强连接的bean，但是两个bean又确实存在前后依赖关系的情况，使用了depends-on的时候，依赖他人的bean是先于被依赖bean销毁的
17、前面所做的都是准备工作,这里开始进入实例化bean的流程,交给子类AbstractAutowireCapableBeanFactory完成
18、一般情况下，Spring通过反射机制利用的class属性指定实现类实例化Bean，在某些情况下，实例化Bean过程比较复杂，如果按照传统的方式，则需要在中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑
这里简单的对这部分源码注释,可以配合时序图看
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// <1> 返回 bean 名称，剥离工厂引用前缀。
// 如果 name 是 alias ，则获取对应映射的 beanName 。
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 从缓存中或者实例工厂中获取 Bean 对象
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// <2> 完成 FactoryBean 的相关处理，并用来获取 FactoryBean 的处理结果
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
//<3> 因为 Spring 只解决单例模式下得循环依赖，在原型模式下如果存在循环依赖则会抛出异常。
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// <4> 如果容器中没有找到，则从父类容器中加载
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
// <5> 如果不是仅仅做类型检查则是创建bean，这里需要记录
// 有一个Set<String> alreadyCreated 记录已经创建的bean
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
// <6> 从容器中获取 beanName 相应的 GenericBeanDefinition 对象，并将其转换为 RootBeanDefinition 对象
// 转换的同时，如果父类 bean 不为空的话，则会一并合并父类的属性。
// 这个容器就是之前 DefaultListableBeanFactory 中的 beanDefinitionMap
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查给定的合并的 BeanDefinition，检查是否是abstract
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// <7> 处理所依赖的 bean 这里指的是depends-on属性
//depends-on适用于表面上看起来两个bean之间没有使用属性之类的强连接的bean，但是两个bean又确实存在前后依赖关系的情况，使用了depends-on的时候，依赖他人的bean是先于被依赖bean销毁的
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
// 若给定的依赖 bean 已经注册为依赖给定的 bean
// 循环依赖的情况
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
// 缓存依赖调用
registerDependentBean(dep, beanName);
try {
//递归加载依赖的bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// <8> bean 实例化
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
//调用的 子类AbstractAutowireCapableBeanFactory的createBean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
// 显式从单例缓存中删除 Bean 实例
// 因为单例模式下为了解决循环依赖，可能他已经存在了，所以销毁它
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//原型模式
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
// 从指定的 scope 下创建 bean
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// <9> 检查需要的类型是否符合 bean 的实际类型
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
// 执行转换
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
最复杂的准备工作做完之后,接下来就是bean的实例化、属性填充、初始化
// <8> bean 实例化
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
//调用的 子类AbstractAutowireCapableBeanFactory的createBean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
// 显式从单例缓存中删除 Bean 实例
// 因为单例模式下为了解决循环依赖，可能他已经存在了，所以销毁它
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
- 以上代码片段中的createBean就是bean实例化的开始
bean实例化时序图
AbstractAutowireCapableBeanFactory
AbstractBeanFactory子类,AbstractBeanFactory调用的createBean只是一个模版方法,由子类去重写实现
ConstructorResolver
构造方法或者工厂类初始化 bean 的委托类,因为往往存在多个构造方法,所以这个类就负责匹配最合适的构造方法来实例化bean
SimpleInstantiationStrategy
负责bean实例化策略,如果发现BeanDefinition配置了lookup-method、replace-method属性,则调用子类CglibSubclassingInstantiationStrategy创建代理类
CglibSubclassingInstantiationStrategy
SimpleInstantiationStrategy子类,负责生成代理类
1、调用模版方法,由子类去实现创建bean的具体逻辑
protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException;
3、实例化的前置处理，生成bean的代理类,通常aop会在这里进行处理
5、进入实例化流程
6、如果在bean标签配置了factory-method属性,则通过工厂类去生成bean,支持静态工厂和实例工厂
//静态工厂
<bean id="clientService"
class="examples.ClientService"
factory-method="createInstance"/>
public class ClientService {
private static ClientService clientService = new ClientService();
private ClientService() {}
public static ClientService createInstance() {
return clientService;
}
}
//实例工厂
<bean id="serviceLocator" class="examples.DefaultServiceLocator">
<!-- inject any dependencies required by this locator bean -->
</bean>
<!-- the bean to be created via the factory bean -->
<bean id="clientService"
factory-bean="serviceLocator"
factory-method="createClientServiceInstance"/>
public class DefaultServiceLocator {
private static ClientService clientService = new ClientServiceImpl();
public ClientService createClientServiceInstance() {
return clientService;
}
}
8、如果传入的构造函数参数Object[] args不为空,或者配置了constructor-arg,说明构造函数有多个,需要匹配最合适的构造函数进行实例化
10、上一步匹配到合适的构造函数 或者 使用默认的构造函数 都会进入该流程进行实例化,在此过程中如果监测到配置了lookup-method、replace-method属性则通过CglibSubclassingInstantiationStrategy生成代理类, 否则直接使用反射实例化
接上一个时序图,我们看下源码执行的位置
//AbstractAutowireCapableBeanFactory.java
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
//....省略
// 使用合适的实例化策略来创建新的实例：工厂方法、构造函数自动注入、简单初始化
// 对应上面时序图5,bean实例化
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//......省略
// 解决单例模式的循环依赖
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 提前将创建的 bean 实例加入到 singletonFactories 中
// 这里是为了后期避免循环依赖
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 对 bean 进行填充，将各个属性值注入，其中，可能存在依赖于其他 bean 的属性则会递归初始依赖 bean
populateBean(beanName, mbd, instanceWrapper);
// 调用初始化方法
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
//...省略
// Register bean as disposable.
try {
// 检查bean是否配置了destroy-method、DisposableBean接口、AutoCloseable接口、DestructionAwareBeanPostProcessor接口
// 如果是，则在容器销毁的时候，调用相应的销毁、关闭方法
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
createBeanInstance(beanName, mbd, args)
bean实例化核心方法,上一个时序图已经介绍过了,
值得注意的是,在实例化后,spring将还未完工的bean放入了缓存中,这主要是为了解决在属性填充过程中发生的循环依赖问题
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
例如A–>B–>A, 当A填充到一半的时候会发现依赖B,于是去实例化B,当填充B的时候发现要依赖A,这个时候如果没有缓存机制,整个就会成为死循环,当加入了缓存,B就会在缓存中寻找到了A,虽然这个时候A还未完工,但是作为依赖协助B完成整个bean的加载已经足够,当B完成加载后,再接着返回完成A的加载
populateBean(beanName, mbd, instanceWrapper)
对 bean 进行填充，将各个属性值注入，其中可能存在依赖于其他 bean 的属性则会递归初始依赖 bean
initializeBean(beanName, exposedObject, mbd)
bean的初始化,主要是执行用户自定义的方法,
1、激活 Aware 方法，对特殊的 bean 处理：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
2、激活用户自定义的 init 方法 实现InitializingBean接口的bean或者定义了init-method
3、检查是否注册了后处理器BeanPostProcessor
registerDisposableBeanIfNecessary(beanName, bean, mbd)
检查bean是否配置了destroy-method、DisposableBean接口、AutoCloseable接口、DestructionAwareBeanPostProcessor接口,如果是，则在容器销毁的时候，调用相应的销毁、关闭方法
至此整个bean的生命周期已经介绍完毕,创建的过程中，可以根据用户的配置增加aop的选项。
692
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
