Spring IOC源码之bean的注册过程讲解

Spring IOC源码之bean的注册过程讲解

目录BeanDefition加载注册过程进入obtainFreshBeanFactory方法​进入AbstractRefreshableApplicationContext类中的refreshBeanFactory方法进入AbstractXmlApplicationContext类的loadBeanDefinitions方法进入doLoadBeanDefinitions方法Spring IoC——Bean的创建和初始化Spring介绍IoC介绍IoC是什么IoC能做什么源码解析准备工作开始解析创建Bean初始化Bean总结

BeanDefition加载注册过程

进入obtainFreshBeanFactory方法

这里面refreshBeanFactory方法会去创建beanFactory并加载bean

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

refreshBeanFactory();

ConfigurableListableBeanFactory beanFactory = getBeanFactory();

if (logger.isDebugEnabled()) {

logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);

}

return beanFactory;

}

​进入AbstractRefreshableApplicationContext类中的refreshBeanFactory方法

在这里首先会将已经创建的bean工程销毁，然后创建新的bean工厂，设置bean工厂的一些属性，这里我们看到bean工厂是可以被序列化的，在customizeBeanFactory里面自定义bean工厂环境，通过allowBeanDefinitionOverriding和allowCircularReferences这两个属性用户可以自己来决定是否需要bean的覆盖，是否需要循环依赖，目前还暂时还用不到这两个属性

下面往容器中注册这些bean的时候会用到，loadBeanDefinitions这个方法才会去真正加载bean

protected final void refreshBeanFactory() throws BeansException {

//如果之前已经创建了bean工厂,那么则销毁

if (hasBeanFactory()) {

destroyBeans();

closeBeanFactory();

}

try {

//创建bean工厂

DefaultListableBeanFactory beanFactory = createBeanFactory();

//设置序列化id

beanFactory.setSerializationId(getId());

//相同名称的bean是否允许覆盖，是否允许循环依赖

customizeBeanFactory(beanFactory);

//这里到了最关键的部分，将BeanDefinition加载到bean工厂

loadBeanDefinitions(beanFactory);

synchronized (this.beanFactoryMonitor) {

this.beanFactory = beanFactory;

}

}

catch (IOException ex) {

throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);

}

}

进入AbstractXmlApplicationContext类的loadBeanDefinitions方法

在这里首先给bean工厂创建一个bean资源加载器并初始化相关环境，进入loadBeanDefinitions继续加载bean，这里也是最关键的地方

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {

// Create a new XmlBeanDefinitionReader for the given BeanFactory.

//给bean工厂创建一个资源加载器

XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

// Configure the bean definition reader with this context's

// resource loading environment.

//设置资源加载环境

beanDefinitionReader.setEnvironment(this.getEnvironment());

beanDefinitionReader.setResourceLoader(this);

beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

// Allow a subclass to provide custom initialization of the reader,

// then proceed with actually loading the bean definitions.

//初始化bean资源加载器

initBeanDefinitionReader(beanDefinitionReader);

//开始加载bean定义

loadBeanDefinitions(beanDefinitionReader);

}

它会将所有的xml进行循环加载,最终会进入XmlBeanDefinitionReader这个类里的loadBeanDefinitions方法。

在这里会获得一个inputStream输入流进入doLoadBeanDefinitions方法开始读取bean，并将xml转换为Document对象

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {

Assert.notNull(encodedResource, "EncodedResource must not be null");

if (logger.isInfoEnabled()) {

logger.info("Loading XML bean definitions from " + encodedResource.getResource());

}

Set currentResources = this.resourcesCurrentlyBeingLoaded.get();

if (currentResources == null) {

currentResources = new HashSet<>(4);

this.resourcesCurrentlyBeingLoaded.set(currentResources);

}

if (!currentResources.add(encodedResource)) {

throw new BeanDefinitionStoreException(

"Detected cyclic loading of " + encodedResource + " - check your import definitions!");

}

try {

//从资源加载描述中获得一个输入流

InputStream inputStream = encodedResource.getResource().getInputStream();

try {

InputSource inputSource = new InputSource(inputStream);

if (encodedResource.getEncoding() != null) {

inputSource.setEncoding(encodedResource.getEncoding());

}

//进入关键部分，开始加载bean定义

return doLoadBeanDefinitions(inputSource, encodedResource.getResource());

}

finally {

inputStream.close();

}

}

catch (IOException ex) {

throw new BeanDefinitionStoreException(

"IOException parsing XML document from " + encodedResource.getResource(), ex);

}

finally {

currentResources.remove(encodedResource);

if (currentResources.isEmpty()) {

this.resourcesCurrentlyBeingLoaded.remove();

}

}

}

进入doLoadBeanDefinitions方法

这里主要是读取xml并转换为Document对象，关于xml的解析这个就不多介绍，直接进入到registerBeanDefinitions方法在这里开始往容器中注册bean

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)

throws BeanDefinitionStoreException {

try {

//加载解析xml文件并返回一个document对象

Document doc = doLoadDocument(inputSource, resource);

//开始注册bean定义

return registerBeanDefinitions(doc, resource);

}

catch (BeanDefinitionStoreException ex) {

throw ex;

}

catch (SAXParseException ex) {

throw new XmlBeanDefinitionStoreException(resource.getDescription(),

"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);

}

catch (SAXException ex) {

throw new XmlBeanDefinitionStoreException(resource.getDescription(),

"XML document from " + resource + " is invalid", ex);

}

catch (ParserConfigurationException ex) {

throw new BeanDefinitionStoreException(resource.getDescription(),

"Parser configuration exception parsing XML from " + resource, ex);

}

catch (IOException ex) {

throw new BeanDefinitionStoreException(resource.getDescription(),

"IOException parsing XML document from " + resource, ex);

}

catch (Throwable ex) {

throw new BeanDefinitionStoreException(resource.getDescription(),

"Unexpected exception parsing XML document from " + resource, ex);

}

}

最终会进入DefaultBeanDefinitionDocumentReader类里的parseBeanDefinitions方法，在parseDefaultElement方法会解析在xml中常见的import,alias,bean等标签

Spring IoC——Bean的创建和初始化

Spring介绍

Spring(http://spring.io/)是一个轻量级的java 开发框架，同时也是轻量级的IoC和AOP的容器框架，主要是针对JavaBean的生命周期进行管理的轻量级容器，可以单独使用，也可以和Struts框架，MyBatis框架等组合使用。

IoC介绍

IoC是什么

Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：

谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对 象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

IoC能做什么

IoC 不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是 松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活。

其实IoC对编程带来的最大改变不是从代码上，而是从思想上，发生了“主从换位”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC容器来创建并注入它所需要的资源了。

IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

那么，IoC容器到底是如何从初始化完成的BeanFactory中对Bean进行创建并初始化的呢？接下来我们就一探究竟。

源码解析

准备工作

首先写一个Spring的配置文件spring.xml，为了方便测试，这里面就只有一个名为test的bean。

xmlns:xsi="http://w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://springframework.org/schema/beans http://springframework.org/schema/beans/spring-beans.xsd">

xmlns:xsi="http://w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://springframework.org/schema/beans http://springframework.org/schema/beans/spring-beans.xsd">

编写程序入口代码，可以直接打断点进行调试。

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

Test bean = context.getBean("test", Test.class);

开始解析

开始源码解析，紧接着上一节，首先进入AbstractApplicationContext.java的refresh方法，这一节我们重点来看里面的invokeBeanFactoryPostProcessors方法。

@Override

public void refresh() throws BeansException, IllegalStateException {

synchronized (this.startupShutdownMonitor) {

// 在这种情况下刷新

prepareRefresh();

// 告诉子类刷新内部bean工厂

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// 在这种情况下,bean工厂准备使用的.

prepareBeanFactory(beanFactory);

try {

// 允许在上下文bean的后处理工厂子类。

postProcessBeanFactory(beanFactory);

//在上下文中调用factory工厂的时候注册bean的 实例对象

invokeBeanFactoryPostProcessors(beanFactory);

// 注册bean的过程当中拦截所以bean的创建

registerBeanPostProcessors(beanFactory);

// 初始化上下文消息资源

initMessageSource();

//初始化事物传播属性

initApplicationEventMulticaster();

// 在特定上下文初始化其他特殊bean子类。

onRefresh();

// 检查侦听器bean并注册。

registerListeners();

// 实例化所有剩余(non-lazy-init)单例.

finishBeanFactoryInitialization(beanFactory);

// 最后一步:发布对应的事件。

finishRefresh();

}

catch (BeansException ex) {

if (logger.isWarnEnabled()) {

logger.warn("Exception encountered during context initialization - " +

"cancelling refresh attempt: " + ex);

}

// 销毁已经创建的单例对象避免浪费资源

destroyBeans();

// 重置“活跃”的旗帜。

cancelRefresh(ex);

// 异常传播到调用者。

throw ex;

}

finally {

// 在spring 核心包里重置了内存，因为我们肯不需要元数据单例bean对象了

resetCommonCaches();

}

}

}

进入invokeBeanFactoryPostProcessors方法

/**

* Instantiate and invoke all registered BeanFactoryPostProcessor beans,

* respecting explicit order if given.

*

Must be called before singleton instantiation.

*/

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime

// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)

if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {

beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));

beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));

}

}

打开PostProcessorRegistrationDelegate类中的invokeBeanFactoryPostProcessors方法，可以看到，这个方法里有很多内容，这里我们只分析最关键的部分。从本质上来说，该方法就是去执行BeanFactoryPostProcessor这个接口中的方法去的，上面代码注释也清楚的写到如果想先执行BeanFactoryPostProcessor这个接口的方法，必须先去实例化实现这个接口的Bean,也就是getBean这个方法。

public static void invokeBeanFactoryPostProcessors(

ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {

// Invoke BeanDefinitionRegistryPostProcessors first, if any.

Set processedBeans = new HashSet<>();

if (beanFactory instanceof BeanDefinitionRegistry) {

BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

List regularPostProcessors = new LinkedList<>();

List registryPostProcessors =

new LinkedList<>();

for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {

if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {

BeanDefinitionRegistryPostProcessor registryPostProcessor =

(BeanDefinitionRegistryPostProcessor) postProcessor;

registryPostProcessor.postProcessBeanDefinitionRegistry(registry);

registryPostProcessors.add(registryPostProcessor);

}

else {

regularPostProcessors.add(postProcessor);

}

}

// 不初始化factoryBeans：我们需要把所以没有初始化的bean让bean工厂处理他们，单例BeanDefinitionRegistryPostProcessors之间实现PriorityOrdered接口、序列化接口

String[] postProcessorNames =

beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

//首先，调用 BeanDefinitionRegistryPostProcessors 并且实现 PriorityOrdered接口

List priorityOrderedPostProcessors = new ArrayList<>();

for (String ppName : postProcessorNames) {

if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));

processedBeans.add(ppName);

}

}

sortPostProcessors(beanFactory, priorityOrderedPostProcessors);

registryPostProcessors.addAll(priorityOrderedPostProcessors);

invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);

//然后, 调用 BeanDefinitionRegistryPostProcessors 并且实现序列化接口

postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

List orderedPostProcessors = new ArrayList<>();

for (String ppName : postProcessorNames) {

if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {

orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));

processedBeans.add(ppName);

}

}

sortPostProcessors(beanFactory, orderedPostProcessors);

registryPostProcessors.addAll(orderedPostProcessors);

invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);

// 最后，调用其他BeanDefinitionRegistryPostProcessors,直到没有进一步的出现。

boolean reiterate = true;

while (reiterate) {

reiterate = false;

postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

for (String ppName : postProcessorNames) {

if (!processedBeans.contains(ppName)) {

BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);

registryPostProcessors.add(pp);

processedBeans.add(ppName);

pp.postProcessBeanDefinitionRegistry(registry);

reiterate = true;

}

}

}

// 现在，调用的postProcessBeanFactory回调处理器处理

invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);

invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

}

else {

// 调用该工厂的时候 注册文本的实例对象

invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);

}

//不在这里初始化FactoryBeans,我们需要把所有

未初始化的bean让工厂后面处理他们

String[] postProcessorNames =

beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

// 单独beanfactorypostprocessor之间实现PriorityOrdered 接口,下令,休息。

List priorityOrderedPostProcessors = new ArrayList<>();

List orderedPostProcessorNames = new ArrayList<>();

List nonOrderedPostProcessorNames = new ArrayList<>();

http:// for (String ppName : postProcessorNames) {

if (processedBeans.contains(ppName)) {

// 跳过已经处理完的第一阶段

}

else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));

}

else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {

orderedPostProcessorNames.add(ppName);

}

else {

nonOrderedPostProcessorNames.add(ppName);

}

}

// 首先, 调用这个 BeanFactoryPostProcessors 并且实现PriorityOrdered 接口

sortPostProcessors(beanFactory, priorityOrderedPostProcessors);

invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

// 然后,调用 BeanFactoryPostProcessors 并且实现 序列化 接口

List orderedPostProcessors = new ArrayList<>();

for (String postProcessorName : orderedPostProcessorNames) {

orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));

}

sortPostProcessors(beanFactory, orderedPostProcessors);

invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

// 最后, 调用其他所有的 BeanFactoryPostProcessors.

List nonOrderedPostProcessors = new ArrayList<>();

for (String postProcessorName : nonOrderedPostProcessorNames) {

nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));

}

invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

// 清除缓存合并bean定义自后处理器可能会有修改原来的元数据,例如:替换占位符值. ..

beanFactory.clearMetadataCache();

}

接下来进入AbstractBeanFactory.java类中的doGetBean方法，这个方法的具体实现可以分为三个部分：

第一部分，首先先去singleton缓存中去找实例。由于我们例子中没有把我们的bean手动放入singletonObjects这个Map里面去，所以这里肯定没找到。

第二部分，然后是去获取该BeanFactory父Factory，希望从这些Factory中获取，如果该Beanfactory有父类，则希望用父类去实例化该bean，类似于JVM类加载的双亲委派机制。由于我们例子中的的Beanfactory为null，所以暂不讨论这种情况。

第三部分，这一部分是我们关注的重点，这里我们将这一大部分再分为三个小的部分来进行分析：

先将目前的bean标记为的正在创建

再获取根据beanName得到对应bean在beanfactory中的beanDefinitionMap的BeanDefinition（上一节初始化beanFactory时存入的），然后去获取这个bean依赖的bean。如果依赖的bean还没有创建，则先创建依赖的bean，进行递归调用（这就是依赖注入Dependence Injection）。如果找不到依赖，则忽略。

最后如果是单例（Spring默认是单例），则调用createBean()这个方法进行Bean的创建。

/**

* Return an instance, which may be shared or independent, of the specified bean.

* @param name the name of the bean to retrieve

* @param requiredType the required type of the bean to retrieve

* @param args arguments to use when creating a bean instance using explicit arguments

* (only applied when creating a new instance as opposed to retrieving an existing one)

* @param typeCheckOnly whether the instance is obtained for a type check,

* not for actual use

* @return an instance of the bean

* @throws BeansException if the bean could not be created

*/

@SuppressWarnings("unchecked")

protected T doGetBean(

final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)

throws BeansException {

final String beanName = transformedBeanName(name);

Object bean;

// 急切地检查手动注册单例单缓存

Object sharedInstance = getSingleton(beanName);

if (sharedInstance != null && args == null) {

if (logger.isDebugEnabled()) {

if (isSingletonCurrentlyInCreation(beanName)) {

logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +

"' that is not fully initialized yet - a consequence of a circular reference");

}

else {

logger.debug("Returning cached instance of singleton bean '" + beanName + "'");

}

}

bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

}

else {

// 如果我们创建bean 实例对象失败了，说明我们在循环引用该实例对象

if (isPrototypeCurrentlyInCreation(beanName)) {

throw new BeanCurrentlyInCreationException(beanName);

}

// 在factory这个工厂里检查bean 对象是否存在

BeanFactory parentBeanFactory = getParentBeanFactory();

if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {

// 当没有发现时，应该检查父类对象

String nameToLookup = originalBeanName(name);

if (args != null) {

// 给父类对象提供明确 的参数

return (T) parentBeanFactory.getBean(nameToLookup, args);

}

else {

//没有参数，代表标准的获取.getbean（）方法

return parentBeanFactory.getBean(nameToLookup, requiredType);

}

}

if (!typeCheckOnly) {

markBeanAsCreated(beanName);

}

try {

final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

checkMergedBeanDefinition(mbd, beanName, args);

// 确保初始化的bean 是当前的这个bean对象

String[] dependsOn = mbd.getDependsOn();

if (dependsOn != null) {

for (String dependsOnBean : dependsOn) {

if (isDependent(beanName, dependsOnBean)) {

throw new BeanCreationException(mbd.getResourceDescription(), beanName,

"Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");

}

registerDependentBean(dependsOnBean, beanName);

getBean(dependsOnBean);

}

}

// 创建一个 bean 的实例对象

if (mbd.isSingleton()) {

sharedInstance = getSingleton(beanName, new ObjectFactory

@Override

public Object getObject() throws BeansException {

try {

return createBean(beanName, mbd, args);

}

catch (BeansException ex) {

//从单例明确地删除实例的缓存:这可能是热切的创建过程,允许循环引用的决议。还删除任何bean,收到一个临时bean的引用。

destroySingleton(beanName);

throw ex;

}

}

});

bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

}

else if (mbd.isPrototype()) {

//这是一个原型,创建一个新的实例

Object prototypeInstance = null;

try {

beforePrototypeCreation(beanName);

prototypeInstance = createBean(beanName, mbd, args);

}

finally {

afterPrototypeCreation(beanName);

}

bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);

}

else {

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, new ObjectFactory

@Override

public Object getObject() throws BeansException {

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;

}

}

进入AbstractAutowireCapableBeanFactory.java类的createBean方法，这里面可以分为四个部分：

第一部分：确保该bean的class是真实存在的，也就是该bean是可以classload可以找到加载的

第二部分：准备方法的重写

第三部分：可以看到，这边出现了一个return，也就是说这边可以返回bean了。但看注释：Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. 这样就很清晰了，BeanPostProcessor这个接口是可以临时修改bean的，优先级高于正常实例化bean的，如果beanPostProcessor能返回，则直接返回了。

第四部分：调用doCreateBean方法开始对bean进行创建

/**

* Central method of this class: creates a bean instance,

* populates the bean instance, applies post-processors, etc.

* @see #doCreateBean

*/

@Override

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {

if (logger.isDebugEnabled()) {

logger.debug("Creating instance of bean '" + beanName + "'");

}

RootBeanDefinition mbdToUse = mbd;

//确保bean类实际上是解决在这一点上,和克隆bean定义的动态解析类不能存储在共享合并bean定义。

Class> resolvedClass = resolveBeanClass(mbd, beanName);

if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {

mbdToUse = new RootBeanDefinition(mbd);

mbdToUse.setBeanClass(resolvedClass);

}

// 准备方法覆盖

try {

mbdToUse.prepareMethodOverrides();

}

catch (BeanDefinitionValidationException ex) {

throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),

beanName, "Validation of method overrides failed", ex);

}

try {

// .让BeanPostProcessors返回一个代理,而不是目标bean实例

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);

}

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

if (logger.isDebugEnabled()) {

logger.debug("Finished creating instance of bean '" + beanName + "'");

}

return beanInstance;

}

打开doCreateBean方法，在这个方法里会做两件事：一是通过createBeanInstance这个方法创建bean，二是通过initializeBean方法初始化bean。先看看createBeanInstance这个方法里有什么玄

/**

* Actually create the specified bean. Pre-creation processing has already happened

* at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.

*

Differentiates between default bean instantiation, use of a

* factory method, and autowiring a constructor.

* @param beanName the name of the bean

* @param mbd the merged bean definition for the bean

* @param args explicit arguments to use for constructor or factory method invocation

* @return a new instance of the bean

* @throws BeanCreationException if the bean could not be created

* @see #instantiateBean

* @see #instantiateUsingFactoryMethod

* @see #autowireConstructor

*/

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {

// Instantiate the bean.

BeanWrapper instanceWrapper = null;

if (mbd.isSingleton()) {

instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);

}

if (instanceWrapper == null) {

instanceWrapper = createBeanInstance(beanName, mbd, args);

}

final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);

Class> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);

// Allow post-processors to modify the merged bean definition.

synchronized (mbd.postProcessingLock) {

if (!mbd.postProcessed) {

applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

mbd.postProcessed = true;

}

}

/// 急切地缓存单件能够解决循环引用

// 即使像BeanFactoryAware由生命周期接口。.

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&

isSingletonCurrentlyInCreation(beanName));

if (earlySingletonExposure) {

if (logger.isDebugEnabled()) {

logger.debug("Eagerly caching bean '" + beanName +

"' to allow for resolving potential circular references");

}

addSingletonFactory(beanName, new ObjectFactory

@Override

public Object getObject() throws BeansException {

return getEarlyBeanReference(beanName, mbd, bean);

}

});

}

// 初始化 bean 的实例对象

Object exposedObject = bean;

try {

populateBean(beanName, mbd, instanceWrapper);

if (exposedObject != null) {

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);

}

}

if (earlySingletonExposure) {

Object earlySingletonReference = getSingleton(beanName, false);

if (earlySingletonReference != null) {

if (exposedObject == bean) {

exposedObject = earlySingletonReference;

}

else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {

String[] dependentBeans = getDependentBeans(beanName);

Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);

for (String dependentBean : dependentBeans) {

if (!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 " +

"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");

}

}

}

}

// 注册一次性使用的 bean

try {

registerDisposableBeanIfNecessary(beanName, bean, mbd);

}

catch (BeanDefinitionValidationException ex) {

throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);

}

return exposedObject;

}

创建Bean

进入createBeanInstance方法，这块代码主要是再次对bean做安全检查并确定该bean有默认的构造函数。直接看这个方法最后一行，调用instantiateBean方法并返回方法的结果。

/**

* Create a new instance for the specified bean, using an appropriate instantiation strategy:

* factory method, constructor autowiring, or simple instantiation.

* @param beanName the name of the bean

* @param mbd the bean definition for the bean

* @param args explicit arguments to use for constructor or factory method invocation

* @return BeanWrapper for the new instance

* @see #instantiateUsingFactoryMethod

* @see #autowireConstructor

* @see #instantiateBean

*/

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {

// 这一步是确保bean这个类在这个步骤完成解决

Class> beanClass = resolveBeanClass(mbd, beanName);

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());

}

if (mbd.getFactoryMethodName() != null) {

return instantiateUsingFactoryMethod(beanName, mbd, args);

}

// 重新创建相同bean的时候

boolean resolved = false;

boolean autowireNecessary = false;

if (args == null) {

synchronized (mbd.constructorArgumentLock) {

if (mbd.resolvedConstructorOrFactoryMethod != null) {

resolved = true;

autowireNecessary = mbd.constructorArgumentsResolved;

}

}

}

if (resolved) {

if (autowireNecessary) {

return autowireConstructor(beanName, mbd, null, null);

}

else {

return instantiateBean(beanName, mbd);

}

}

// 这个时候需要确定该一下 这个 bean 的构造函数.

Constructor>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);

if (ctors != null ||

mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||

mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {

return autowireConstructor(beanName, mbd, ctors, args);

}

// 不做任何特殊处理:简单地使用不带参数的构造函数。

return instantiateBean(beanName, mbd);

}

接着进入instantiateBean方法查看

/**

* Instantiate the given bean using its default constructor.

* @param beanName the name of the bean

* @param mbd the bean definition for the bean

* @return BeanWrapper for the new instance

*/

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {

try {

Object beanInstance;

final BeanFactory parent = this;

if (System.getSecurityManager() != null) {

beanInstance = AccessController.doPrivileged(new PrivilegedAction

@Override

public Object run() {

return getInstantiationStrategy().instantiate(mbd, beanName, parent);

}

}, getAccessControlContext());

}

else {

beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);

}

BeanWrapper bw = new BeanWrapperImpl(beanInstance);

initBeanWrapper(bw);

return bw;

}

catch (Throwable ex) {

throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);

}

}

再进入SimpleInstantiationStrategy.java的instantiate方法，我们可以看到，在这个方法里，Spring通过反射的方法根据BeanDefinition创建出Bean的对象并返回。

@Override

public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {

// Don't override the class with CGLIB if no overrides.

if (bd.getMethodOverrides().isEmpty()) {

Constructor> constructorToUse;

synchronized (bd.constructorArgumentLock) {

constructorToUse = (Constructor>) bd.resolvedConstructorOrFactoryMethod;

if (constructorToUse == null) {

final Class> clazz = bd.getBeanClass();

if (clazz.isInterface()) {

throw new BeanInstantiationException(clazz, "Specified class is an interface");

}

try {

if (System.getSecurityManager() != null) {

constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction>() {

@Override

public Constructor> run() throws Exception {

return clazz.getDeclaredConstructor((Class[]) null);

}

});

}

else {

constructorToUse = clazz.getDeclaredConstructor((Class[]) null);

}

bd.resolvedConstructorOrFactoryMethod = constructorToUse;

}

catch (Throwable ex) {

throw new BeanInstantiationException(clazz, "No default constructor found", ex);

}

}

}

return BeanUtils.instantiateClass(constructorToUse);

}

else {

// Must generate CGLIB subclass.

return instantiateWithMethodInjection(bd, beanName, owner);

}

}

以上是Bean的创建，接下来我们看IoC容器是如何对Bean进行初始化的。

初始化Bean

让我们回到AbstractAutowireCapableBeanFactory.java类中的doCreateBean方法中，重点关注里面的initializeBean方法。现在bean已经被创建了，开始初始化该bean。

/**

* Initialize the given bean instance, applying factory callbacks

* as well as init methods and bean post processors.

*

Called from {@link #createBean} for traditionally defined beans,

* and from {@link #initializeBean} for existing bean instances.

* @param beanName the bean name in the factory (for debugging purposes)

* @param bean the new bean instance we may need to initialize

* @param mbd the bean definition that the bean was created with

* (can also be {@code null}, if given an existing bean instance)

* @return the initialized bean instance (potentially wrapped)

* @see BeanNameAware

* @see BeanClassLoaderAware

* @see BeanFactoryAware

* @see #applyBeanPostProcessorsBeforeInitialization

* @see #invokeInitMethods

* @see #applyBeanPostProcessorsAfterInitialization

*/

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {

if (System.getSecurityManager() != null) {

AccessController.doPrivileged(new PrivilegedAction

@Override

public Object run() {

invokeAwareMethods(beanName, bean);

return null;

}

}, getAccessControlContext());

}

else {

invokeAwareMethods(beanName, bean);

}

Object wrappedBean = bean;

if (mbd == null || !mbd.isSynthetic()) {

wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

}

try {

invokeInitMethods(beanName, wrappedBean, mbd);

}

catch (Throwable ex) {

throw new BeanCreationException(

(mbd != null ? mbd.getResourceDescription() : null),

beanName, "Invocation of init method failed", ex);

}

if (mbd == null || !mbd.isSynthetic()) {

wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

}

return wrappedBean;

}

在这个方法中，先调用invokeAwareMethods方法用于加载相关资源（比如BeanName、BeanClassLoader、BeanFactory等资源）。

private void invokeAwareMethods(final String beanName, final Object bean) {

if (bean instanceof Aware) {

if (bean instanceof BeanNameAware) {

((BeanNameAware) bean).setBeanName(beanName);

}

if (bean instanceof BeanClassLoaderAware) {

((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());

}

if (bean instanceof BeanFactoryAware) {

((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);

}

}

}

再调用applyBeanPostProcessorsBeforeInitialization方法用于构造方法执行之前再次修改Bean（BeanPostProcessor接口）。

@Override

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)

throws BeansException {

Object result = existingBean;

for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {

result = beanProcessor.postProcessBeforeInitialization(result, beanName);

if (result == null) {

return result;

}

}

return result;

}

然后通过invokeInitMethods调用自定义的初始化方法

/**

* Give a bean a chance to react now all its properties are set,

* and a chance to know about its owning bean factory (this object).

* This means checking whether the bean implements InitializingBean or defines

* a custom init method, and invoking the necessary callback(s) if it does.

* @param beanName the bean name in the factory (for debugging purposes)

* @param bean the new bean instance we may need to initialize

* @param mbd the merged bean definition that the bean was created with

* (can also be {@code null}, if given an existing bean instance)

* @throws Throwable if thrown by init methods or by the invocation process

* @see #invokeCustomInitMethod

*/

protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)

throws Throwable {

boolean isInitializingBean = (bean instanceof InitializingBean);

if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {

if (logger.isDebugEnabled()) {

logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");

}

if (System.getSecurityManager() != null) {

try {

AccessController.doPrivileged(new PrivilegedExceptionAction

@Override

public Object run() throws Exception {

((InitializingBean) bean).afterPropertiesSet();

return null;

}

}, getAccessControlContext());

}

catch (PrivilegedActionException pae) {

throw pae.getException();

}

}

else {

((InitializingBean) bean).afterPropertiesSet();

}

}

if (mbd != null) {

String initMethodName = mbd.getInitMethodName();

if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&

!mbd.isExternallyManagedInitMethod(initMethodName)) {

invokeCustomInitMethod(beanName, bean, mbd);

}

}

}

再调用applyBeanPostProcessorsAfterInitialization方法用于构造方法执行之前再次修改Bean（BeanPostProcessor接口）。

@Override

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)

throws BeansException {

Object result = existingBean;

for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {

result = beanProcessor.postProcessAfterInitialization(result, beanName);

if (result == null) {

return result;

}

}

return result;

}

以上就完成了创建并初始化Bean的整个过程。

总结

通过这次源码分析，我们应该知道bean是怎么被IoC容器所创建的了，也知道IoC容器是如何去初始化spring.xml中的的bean了。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。