ApplicationContext的创建过程

在之前，我已经写过一篇关于BeanFactory的文章。但是在实际开发中，直接使用BeanFactory的场景还是比较少的，更多的时候是使用ApplicationContext。

那么下面我们就从ApplicationContext context=new ClassPathXmlApplicationContext("beanFactoryTest.xml");来探究ApplicationContext是如何启动的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
	this(new String[] {configLocation}, true, null);
}


public ClassPathXmlApplicationContext(
		String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
		throws BeansException {

	super(parent);
	setConfigLocations(configLocations);
	if (refresh) {
		refresh();
	}
}

实例化ApplicatoinContext的关键就在于这个refresh()方法。我们来看一下具体实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

@Override
	public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 准备工作，初始化Spring的状态，使Spring进入运行状态
			prepareRefresh();

			//初始化BeanFactory
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 准备bean工厂以供在此上下文中使用。
			prepareBeanFactory(beanFactory);

			try {
				//没有具体实现，谁要使用谁就实现，作用就是BeanFactory准备工作完成后做一些定制化的处理
				postProcessBeanFactory(beanFactory);

				//调用工厂后处理器 
			invokeBeanFactoryPostProcessors(beanFactory);

				// 注册Bean后处理器
				registerBeanPostProcessors(beanFactory);

				// 初始化消息源：初始化容器的国际化信息资源
				initMessageSource();

				//初始化应用上下文事件广播器
				initApplicationEventMulticaster();

				// 初始化其它特殊的bean
				onRefresh();

				// 注册事件监听器
				registerListeners();

				// 初始化所有的单例bean
				finishBeanFactoryInitialization(beanFactory);

				//发布上下文刷新事件
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}

refresh()方法中调用了许多其它的方法。下面我们就依次进入这些方法的实现中去探究一下，它们完成了什么工作。

准备工作prepareRefresh()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
protected void prepareRefresh() {
		this.startupDate = System.currentTimeMillis();
		//设置context关闭状态，激活标志
    	this.closed.set(false);
		this.active.set(true);

		/* 这个方法没有做任何事情，它的实现是空的。
		设计这个方法是为了在启动之前替换一些属性占位符
		这个地方是为了方便我们后期拓展
		*/
		initPropertySources();
		/*验证必须的属性是否正确
		*/
		getEnvironment().validateRequiredProperties();
    
		this.earlyApplicationEvents = new LinkedHashSet<>();
	}


初始化BeanFactory

初始化BeanFactory的工作由下面这行代码完成：

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
       //初始化BeanFactory的工作实际由这个方法完成
	refreshBeanFactory();
	return getBeanFactory();
}


protected final void refreshBeanFactory() throws BeansException {
	if (hasBeanFactory()) {
           /*如果之前已经由BeanFactory了那么就销毁单例池中的bean
           关闭BeanFactory
           */
		destroyBeans();
		closeBeanFactory();
	}
	try {
           //创建容器对象
		DefaultListableBeanFactory beanFactory = createBeanFactory();
           //设置SerializationId
		beanFactory.setSerializationId(getId());
           
           /*
           这个方法是一个钩子方法，
           子类可以覆盖它对当前上下文管理的BeanFactory进行自定义操作
           */
		customizeBeanFactory(beanFactory);
           /*装载配置文件，并传入相关联的BeanFacory对象
           作为BeanDefinition的容器
           */
		loadBeanDefinitions(beanFactory);
		synchronized (this.beanFactoryMonitor) {
			this.beanFactory = beanFactory;
		}
	}
	catch (IOException ex) {
		throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
	}
}

从源代码我们可以看出，初始化BeanFactory的工作实际上是由refreshBeanFactory()完成的。它工作流程是这样的：

  1. 首先判断BeanFactory是否已经存在了，如果已经存在，就销毁单例池和BeanFactory。否则继续执行BeanFactory的初始化工作

  2. 创建容器对象DefaultListableBeanFactory,这个对象非常的关键，它就是我们常说的IOC容器，稍后我们会探究创建容器对象的过程。

  3. 设置SerializationId

  4. 执行子类的钩子方法，可以对BeanFacotry进行自定义

  5. 装载配置文件，得到BeanDefinition，传入BeanFactory作为BeanDefintion的容器

  6. 完成BeanFactory的初始化工作

整个工作流程中，比较关键的第五步。下面我们来仔细分析一下这一步背后的逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
	// Create a new XmlBeanDefinitionReader for the given BeanFactory.
	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));

	initBeanDefinitionReader(beanDefinitionReader);
	loadBeanDefinitions(beanDefinitionReader);
}

这段代码的背后涉及了许多解析配置文件的细节，这里我们就不深究了。总之这段代码的作用就是解析配置文件，得到BeanDefinition，然后将所有的BeanDefintioin存入DefaultListableBeanFactory类中的Map<String, BeanDefinition> beanDefinitionMap 中，到此，我们已经拥有了创建Bean的描述信息BeanDefinition和BeanFactory。

准备BeanFactory

准备BeanFactory的工作是由prepareBeanFactory(beanFactory);完成的。我们看一下它的具体实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 设置类加载器，存在则直接设置/不存在则新建一个默认类加载器
		beanFactory.setBeanClassLoader(getClassLoader());
        //设置EL表达式解析器，bean出书画完成后完成属性填充式可能会用到
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        //设置属性注册解析器PropertyEditor
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// 使用上下文回调配置bean工厂
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		//设置忽略自动装配的接口
  beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

		//注册可以解析的自动装配
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// 将早期用于检测内部bean的后处理器注册为applicationlistener。
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// 检测LoadTimeWeaver并准备编织(如果找到)。
		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			// 为类型匹配设置一个临时类加载器。
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		// 注册缺省环境bean。
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}

准备BeanFactory主要做了这些事情：

  1. 设置类加载器
  2. 设置EL表达式解析器
  3. 利用BeanPostProcessor的特性给各种Aware接口的实现类注入ApplicationContext中对应的属性
  4. 设置各种Aware接口的实现类为忽略自动装配
  5. 设置自动装配的类(BeanFactory，ResourceLoader，ApplicationEventPublisher，ApplicationContext)
  6. 如果BeanFactory中存在loadTimeWeaver的bean，那么需要添加动态织入功能。
  7. 注册各种可用组件（environment，systemProperties，systemEnvironment）

允许用户在BeanFactory准备工作完成之后做一些定制化处理

postProcessBeanFactory(beanFactory);这个方法Spring中并没有具体实现的，它允许用户对BeanFactory进行一些定制化的处理。

调用工厂后处理器

invokeBeanFactoryPostProcessors(beanFactory);

根据反射机制从BeanDefintionRegistry中找出所有的BeanFactoryProcessor类型的Bean，并调用其postProcessBeanFactory()方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {

/*getBeanFactoryPostProcessors()拿到当前应用上下文beanFactoryPostProcessors变量中的值
invokeBeanFactoryPostProcessors实例化并调用所有已注册的BeanFactoryPostProcessors
*/       
       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()));
	}
}

注册Bean后处理器

registerBeanPostProcessors(beanFactory);

根据反射机制从BeanDefintionRegistry中找出所有BeanPostProcessor类型的bean，并将它们注册到容器Bean后处理器的注册表中。

初始化消息源：初始化容器的国际化信息资源

initMessageSource();

初始化应用上下文事件广播器

initApplicationEventMulticaster();

AbstractApplciationContext拥有一个applicationEventMulticaster 成员变量，applicationEventMulticaster 提供了容器监听器的注册表，成其为事件广播器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
protected void initApplicationEventMulticaster() {
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //首先看配置文件中有无配置该类型的类
		if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
			this.applicationEventMulticaster =
					beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
			if (logger.isTraceEnabled()) {
				logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
			}
		}
		else {
            //如果没有，则应用Spring框架提供的事件广播器实例
			this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
			beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
			if (logger.isTraceEnabled()) {
				logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
						"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
			}
		}
	}

Spring初始化事件广播器，用户可以在配置文件中为容器定义一个自定义的事件广播器(Bean的名称必须是applicationEventMulticaster)，只要实现了ApplicationEventMulticaster即可，Spring会从beanFactory中自动获取，如果没有找到外部配置的事件广播器，Spring将使用其内置的SimpleApplicationEventMulticasterSimpleApplicationEventMulticaster

初始化其它特殊的bean

onRefresh();

这个方法是一个钩子方法。子类可以借助这个钩子方法执行一些特殊的操作。

比如AbstractRefreshableWebApplicationContext就通过这个方法完成了初始化ThemeSource的操作。

初始化事件监听器

registerListeners();

Spring从BeanDefinitionRegistry中找出所有实现ApplicationListener的bean，将BeanDefinition对象生成bean，注册为容器的事件监听器，实际的操作就是将器添加到事件广播器提供的监听器注册表中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
protected void registerListeners() {
		// Register statically specified listeners first.
		for (ApplicationListener<?> listener : getApplicationListeners()) {
			getApplicationEventMulticaster().addApplicationListener(listener);
		}

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let post-processors apply to them!
		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
		for (String listenerBeanName : listenerBeanNames) {
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		}

		// Publish early application events now that we finally have a multicaster...
		Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
		this.earlyApplicationEvents = null;
		if (earlyEventsToProcess != null) {
			for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
				getApplicationEventMulticaster().multicastEvent(earlyEvent);
			}
		}
	}

初始化所有的单例bean

实例化所有单例的bean，并将它们放入到Spring容器的缓存中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// Initialize conversion service for this context.
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		// Register a default embedded value resolver if no bean post-processor
		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
		// at this point, primarily for resolution in annotation attribute values.
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
		}

		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		beanFactory.freezeConfiguration();

		// Instantiate all remaining (non-lazy-init) singletons.
		beanFactory.preInstantiateSingletons();
	}

发布上下文刷新事件

finishRefresh();

创建上下文刷新事件，事件广播其负责将这些事件广播道每个注册事件监听器中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
protected void finishRefresh() {
	// Clear context-level resource caches (such as ASM metadata from scanning).
	clearResourceCaches();

	// Initialize lifecycle processor for this context.
	initLifecycleProcessor();

	// Propagate refresh to lifecycle processor first.
	getLifecycleProcessor().onRefresh();

	// Publish the final event.
	publishEvent(new ContextRefreshedEvent(this));

	// Participate in LiveBeansView MBean, if active.
	LiveBeansView.registerApplicationContext(this);
}

getBean的过程

下面我将仔细分析这段代码的底层实现。

final MyTestBean bean = (MyTestBean) context.getBean("myTestBean");

1
2
3
4
5
public Object getBean(String name) throws BeansException {
       //这个方法是空方法
	assertBeanFactoryActive();
	return getBeanFactory().getBean(name);
}
1
2
3
public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

最关键的就是这个方法了，下面我们分析一下它背后的逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
		@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

       //拿到beanname
	final String beanName = transformedBeanName(name);
	Object 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 + "'");
			}
		}
           
           
           /*
           如果shareInstance是普通的单例bean则直接返回；
           如果shareInstance是FactoryBean类型，则需要调用getObject工厂方法获取真正的bean实例；
           如果用户想要获取FactoryBean则不做特殊处理
           */
		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
	}

	else {
		/*Spring只能解决单例对象的setter注入的循环依赖，不能解决构造注入，
		也不能解决多例的循环依赖*/
		if (isPrototypeCurrentlyInCreation(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}

		// 检测是否有父工厂
		BeanFactory parentBeanFactory = getParentBeanFactory();
           
           //如果存在父工厂且当前bean工厂不存在当前bean的定义，那么bean定义存在父工厂中
		if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
			// 获取bean的原始名称
			String nameToLookup = originalBeanName(name);
               //若为AbstractBeanFactory类型，委托父类处理
			if (parentBeanFactory instanceof AbstractBeanFactory) {
				return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
						nameToLookup, requiredType, args, typeCheckOnly);
			}
			else if (args != null) {
				// 委托到构造函数getBean处理
				return (T) parentBeanFactory.getBean(nameToLookup, args);
			}
			else if (requiredType != null) {
				return parentBeanFactory.getBean(nameToLookup, requiredType);
			}
			else {
                   //委托给标准getBean处理
				return (T) parentBeanFactory.getBean(nameToLookup);
			}
		}

           
           /*
           typeCheckOnly是用来判断调用getBean仅仅进行类型检查获取bean对象
           如果不是仅仅只做类型检查，而是创建bean对象，则需要调用markBeanAsCreated
           进行记录
           */
		if (!typeCheckOnly) {
			markBeanAsCreated(beanName);
		}

		try {
               
               /*从容器中或取beanName对应的GenericBeanDefinition对象，并将其转化为					RootBeanDefinition对象
               */
               
			final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
               //检查当前创建的bean定义是不是抽象的bean定义
			checkMergedBeanDefinition(mbd, beanName, args);

			//处理dependsOn依赖
               //获取所依赖的bean的名称
			String[] dependsOn = mbd.getDependsOn();
			if (dependsOn != null) {
				for (String dep : dependsOn) {
					if (isDependent(beanName, dep)) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
					}
                       //保存bean直接的依赖关系
					registerDependentBean(dep, beanName);
					try {
                           //获取依赖的bean（如果依赖的bean没有被创建，那么这个时候就被创建了）
						getBean(dep);
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
								"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
					}
				}
			}

			//是单例，则创建单例bean
			if (mbd.isSingleton()) {
				sharedInstance = getSingleton(beanName, () -> {
					try {
                           //创建bean
						return createBean(beanName, mbd, args);
					}
					catch (BeansException ex) {
						//创建bean的过程中发生异常，需要销毁关于当前bean的所有信息
						destroySingleton(beanName);
						throw ex;
					}
				});
                   
            /*
           如果shareInstance是普通的单例bean则直接返回；
           如果shareInstance是FactoryBean类型，则需要调用getObject工厂方法获取真正的bean实例；
           如果用户想要获取FactoryBean则不做特殊处理
           */
				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 {
				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;
		}
	}

	// 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;
}

拿到BeanName

final String beanName = transformedBeanName(name);

尝试从缓存中获取对象

Object sharedInstance = getSingleton(beanName);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
       //从单例池中获取单例对象
	Object singletonObject = this.singletonObjects.get(beanName);
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
           //单例池中没有该单例对象，且该单例正在创建过程中
		synchronized (this.singletonObjects) {
               //从提前暴露单例池中获取实例化的单例对象
			singletonObject = this.earlySingletonObjects.get(beanName);
			if (singletonObject == null && allowEarlyReference) {
                   //依然未获取到，就去获取单例工厂
				ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
				if (singletonFactory != null) {
                       //使用工厂方法获取单例对象，这个时候单例对象仅仅实例化
                       //在这个过程中还会调用getEarlyBeanReference()进行后置处理
					singletonObject = singletonFactory.getObject();
                       //加入提前暴露单例池
					this.earlySingletonObjects.put(beanName, singletonObject);
                       //从单例工厂Map中删除该单例工厂
					this.singletonFactories.remove(beanName);
				}
			}
		}
	}
	return singletonObject;
}

该方法的整个流程是这个样子的：

  1. 首先尝试直接从单例池中获取，如果获取到了就直接返回。
  2. 从单例池中没有获取到且该bean正在创建过程中，就尝试从提前暴露单例池中获取，获取到了直接返回。
  3. 如果提前暴露单例池中也没有，且允许提前暴露，就去获取该bean对应的bean工厂。
  4. 拿到bean工厂后通过bean工厂实例化bean，并加入提前暴露单例池，并从工厂池中删除该工厂。

这个方法中涉及到了Spring中非常重要的三级缓存机制，它用来解决循环依赖问题。首先尝试从一级缓存（单例池singletonObjects）中获取，如果获取不到就取二级缓存（提前暴露单例池earlySingletonObjects）中获取，二级缓存中的对象只是一个早期对象，这些对象都是刚刚实例化的对象，还没进行属性赋值等工作。如果二级缓存中依赖没有找到，那么就从三级缓存（singletonFactories）中获取，在getBean过程中调用构造方式实例化的适合，会把早期对象包裹成一个ObjectFactory暴露到三级缓存中

通过分析代码流程，我们可以看处这个方法是会返回空的，并且这个时候但会的bean并不完整，还未进行属性注入等工作

从头开始，合并Bean定义

但调用getSingleton方法并没有拿到bean的时候，就需要从头开始。创建一个bean的第一步就是拿到描述bean的信息即BeanDefinition。因为继承的存在，所以完整的Bean定义信息有一部分还在父类中，因此需要合并父类定义信息。

final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

它的具体实现如下：

1
2
3
4
5
6
7
8
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
	//首先尝试从缓存中获取
	RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
	if (mbd != null) {
		return mbd;
	}
	return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

首先尝试从缓存中获取合并后的Bean定义信息，如果缓存中没有，最终调用了这个方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
protected RootBeanDefinition getMergedBeanDefinition(
			String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
			throws BeanDefinitionStoreException {

		synchronized (this.mergedBeanDefinitions) {
			RootBeanDefinition mbd = null;

			// Check with full lock now in order to enforce the same merged instance.
			if (containingBd == null) {
				mbd = this.mergedBeanDefinitions.get(beanName);
			}

			if (mbd == null) {
                //如果没有父类配置
				if (bd.getParentName() == null) {
					// Use copy of given root bean definition.
					if (bd instanceof RootBeanDefinition) {
                        //直接将原来的Bean定义升级为RootBeanDefinition，完成合并
						mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
					}
					else {
                        //包裹为RootBeanDefinition
						mbd = new RootBeanDefinition(bd);
					}
				}
				else {
					//有父类定义
					BeanDefinition pbd;
					try {
                        //获取父类bean的名称
						String parentBeanName = transformedBeanName(bd.getParentName());
                        /*
                        如果父类beanName与子类beanName名称相同，
                        则父类bean一定在父容器中
                        */
						if (!beanName.equals(parentBeanName)) {
							pbd = getMergedBeanDefinition(parentBeanName);
						}
						else {
                            /*
                             * 这里再次调用getMergedBeanDefinition，只不过参数值变为了
                             * parentBeanName，用于合并父BeanDefinition 和爷爷辈的
                             * BeanDefinition。如果爷爷辈的BeanDefinition仍有父
                             * BeanDefinition，则继续合并
                             */
							BeanFactory parent = getParentBeanFactory();
							if (parent instanceof ConfigurableBeanFactory) {
								pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
							}
							else {
								throw new NoSuchBeanDefinitionException(parentBeanName,
										"Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
										"': cannot be resolved without an AbstractBeanFactory parent");
							}
						}
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
								"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
					}
					// 以父类BeanDefintion的配置信息为基本创建RootBeanDefinition
					mbd = new RootBeanDefinition(pbd);
                    //用子类的BeanDefintion中的属性覆盖父BeanDefintion中的属性
					mbd.overrideFrom(bd);
				}

                //如果用户未配置scope，则设置未singleton
				if (!StringUtils.hasLength(mbd.getScope())) {
					mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
				}

		
				if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
					mbd.setScope(containingBd.getScope());
				}

			
				if (containingBd == null && isCacheBeanMetadata()) 
                    //缓存合并后的BeanDefintion
					this.mergedBeanDefinitions.put(beanName, mbd);
				}
			}

			return mbd;
		}

处理DependsOn依赖

DependsOn依赖是bean创建前后的依赖。

整个DependsOn依赖的处理主要是doGetBean方法中的这段代码完成的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						registerDependentBean(dep, beanName);
						try {
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

从BeanDefintion中获取到DependsOn依赖的bean信息后。依次遍历调用isDependent方法。它的实现如下：

1
2
3
4
5
protected boolean isDependent(String beanName, String dependentBeanName) {
		synchronized (this.dependentBeanMap) {
			return isDependent(beanName, dependentBeanName, null);
		}
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
private boolean isDependent(String beanName, String dependentBeanName, @Nullable Set<String> alreadySeen) {
    //alreadySeen中存放的是已经检查的依赖bean
		if (alreadySeen != null && alreadySeen.contains(beanName)) {
			return false;
		}
    //获取原始beanName
		String canonicalName = canonicalName(beanName);
    //获取当前bean所依赖的bean的名称的集合
		Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
		if (dependentBeans == null) {
            //不依赖任何的前置bean，则直接返回
			return false;
		}
		if (dependentBeans.contains(dependentBeanName)) {
            //说明已经存在已经注册的bean
			return true;
		}
    //递归检查依赖
		for (String transitiveDependency : dependentBeans) {
			if (alreadySeen == null) {
				alreadySeen = new HashSet<>();
			}
            //添加到areadySeen
			alreadySeen.add(beanName);
            //递归检查依赖
			if (isDependent(transitiveDependency, dependentBeanName, alreadySeen)) {
				return true;
			}
		}
		return false;
	}

调用registerDependentBean保存bean直接的依赖关系。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void registerDependentBean(String beanName, String dependentBeanName) {
    //获取原始的beanName
		String canonicalName = canonicalName(beanName);

    //添加 <canonicalName, dependentBeanName> 到 dependentBeanMap 中
		synchronized (this.dependentBeanMap) {
			Set<String> dependentBeans =
					this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
			if (!dependentBeans.add(dependentBeanName)) {
				return;
			}
		}

    //添加 <dependentBeanName, canonicalName> 到 dependenciesForBeanMap 中
		synchronized (this.dependenciesForBeanMap) {
			Set<String> dependenciesForBean =
					this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
			dependenciesForBean.add(canonicalName);
		}
	}

最后调用getBean方法，获取所依赖的Bean（若该bean没创建，就创建）。

处理单例Bean

处理单实例的bean主要是由这段代码完成的。

1
2
3
4
5
6
7
8
9
sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});

从这段代码我们可以看出关键在于getSingleton方法.下面我们来看它的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		synchronized (this.singletonObjects) {
            //尝试从单例池(一级缓存)中获取
			Object singletonObject = this.singletonObjects.get(beanName);
			if (singletonObject == null) {
                //单例池中没有
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(beanName,
							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
				}
                //标记当前bean正在创建
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<>();
				}
				try {
                    //创建bean
					singletonObject = singletonFactory.getObject();
					newSingleton = true;
				}
				catch (IllegalStateException ex) {
					//回调singletonObjects的get方法
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						throw ex;
					}
				}
				catch (BeanCreationException ex) {
					if (recordSuppressedExceptions) {
						for (Exception suppressedException : this.suppressedExceptions) {
							ex.addRelatedCause(suppressedException);
						}
					}
					throw ex;
				}
				finally {
					if (recordSuppressedExceptions) {
						this.suppressedExceptions = null;
					}
                    //后置处理，将当前bean从正在创建集合中移除
					afterSingletonCreation(beanName);
				}
				if (newSingleton) {
                    //加入单例池
					addSingleton(beanName, singletonObject);
				}
			}
			return singletonObject;
		}
	}

整个过程中，比较关键的在于singletonFactory.getObject();

这个getObject实际上是调用了createBean方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		if (logger.isTraceEnabled()) {
			logger.trace("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;

		// Make sure bean class is actually resolved at this point, and
		// clone the bean definition in case of a dynamically resolved Class
		// which cannot be stored in the shared merged bean definition.
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		// Prepare method overrides.
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			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);
		}

		try {
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			if (logger.isTraceEnabled()) {
				logger.trace("Finished creating instance of bean '" + beanName + "'");
			}
			return beanInstance;
		}
		catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
			// A previously detected exception with proper bean creation context already,
			// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
		}
	}

真正完成bean创建的是doCreateBean方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
			throws BeanCreationException {

		// BeanWrapper是bean包装器，包装bean对象和属性描述器
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
            //从没有完成的FactoryBean中移除
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
            //使用合适的实例化策略进行实例化
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
    //拿到刚刚实例化的早期bean
		final Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}

		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
                    //进行后置处理@AutoWired的注解的预解析
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// 判断该对象是否可以早期暴露
		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");
			}
            //将早期暴露对象包装未一个SingletonFactory，存放到三级缓存中
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
            //进行属性赋值（调用set方法进行赋值）
			populateBean(beanName, mbd, instanceWrapper);
            //进行bean的初始化，这里可能生成代理对象
			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) {
            /**
             * 去缓存中获取到我们的对象 由于传递的allowEarlyReference 是false 要求只能在一级二级缓存中去获取
             * 正常普通的bean(不存在循环依赖的bean) 创建的过程中，压根不会把三级缓存提升到二级缓存中
             */
			Object earlySingletonReference = getSingleton(beanName, false);
            //能够获取到
			if (earlySingletonReference != null) {
                //经过后置处理的bean和早期bean引用还相等的话，表示当前bean没有被代理过
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
                //处理依赖bean
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> 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.");
					}
				}
			}
		}

根据ShareInstance获取真正bean

在doGetBean方法中我们多次看到bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

之所以要不是直接返回ShareInstance，是因为可能拿到的bean是一个FactoryBean的bean，需要调用getBean方法，才能拿到真正的bean。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

		// 如果name以&开头，但beanInstance却不是FactoryBean，则认为有问题
		if (BeanFactoryUtils.isFactoryDereference(name)) {
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
			if (!(beanInstance instanceof FactoryBean)) {
				throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
			}
		}

		/*
		如果上面的判断通过了，则表明beanInstance可能是一个普通的bean，页可能是一个FactoryBean，
		如果是一个不同bean，这里直接返回即可
		如果是FactoryBean，则要调用工厂方法生成一个bean
		*/
		if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
			return beanInstance;
		}

		Object object = null;
		if (mbd == null) {
            /*
            如果mbd未空，则从缓存中加载bean，FactoryBean生成的单例bean会被缓存
            在factoryBeanObjectCache集合中，不会每次都创建
            */
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			//经过前面的判断，这里可以断定beanInstance是FactoryBean类型的
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			//如果mbd为空，则判断是否存在名字beanName的BeanDefiniton
			if (mbd == null && containsBeanDefinition(beanName)) {
				mbd = getMergedLocalBeanDefinition(beanName);
			}
            
			boolean synthetic = (mbd != null && mbd.isSynthetic());
            //调用getObjectFromFactoryBean方法继续和获取实例
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}

最后调用getObjectFromFactoryBean(factory, beanName, !synthetic);方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
           /**
             * FactoryBean 也有单例和非单例之分，针对不同类型的 FactoryBean，这里有两种处理方式：
             *   1. 单例 FactoryBean 生成的 bean 实例也认为是单例类型。需放入缓存中，供后续重复使用
             *   2. 非单例 FactoryBean 生成的 bean 实例则不会被放入缓存中，每次都会创建新的实例
             **/
        if (factory.isSingleton() && containsSingleton(beanName)) {
            synchronized (getSingletonMutex()) {
                //从缓存中取bean实例，避免多次创建bean实例
                Object object = this.factoryBeanObjectCache.get(beanName);
                if (object == null) {
                    //使用工厂对象中创建实例
                    object = doGetObjectFromFactoryBean(factory, beanName);
                    // Only post-process and store if not put there already during getObject() call above
                    // (e.g. because of circular reference processing triggered by custom getBean calls)
                    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                    if (alreadyThere != null) {
                        object = alreadyThere;
                    }
                    else {
                        if (shouldPostProcess) {
                            //判断当地的bean是否正在创建
                            if (isSingletonCurrentlyInCreation(beanName)) {
                                // Temporarily return non-post-processed object, not storing it yet..
                                return object;
                            }
                            beforeSingletonCreation(beanName);
                            try {
                                object = postProcessObjectFromFactoryBean(object, beanName);
                            }
                            catch (Throwable ex) {
                                throw new BeanCreationException(beanName,
                                        "Post-processing of FactoryBean's singleton object failed", ex);
                            }
                            finally {
                                afterSingletonCreation(beanName);
                            }
                        }
                        // 这里的beanName对应于FactoryBean的实现类，FactoryBean的实现类也会被实例化，并被缓存在singletonObjects中
                        if (containsSingleton(beanName)) {
                            // 这里的beanName对应于FactoryBean的实现类，FactoryBean的实现类也会被实例化，并被缓存在singletonObjects中
                            this.factoryBeanObjectCache.put(beanName, object);
                        }
                    }
                }
                return object;
            }
        }
        else {
            Object object = doGetObjectFromFactoryBean(factory, beanName);
            if (shouldPostProcess) {
                try {
                    object = postProcessObjectFromFactoryBean(object, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
                }
            }
            return object;
        }
    }

使用工厂对象创建实例object=doGetObjectFromFactoryBean(factory,beanName)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
            throws BeanCreationException {

        Object object;
        try {
            if (System.getSecurityManager() != null) {
                AccessControlContext acc = getAccessControlContext();
                try {
                    object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                //真正的调用工厂bean的getObject()方法
                object = factory.getObject();
            }
        }
        catch (FactoryBeanNotInitializedException ex) {
            throw new BeanCurrentlyInCreationException(beanName, ex.toString());
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
        }

        // Do not accept a null value for a FactoryBean that's not fully
        // initialized yet: Many FactoryBeans just return null then.
        if (object == null) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(
                        beanName, "FactoryBean which is currently in creation returned null from getObject");
            }
            object = new NullBean();
        }
        return object;
    }

流程图

8QHPCd.png

技术JavaSpring
许可协议

本文采用 署名-非商业性使用-相同方式共享 4.0 国际 许可协议，转载请注明出处。

快来参与讨论吧~