经过一个多月的努力，我终于完成了对spring核心源码的阅读，其内部结构之巧妙令我大受震撼。本着趁热打铁的原则，我打算将一个多月的所学浓缩成这篇文章，给大家分享。
在开始正式内容之前，我有两点前提要跟大家交代。首先，这篇文章是对spring核心源码的解读，因篇幅有限基础的spring知识我就不再赘述，对spring不了解的朋友们可能阅读起来比较吃力，建议先去学习spring的基础内容。其次，我想明确一下分析的粒度，相信大家都知道，spring是一个庞大的工程，面对成千上万行代码，任何人都不可能面面俱到，那么分析什么、分析到什么程度就显得尤为重要。本篇文章旨在从源码的角度为大家建立一个spring框架的整体运行流程结构，所以分析过程紧跟spring的主体运行过程走，与主体运行相关性不大的东西我们将会省略。就如同拆解一辆超级跑车，我们只带大家拆到发动机、轮子、变速箱，至于发动机中的齿轮、活塞、橡皮圈，就不在我们讨论的范围之内了。ok，话不多说，这就开始吧！
相信大家都知道spring有两大核心功能，ioc(控制反转 Inversion of Control) 和 aop(面向切面编程 Aspect Oriented Programming),让我们先从ioc开始对spring进行拆解。ioc的核心目的就是把对象（以下成为bean）的创建和管理交给spring容器来做，由此看来bean的创建是spring ioc功能的核心。那么bean的创建分为那几步呢？回想一下手动创建bean的过程，可以想到bean创建分为三大步，bean定义信息读取封装、bean实例化、初始化和内容填充。这仨大步又可拆分成若干小步，接下来将逐一讲解。
1.1容器的解读
容器是spring一切工作的基础，本文章将以spring最常用的容器ClassPathXmlApplicationContext为切入点进行讲解。容器的创建是一件非常简单的操作：
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("Context.xml"); 其中Context.xml为配置文件路径。
继续追入构造方法可以看到
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {
super(parent);
this.setConfigLocations(configLocations);//设置配置文件地址
if (refresh) {
//刷新容器，所有工作的重点
this.refresh();
}
}
进入refresh（）方法，容器创建的相关工作一目了然：
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) {
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
//准备上下文环境
this.prepareRefresh();
// 获取bean工厂，bean创建有关的大部分工作都在beanfactory中完成，我们关心的bean定义信息的读取也在beanfactory创建时完成
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
//对beanfactory进行功能扩充
this.prepareBeanFactory(beanFactory);
try {
//BeanFactory创建完成的后置处理器，留给用户重写方法
this.postProcessBeanFactory(beanFactory);
StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
//激活BeanFactory的后置处理器
this.invokeBeanFactoryPostProcessors(beanFactory);
//注册bean的后置处理器（前者是BeanFactory创建完成后调用，后者是BeanFactory中的bean加载完成后调用，这里仅是注册）
this.registerBeanPostProcessors(beanFactory);
//结束后置处理流程
beanPostProcess.end();
//初始化消息源
this.initMessageSource();
//初始化消息广播器，默认由applicationEventMulticaster负责消息广播
this.initApplicationEventMulticaster();
//留给子类实现功能
this.onRefresh();
//注册所有事件监听器
this.registerListeners();
//初始化剩下的单实例bean（多实例bean不在容器创建时实例化），我们将从这一步为出发点分析bean的实例化过程
this.finishBeanFactoryInitialization(beanFactory);
//完成刷新过程，发出ContextRefreshEvent事件
this.finishRefresh();
} catch (BeansException var10) {
if (this.logger.isWarnEnabled()) {
this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var10);
}
//出现问题销毁
this.destroyBeans();
this.cancelRefresh(var10);
throw var10;
} finally {
this.resetCommonCaches();
contextRefresh.end();
}
}
}
这里还有一张图辅助了解refresh的全过程
1.2bean配置信息的读取
让我们追入第一处标红的方法obtainFreshBeanFactory()
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
this.refreshBeanFactory();
return this.getBeanFactory();
}
追入refreshBeanFactory( ) 方法
protected final void refreshBeanFactory() throws BeansException {
if (this.hasBeanFactory()) {
this.destroyBeans();
this.closeBeanFactory();
}
try {
//创建bean工厂
DefaultListableBeanFactory beanFactory = this.createBeanFactory();
//设置序列化ID
beanFactory.setSerializationId(this.getId());
//对创建好的bean工厂进行定制，可自主实现功能增强
this.customizeBeanFactory(beanFactory);
//加载bean定义信息，重点
this.loadBeanDefinitions(beanFactory);
this.beanFactory = beanFactory;
} catch (IOException var2) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + this.getDisplayName(), var2);
}
}
继续进入bean定义信息加载方法loadBeanDefinitions（）
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) {
//加载bean定义信息的读取器，因为bean定义信息使用xml文件保存，故加载的是xmlBeanDefinitionReader，bean定义信息的读取将由读取器负责。
XmlBeanDefinitionReader beanDefinitionReader = newXmlBeanDefinitionReader(beanFactory);
//设置环境
beanDefinitionReader.setEnvironment(this.getEnvironment());
//设置资源加载器
beanDefinitionReader.setResourceLoader(this);
//设置内容解析器
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
//初始化加载器
this.initBeanDefinitionReader(beanDefinitionReader);
//开始读取bean定义信息
this.loadBeanDefinitions(beanDefinitionReader);
}
XmlBeanDefinitionReader中的loadBeanDefinitions(EncodedResource encodedResource)方法负责读取bean定义信息
截取其中的一小段代码：
//创建输入流
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
//设置字符编码
inputSource.setEncoding(encodedResource.getEncoding());
}
//根据输入流加载bean定义信息，var6为加载的bean定义系信息总数
var6 = this.doLoadBeanDefinitions(inputSource, encodedResource.getResource());
追入doLoadBeanDefinitions（）方法
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {
try {
//配置文件被封装为文档对象Document
Document doc = this.doLoadDocument(inputSource, resource);
//根据文档对象注册bean定义信息
int count = this.registerBeanDefinitions(doc, resource);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Loaded " + count + " bean definitions from " + resource);
}
return count;
...}
至此我们可以看到，bean定义信息被封装为BeanDefinition对象，在bean工厂中保存，BeanDefinition加载的具体过程为：先由输入数据流InputSource读入配置文件，再封装为Document对象，再由Document对象依次注册bean定义信息BeanDefinition。这就是bean定义信息加载的全部过程，下面对两个关键对象Document和BeanDefinition的关键信息进行展示
Document：
public class DeferredDocumentImpl extends DocumentImpl implements DeferredNode {
...
//
// Data
//
/** Node count. */
protected transient int fNodeCount = 0;
/** Node types. */
protected transient int fNodeType[][];
/** Node names. */
protected transient Object fNodeName[][];
/** Node values. */
protected transient Object fNodeValue[][];
/** Node parents. */
protected transient int fNodeParent[][];
/** Node first children. */
protected transient int fNodeLastChild[][];
/** Node prev siblings. */
protected transient int fNodePrevSib[][];
/** Node namespace URI. */
protected transient Object fNodeURI[][];
/** Extra data. */
protected transient int fNodeExtra[][];
/** Identifier count. */
protected transient int fIdCount;
/** Identifier name indexes. */
protected transient String fIdName[];
/** Identifier element indexes. */
protected transient int fIdElement[];
/** DOM2: For namespace support in the deferred case.
*/
// Implementation Note: The deferred element and attribute must know how to
// interpret the int representing the qname.
protected boolean fNamespacesEnabled = false;
//
// private data
//
private transient final StringBuilder fBufferStr = new StringBuilder();
private transient final ArrayList fStrChunks = new ArrayList();
//
// Constructors
//
/**
* NON-DOM: Actually creating a Document is outside the DOM's spec,
* since it has to operate in terms of a particular implementation.
*/
public DeferredDocumentImpl() {
this(false);
} // <init>()
/**
* NON-DOM: Actually creating a Document is outside the DOM's spec,
* since it has to operate in terms of a particular implementation.
*/
public DeferredDocumentImpl(boolean namespacesEnabled) {
this(namespacesEnabled, false);
...BeanDefinition各种有关bean的信息一目了然：
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor implements BeanDefinition, Cloneable {
...
@Nullable
private volatile Object beanClass;
@Nullable
private String scope;
private boolean abstractFlag;
@Nullable
private Boolean lazyInit;
private int autowireMode;
private int dependencyCheck;
@Nullable
private String[] dependsOn;
private boolean autowireCandidate;
private boolean primary;
private final Map<String, AutowireCandidateQualifier> qualifiers;
@Nullable
private Supplier<?> instanceSupplier;
private boolean nonPublicAccessAllowed;
private boolean lenientConstructorResolution;
@Nullable
private String factoryBeanName;
@Nullable
private String factoryMethodName;
@Nullable
private ConstructorArgumentValues constructorArgumentValues;
@Nullable
private MutablePropertyValues propertyValues;
private MethodOverrides methodOverrides;
@Nullable
private String initMethodName;
@Nullable
private String destroyMethodName;
private boolean enforceInitMethod;
private boolean enforceDestroyMethod;
private boolean synthetic;
private int role;
@Nullable
private String description;
@Nullable
private Resource resource;
protected AbstractBeanDefinition() {
this((ConstructorArgumentValues)null, (MutablePropertyValues)null);
}
protected AbstractBeanDefinition(@Nullable ConstructorArgumentValues cargs, @Nullable MutablePropertyValues pvs) {
this.scope = "";
this.abstractFlag = false;
this.autowireMode = 0;
this.dependencyCheck = 0;
this.autowireCandidate = true;
this.primary = false;
this.qualifiers = new LinkedHashMap();
this.nonPublicAccessAllowed = true;
this.lenientConstructorResolution = true;
this.methodOverrides = new MethodOverrides();
this.enforceInitMethod = true;
this.enforceDestroyMethod = true;
this.synthetic = false;
this.role = 0;
this.constructorArgumentValues = cargs;
this.propertyValues = pvs;
}
...1.3bean实例化
bean定义信息加载以后就进入了第二个阶段，根据配置信息创建对应的bean。追入第二个标红的方法finishBeanFactoryInitialization(beanFactory)中。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
}
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver((strVal) -> {
return this.getEnvironment().resolvePlaceholders(strVal);
});
}
//拿到所有要初始化的LoadTimeWeaverAwareBean（一种特殊的bean，此处以它为切入点分析bean实例化流程）的名字
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
String[] var3 = weaverAwareNames;
int var4 = weaverAwareNames.length;
for(int var5 = 0; var5 < var4; ++var5) {
String weaverAwareName = var3[var5];
//调用getBean方法，BeanFactory().getBean()方法会在第一次获取bean的时候自动完成bean的实例化工作
this.getBean(weaverAwareName);
}
beanFactory.setTempClassLoader((ClassLoader)null);
//冻结bean定义信息
beanFactory.freezeConfiguration();
//实例化下的bean，过程于上边类似都是调用getbean（）方法
beanFactory.preInstantiateSingletons();
}
追入getbean（）
public Object getBean(String name) throws BeansException {
this.assertBeanFactoryActive();
return this.getBeanFactory().getBean(name);
}
可以清楚地看到调用了BeanFactory的getBean()方法
继续追入
public Object getBean(String name) throws BeansException {
return this.doGetBean(name, (Class)null, (Object[])null, false);
}
由此看到bean实例化的关键内容都在doGetBean（）方法中呈现
此方法代码较长，其中共有四处创建bean实例的地方（红色标出）重点关注此处即可
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
String beanName = this.transformedBeanName(name);
//尝试从缓存中获得bean实例，如果缓存中有，则无需创建，
这里要指出的是此处获得的只是bean的实例，不是要返回的bean对象，
因为bean实例可能是beanfactory类，对于beanfactory类，在其中创建的bean才是我们真正想要返回的bean
Object sharedInstance = this.getSingleton(beanName);
Object beanInstance;
if (sharedInstance != null && args == null) {
if (this.logger.isTraceEnabled()) {
if (this.isSingletonCurrentlyInCreation(beanName)) {
this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
} else {
this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//对bean实例的检测处理，如果bean实例是beanfactory类则调用getbean（）方法拿到真正要返回的bean
beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
} else {
if (this.isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
BeanFactory parentBeanFactory = this.getParentBeanFactory();
if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
String nameToLookup = this.originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
}
if (args != null) {
return parentBeanFactory.getBean(nameToLookup, args);
}
if (requiredType != null) {
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
return parentBeanFactory.getBean(nameToLookup);
}
if (!typeCheckOnly) {
this.markBeanAsCreated(beanName);
}
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate").tag("beanName", name);
try {
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
this.checkMergedBeanDefinition(mbd, beanName, args);
String[] dependsOn = mbd.getDependsOn();
String[] var12;
if (dependsOn != null) {
var12 = dependsOn;
int var13 = dependsOn.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dep = var12[var14];
if (this.isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
this.registerDependentBean(dep, beanName);
try {
this.getBean(dep);
} catch (NoSuchBeanDefinitionException var31) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var31);
}
}
}
if (mbd.isSingleton()) {
//获取单实例bean，真正创建bean的方法是回调函数中的createbean
sharedInstance = this.getSingleton(beanName, () -> {
try {
return this.createBean(beanName, mbd, args);
} catch (BeansException var5) {
this.destroySingleton(beanName);
throw var5;
}
});
//对新创建的bean的检测
beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
} else if (mbd.isPrototype()) {
var12 = null;
Object prototypeInstance;
try {
this.beforePrototypeCreation(beanName);
//多实例bean的创建，也是调用createbean（）方法
prototypeInstance = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
//对新创建的bean的检测
beanInstance = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
} else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
}
Scope 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, () -> {
this.beforePrototypeCreation(beanName);
Object var4;
try {
//创建其他作用范围上的bean实例
var4 = this.createBean(beanName, mbd, args);
} finally {
this.afterPrototypeCreation(beanName);
}
return var4;
});
//对新创建的bean的检测
beanInstance = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
} catch (IllegalStateException var30) {
throw new ScopeNotActiveException(beanName, scopeName, var30);
}
}
} catch (BeansException var32) {
beanCreation.tag("exception", var32.getClass().toString());
beanCreation.tag("message", String.valueOf(var32.getMessage()));
this.cleanupAfterBeanCreationFailure(beanName);
throw var32;
} finally {
beanCreation.end();
}
}
return this.adaptBeanInstance(name, beanInstance, requiredType);
}
我们看到，此方法中把bean实例的创建分为了四种，从缓存中获得，创建单实例bean实例，创建多实例bean实例，创建其他作用范围的bean实例。在每一个实例创建好后都调用了getObjectForBeanInstance方法检测。继续追入createbean方法。
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]);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
//准备重写方法，spring允许你在配置文件中指定bean中方法的重写方法，此处在为此做准备
mbdToUse.prepareMethodOverrides();
} catch (BeanDefinitionValidationException var9) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
}
Object beanInstance;
try {
//BeanPostProcessors一个机会来返回代理对象替代真正的实例，用于功能扩展增强
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 {
//真正创建bean实例
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);
}
}
进入doCreateBean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//创建bean实例
instanceWrapper = this.createBeanInstance(beanName, mbd, args);
}
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized(mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable var17) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
}
mbd.postProcessed = true;
}
}
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
if (earlySingletonExposure) {
if (this.logger.isTraceEnabled()) {
this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
this.addSingletonFactory(beanName, () -> {
return this.getEarlyBeanReference(beanName, mbd, bean);
});
}
Object exposedObject = bean;
try {
//填充创建好的bean实例的属性，ioc分析的第三大步，内容填充将在此展开
this.populateBean(beanName, mbd, instanceWrapper);
//初始化bean， Aop过程在其中进行（以后会详细说明不用纠结）
exposedObject = this.initializeBean(beanName, exposedObject, mbd);
} catch (Throwable var18) {
if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
throw (BeanCreationException)var18;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
}
if (earlySingletonExposure) {
Object earlySingletonReference = this.getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
String[] dependentBeans = this.getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
String[] var12 = dependentBeans;
int var13 = dependentBeans.length;
for(int var14 = 0; var14 < var13; ++var14) {
String dependentBean = var12[var14];
if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been wrapped. This means that said other beans do not use the final version of the bean. This is often the result of over-eager type matching - consider using 'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
return exposedObject;
} catch (BeanDefinitionValidationException var16) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
}
}
此方法中有两个值得我们关注的地方，一个是createBeanInstance创建bean实例，一个是populateBean填充bean属性。
先进入createBeanInstance
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
} else {
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return this.obtainFromSupplier(instanceSupplier, beanName);
} else if (mbd.getFactoryMethodName() != null) {
return this.instantiateUsingFactoryMethod(beanName, mbd, args);
} else {
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized(mbd.constructorArgumentLock) {
//bean有多组构造器，需要根据传入参数选择合适构造器
if (mbd.resolvedConstructorOrFactoryMethod != null) {
//判断构造器是否已经被解析
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
//如果构造器已经被解析，判断构造器是否需要自动参数填充，如果需要则调用autowireConstructor方法进行创建，如果不需要则调用instantiateBean进行默认创建
if (resolved) {
return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
} else {
//构造器未被解析则首先选择合适的构造器
Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
ctors = mbd.getPreferredConstructors();
//有适合的构造器则调用autowireConstructor进行创建，没有则使用默认创建
return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
} else {
//其他情况直接使用autowireConstructor创建
return this.autowireConstructor(beanName, mbd, ctors, args);
}
}
}
}
}
spring将创建实例分为了两种，一种是默认实例化，一种是带有参数的实例化，默认实例化对应instantiateBean方法，带有参数的实例化对应autowireConstructor方法。createBeanInstance方法中根据不同条件选用二者之一进行实例创建。
1.4bean属性填充
完成bean实例创建以后紧接着要做的就是对bean的各种属性进行填充，此步骤在函数populateBean中完成，追入函数可看到属性填充的两个关键方法autowireByName和autowireByType
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
if (bw == null) {
if (mbd.hasPropertyValues()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
} else {
if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
Iterator var4 = this.getBeanPostProcessorCache().instantiationAware.iterator();
while(var4.hasNext()) {
InstantiationAwareBeanPostProcessor bp = (InstantiationAwareBeanPostProcessor)var4.next();
if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
PropertyValues pvs = mbd.hasPropertyValues() ? mbd.getPropertyValues() : null;
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == 1 || resolvedAutowireMode == 2) {
MutablePropertyValues newPvs = new MutablePropertyValues((PropertyValues)pvs);
if (resolvedAutowireMode == 1) {
//根据名字自动填充，将解析出来要填充的内容保存到MutablePropertyValues（newPvs）中
this.autowireByName(beanName, mbd, bw, newPvs);
}
//根据类型自动填充，其他操作同上
if (resolvedAutowireMode == 2) {
this.autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = mbd.getDependencyCheck() != 0;
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
PropertyValues pvsToUse;
for(Iterator var9 = this.getBeanPostProcessorCache().instantiationAware.iterator(); var9.hasNext(); pvs = pvsToUse) {
InstantiationAwareBeanPostProcessor bp = (InstantiationAwareBeanPostProcessor)var9.next();
pvsToUse = bp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = bp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
this.checkDependencies(beanName, mbd, filteredPds, (PropertyValues)pvs);
}
if (pvs != null) {
//解析出来的属性填充到bean中
this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
}
}
}
继续进入autowireByName方法
protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
//找出需要注入的属性名字
String[] propertyNames = this.unsatisfiedNonSimpleProperties(mbd, bw);
String[] var6 = propertyNames;
int var7 = propertyNames.length;
for(int var8 = 0; var8 < var7; ++var8) {
String propertyName = var6[var8];
if (this.containsBean(propertyName)) {
//创建要注入的属性
Object bean = this.getBean(propertyName);
//保存属性到MutablePropertyValues中
pvs.add(propertyName, bean);
this.registerDependentBean(propertyName, beanName);
if (this.logger.isTraceEnabled()) {
this.logger.trace("Added autowiring by name from bean name '" + beanName + "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
}
} else if (this.logger.isTraceEnabled()) {
this.logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName + "' by name: no matching bean found");
}
}
}
autowireByType方法过程相似，此处不再赘述。至此，springIOC有关功能的核心流程都已分析结束，下面将进入Aop有关流程的源码分析。
经过千山万水我们终于分析完了bean创建的所有流程，但是至此spring容器的所有工作流程都结束了吗？很遗憾，并没有。因为spring容器还为我们提供了另一个重要的功能——Aop（Aspect Oriented Programming）面向切面编程，它允许我们动态的将代码切入到目标方法中去。篇幅原因有关Aop的基础知识我也不再赘述，我们重点关注spring是如何实现Aop功能的。 相信你也有所耳闻，spring实现Aop的方法就是创建动态代理，简而言之就是为被代理对象创建子类，在子类中重写被增强的方法，将其改为先执行增强逻辑，再执行原有逻辑。而spring实现动态代理的两种方式是CGLIB动态代理和JDK动态代理。
上述Aop过程还有一个小问题，就是什么时候、怎么创建动态代理？由于Aop是基于原有逻辑进行增强，所以动态代理的创建时机一定是原始bean初始化完成以后，至于如何创建，不知你是否记得bean创建过程中有许许多多的后置处理器，spring选用了初始化完成的后置处理器，在其中完成了对原始bean的Aop代理对象的创建
让我们在回顾一下创建bean的doCreateBean方法
追入 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 {
this.invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//应用初始化的前置处理器
wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
}
try {
//调用bean的初始化方法（可以在配置文件中配置）
this.invokeInitMethods(beanName, wrappedBean, mbd);
} catch (Throwable var6) {
throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
}
//初始化完成的后置处理器，spring会在容器中加入一个支持Aop功能的后置处理器，所有Aop有关功能都会在后置处理器中完成
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
我们找到spring创建的这个特殊后置处理器AnnotationAwareAspectJAutoProxyCreator
在类层次中我们可以看到它实现了BeanPostProcessor接口，找到父类AbstractAutoProxyCreator中实现了方法postProcessAfterInitialization，至此Aop源码分析正式开始。
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
//如果bean适合被代理，那么返回代理的bean
return this.wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
继续追入wrapIfNecessary方法
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
//如果已经进行过处理，则直接返回
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
//没有增强器，无需增强直接返回
} else if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
} else if (!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) {
//拿到目标bean的所有增强器
Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
//创建代理对象
Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
} else {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
} else {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
}
wrapIfNecessary先通过getAdvicesAndAdvisorsForBean方法找到了所有的增强器，再通过creatProxy方法完成了代理对象的创建，将增强代码织入到了目标方法中，让我们先进入getAdvicesAndAdvisorsForBean小看一眼。
protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
//找到所有合适的增强器
List<Advisor> advisors = this.findEligibleAdvisors(beanClass, beanName);
return advisors.isEmpty() ? DO_NOT_PROXY : advisors.toArray();
}
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) { //找到所有候选增强器 List<Advisor> candidateAdvisors = this.findCandidateAdvisors(); //根据规则挑选能够应用在目标方法上的增强器 List<Advisor> eligibleAdvisors = this.findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName); this.extendAdvisors(eligibleAdvisors); if (!eligibleAdvisors.isEmpty()) { eligibleAdvisors = this.sortAdvisors(eligibleAdvisors); } return eligibleAdvisors; }
增强器的具体查找封装逻辑都在这两个方法中，感兴趣的朋友可自行阅读。
接着进入creatProxy方法查看创建代理逻辑。
protected Object createProxy(Class<?> beanClass, @Nullable String beanName, @Nullable Object[] specificInterceptors, TargetSource targetSource) {
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory)this.beanFactory, beanName, beanClass);
}
//创建代理工厂，代理类将在代理工厂中创建
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);
if (proxyFactory.isProxyTargetClass()) {
if (Proxy.isProxyClass(beanClass) || ClassUtils.isLambdaClass(beanClass)) {
Class[] var6 = beanClass.getInterfaces();
int var7 = var6.length;
for(int var8 = 0; var8 < var7; ++var8) {
Class<?> ifc = var6[var8];
proxyFactory.addInterface(ifc);
}
}
} else if (this.shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
} else {
this.evaluateProxyInterfaces(beanClass, proxyFactory);
}
Advisor[] advisors = this.buildAdvisors(beanName, specificInterceptors);
//在工厂中加入增强器
proxyFactory.addAdvisors(advisors);
//设置代理源（目标方法）
proxyFactory.setTargetSource(targetSource);
//定制代理
this.customizeProxyFactory(proxyFactory);
//是否冻结配置，也就是之后是否还允许修改配置信息
proxyFactory.setFrozen(this.freezeProxy);
if (this.advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
ClassLoader classLoader = this.getProxyClassLoader();
if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
classLoader = ((SmartClassLoader)classLoader).getOriginalClassLoader();
}
//让代理bean工厂开始创建代理bean
return proxyFactory.getProxy(classLoader);
}
此方法是对ProxyFactory的一些属性设置，真正的代理对象创建委托给了proxyFactory的getProxy方法来做，继续进入proxyFactory.getProxy方法
public Object getProxy(@Nullable ClassLoader classLoader) {
return this.createAopProxy().getProxy(classLoader);
}
无需多言继续追入
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
this.activate();
}
return this.getAopProxyFactory().createAopProxy(this);
}
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
//如果符合Jdk代理规则优先使用Jdk代理
if (NativeDetector.inNativeImage() || !config.isOptimize() && //不是针对目标对象类的代理!config.isProxyTargetClass() && //存在可以代理的接口!this.hasNoUserSuppliedProxyInterfaces(config)) {
//返回Jdk代理结果
return new JdkDynamicAopProxy(config);
} else {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: Either an interface or a target is required for proxy creation.");
} else {
//返回CGLib代理结果
return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) && !ClassUtils.isLambdaClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
}
}
}
我们知道Jdk代理只能针对实现了接口的类，如果被代理类没有实现接口那么只能选用Cglib进行动态代理。所以此方法中根据不同条件选用了不同种代理的创建策略，最终完成了AOP代理类的创建，至此spring Aop的主要流程均已完成。
终于，spring容器的两大核心功能IOC和AOP都已分析完毕，至此关于spring源码的分析就可告一段落了。在流程分析的过程中相信你也有所感悟，分析spring源码就像在剥洋葱，从内到外把一个复杂的功能一层一层的拆解，繁而不杂，大而不乱。如此巧妙的设计让人叹为观止，不得不佩服开发人员技术水之高。以后有机会我会分享更多源码的解读（springmvc、springboot、mybatis..），希望能和大家一同学习，一同进步!
创作过程难免有所纰漏，请大家指正！
348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
