【注意】最后更新于 October 1, 2018，文中内容可能已过时，请谨慎使用。
Spring的IOC源码分析
一、Spring的体系结构
BeanFactory实现工厂模式，创建bean工厂类；BeanDefinition是描述bean的信息，比如类的属性，构造方法等一些类基本信息；
Spring的IOC中最核心两个接口；
1. BeanFactory体系图
根据上面类做简单说明，DefaultListableBeanFactory是BeanFactory实现类，也是IOC最核心实现类，实现IOC所有操作；
- BeanFactory：bean工厂接口类，获取bean对象；
- ListableBeanFactory：获取BeanDefinition统计信息，按类型查询BeanDefinition的名称等BeanDefinitions信息；
- HierarchicalBeanFactory：bean层级关系；
- ConfigurableBeanFactory：提供配置Factory的各种方法。
- SingletonBeanRegistry：定义单例的注册和获取。
- ConfigurableBeanFactory：提供配置beanFactory的各种方法。
- AutowireCapableBeanFactory：提供创建Bean、自动注入、初始化以及应用bean的后处理器。
- ConfigurableListableBeanFactory：提供了分析和修改bean定义以及预先实例化单例的工具。
- AliasRegistry:定义对alias的简单增删改等操作
- BeanDefinitionRegistry：定义对BeanDefinition的各种增删查改。
Spring的IOC的bean工厂接口，提供这么多接口，主要实现单一原则，让每个接口单一职责；然后下面介绍实现单一职责接口抽象类和实现类；
- SimpleAliasRegister实现AliasRegistry接口，具有AliasRegistry职责特性；
- DefaultSingletonBeanRegistry实现SingletonBeanRegistry接口，具有SingletonBeanRegistry职责特性；
- FactoryBeanRegistrySupport：集成单例bean管理
- AbstractBeanFactory：实现ConfigurableBeanFactory的接口，具有ConfigurableBeanFactory职责特性。
- AbstractAutowireCapableBeanFactory：实现ConfigurableBeanFactory的接口，具有AutowireCapableBeanFactory职责特性。
- DefaultListableBeanFactory实现上面所有接口和继承上面所有抽象类，具有上面所有接口职责特性；DefaultListableBeanFactory在Spring中IOC最核心类；
2. BeanDefinition体系图
根据上面UML图，简单说明一下；
- AttributeAccessor：从类名可以看出什么意思；其次就是属性操作；
- AttributeAccessorSupport 是AttributeAccessor接口实现，内部就是LinkedHashMap保存数据；
- BeanMetadataElement： 获取配置源对象的bean元数据元素。
- BeanMetadataAttributeAccessor 是BeanMetadataElement接口实现，对配置源获取和修改；继承AttributeAccessorSupport，覆盖属性方法，包装成BeanMetadataAttribute对象属性；
- BeanDefinition：类名、scope、属性、构造函数参数列表、依赖的bean、是否是单例类、是否是懒加载等操作，具体在后面在说；BeanDefinition实现类后面具体介绍；
- AnnotatedBeanDefinition :扩展BeanDefinition接口，暴露AnnotationMetadata关于其bean类 - 不需要加载类。
(1). BeanDefinition接口
从接口方法理解BeanDefinition保存类那些属性；用的不多具体说明一下；
-
AutowireCandidate： 设置此bean是否可以自动连接到其他bean。请注意，此标志仅用于影响基于类型的自动装配。 它不会影响名称的显式引用，即使指定的bean未标记为autowire候选，也会解析它。 因此，如果名称匹配，按名称自动装配将注入bean。
-
Primary：这个标示，主要作用多个实现类时，标示为true,设置为默认自动注入类；
二、XML的BEAN
在spring 3.0以前都是XML配置bean；这以来我们进行三个步骤对BeanDefinition的Resource定位、载入和注册这三个基本的过程；
1.Resource定位
1
|
BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
|
XmlBeanFactory用过时类，这里主要具体讲解XML的BEAN过程；XmlBeanFactory继承DefaultListableBeanFactory具有BeanFory特性；
1
|
new ClassPathResource("applicationContext.xml")
|
定位bean的xml;ClassPathResource实现Resource接口；Resource接口资源接口；
2.载入
XmlBeanFactory中创建XmlBeanDefinitionReader对象，XmlBeanDefinitionReader.loadBeanDefinitions进行载入BeanDefinition操作；
(1).XmlBeanDefinitionReader
这个UML关系到的类；
类简单说明一下：
- DocumentLoader：加载XML创建Document；
- BeanDefinitionDocumentReader：解析Document中的节点元素Element，例如beans，bean等节点；bean节点属性和子节点交给BeanDefinitionParserDelegate处理；
- BeanDefinitionParserDelegate：实际解析Document中的bean节点元素，封装成BeanDefinition；
- DefaultNamespaceHandlerResolver : 在META-INF/spring.handlers路径查找特定名称空间URI的NamespaceHandler实现。
(2).载入流程
(4).具体分析BeanDefinitionParserDelegate.parseBeanDefinitionElement
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
|
/**
* Parse the bean definition itself, without regard to name or aliases. May return
* {@code null} if problems occurred during the parsing of the bean definition.
*/
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
try {
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
//创建GenericBeanDefinition
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
//解析bean元素的属性
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
//meta 被AttributeAccessor添加
parseMetaElements(ele, bd);
// 通常称为获取器注入，spring in action中对它的描述是，一种特殊的方法注入，它是把一个方法声明为返回某种类型的bean，
// 而实际要返回的bean是在配置文件里面配置的，可用在设计可插拔的功能上，接触程序依赖。
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
//可以在运行时用新的方法替换旧的方法。
// arg-type处理重载方法
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
parseConstructorArgElements(ele, bd);
parsePropertyElements(ele, bd);
parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
return bd;
}
catch (ClassNotFoundException ex) {
error("Bean class [" + className + "] not found", ele, ex);
}
catch (NoClassDefFoundError err) {
error("Class that bean class [" + className + "] depends on not found", ele, err);
}
catch (Throwable ex) {
error("Unexpected failure during bean definition parsing", ele, ex);
}
finally {
this.parseState.pop();
}
return null;
}
/**
* Apply the attributes of the given bean element to the given bean * definition.
* @param ele bean declaration element
* @param beanName bean name
* @param containingBean containing bean definition
* @return a bean definition initialized according to the bean element attributes
*/
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
BeanDefinition containingBean, AbstractBeanDefinition bd) {
if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
}
else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
}
else if (containingBean != null) {
// Take default from containing bean in case of an inner bean definition.
bd.setScope(containingBean.getScope());
}
if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
}
String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
if (DEFAULT_VALUE.equals(lazyInit)) {
lazyInit = this.defaults.getLazyInit();
}
bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
bd.setAutowireMode(getAutowireMode(autowire));
String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);
bd.setDependencyCheck(getDependencyCheck(dependencyCheck));
//检查属性
if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
}
//自动依赖注入
String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {
String candidatePattern = this.defaults.getAutowireCandidates();
if (candidatePattern != null) {
String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
}
}
else {
bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
}
//自动装配时当出现多个Bean候选者时，Primary 为True的Bean将作为首选者，否则将抛出异常
if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
}
if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
if (!"".equals(initMethodName)) {
bd.setInitMethodName(initMethodName);
}
}
else {
if (this.defaults.getInitMethod() != null) {
bd.setInitMethodName(this.defaults.getInitMethod());
bd.setEnforceInitMethod(false);
}
}
if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
bd.setDestroyMethodName(destroyMethodName);
}
else {
if (this.defaults.getDestroyMethod() != null) {
bd.setDestroyMethodName(this.defaults.getDestroyMethod());
bd.setEnforceDestroyMethod(false);
}
}
//通过调用静态工厂方法创建bean,使用<constructor-arg>元素为该方法传递方法参数
if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
}
//通过调用实例工厂方法创建bean
// -在bean的factory-bean属性里指定拥有该工厂方法的bean
// -在factory-method属性里指定该工厂方法的名称
// -使用constructor-arg元素为工厂方法传递方法参数
if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
}
return bd;
}
|
3.注册
BeanDefinitionDocumentReader.processBeanDefinition方法中注册代码
1
|
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
|
这里处理BeanDefinition都注册到DefaultListableBeanFactory中beanDefinitionMap中,别名注册到DefaultListableBeanFactory中；
三、注解的BEAN
1
2
3
4
5
6
7
8
9
10
11
12
13
|
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd">
<context:component-scan base-package="com.zp.controller" />
</beans>
|
上面介绍过自定义"context:component-scan"节点，会从DefaultNamespaceHandlerResolver按URI查找相应NamespaceHandler实现类；
DefaultNamespaceHandlerResolver先从META-INF/spring.handlers文件读取，保存空间URI到NamespaceHandler类名称MAP;例如
按"http://www.springframework.org/schema/context"查询对应到ContextNamespaceHandler；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public class ContextNamespaceHandler extends NamespaceHandlerSupport {
@Override
public void init() {
registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
}
}
|
“component-scan"元素找到ComponentScanBeanDefinitionParser解析；自定义解析继承BeanDefinitionParser接口；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
// Actually scan for bean definitions and register them.
ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
return null;
}
|
找到注解扫描ClassPathBeanDefinitionScanner类；按basePackages扫描查找相应class;生产ScannedGenericBeanDefinition注册到DefaultListableBeanFactory；
ClassPathBeanDefinitionScanner扫描怎么处理呢？后面具体在说明；
四、DefaultListableBeanFactory分析
1.registerBeanDefinition 注册BeanDefinition
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
|
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
//处理MethodOverrides
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition oldBeanDefinition;
oldBeanDefinition = this.beanDefinitionMap.get(beanName);
if (oldBeanDefinition != null) {
//是否替换BeanDefinition
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + oldBeanDefinition + "] bound.");
}
else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (this.logger.isWarnEnabled()) {
this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
oldBeanDefinition + "] with [" + beanDefinition + "]");
}
}
else if (!beanDefinition.equals(oldBeanDefinition)) {
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
}
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
if (hasBeanCreationStarted()) { //是否在创建bean对象，是，成在线程安全问题；
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// Still in startup registration phase
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
//重置beanName缓存的数据
if (oldBeanDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}
|
注册BeanDefinition分步骤
- 处理MethodOverrides
- beanDefinitionMap是否包含key值beanName,包含处理是否覆盖以前BeanDefinition数据；
- 不包含，BeanDefinition注册到beanDefinitionMap，把beanName添加beanDefinitionNames集合中；manualSingletonNames移除beanName；
- 正常创建bean对象，成在线程安全问题，这里用synchronized处理线程安全问题；
2.registerAlias 注册别名
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
|
/** Map from alias to canonical name */
private final Map<String, String> aliasMap = new ConcurrentHashMap<String, String>(16);
@Override
public void registerAlias(String name, String alias) {
Assert.hasText(name, "'name' must not be empty");
Assert.hasText(alias, "'alias' must not be empty");
if (alias.equals(name)) {
this.aliasMap.remove(alias);
}
else {
String registeredName = this.aliasMap.get(alias);
if (registeredName != null) {
if (registeredName.equals(name)) {
// An existing alias - no need to re-register
return;
}
if (!allowAliasOverriding()) {
throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" +
name + "': It is already registered for name '" + registeredName + "'.");
}
}
checkForAliasCircle(name, alias);
this.aliasMap.put(alias, name);
}
}
|
从代码可以看出用ConcurrentHashMap保存别名对象；aliasMap对应alias->name;这里注意是alias1->beanName,alias2->alias1这种数据结构；
aliasMap.get(alias)为空时，这时alias就是beanName;
3.getBean 获取bean对象；
调用AbstractBeanFactory.doGetBean,获取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
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
|
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
//包含&前缀name,转化成beanName
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 1.先从缓存中获取被创建过的单态类型的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 {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
// 2.判断Prototype类型是否循环引用
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
// 3.检查是否有父BeanFactory,该BeanFactory中beanDefinitionMap没找beanName，就用从父BeanFactory中getBean
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
// 4.是否为类型检查获取实例
if (!typeCheckOnly) {
// 作用：将指定的bean标记为已创建（或即将创建）。这允许bean工厂优化其缓存以重复创建指定的bean。
markBeanAsCreated(beanName);
}
try {
// 5.合并的RootBeanDefinition，如果beanName指定父beanName，则遍历父beanName,进行合并成RootBeanDefinition；
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// RootBeanDefinition是否抽象标示，是throw BeanIsAbstractException
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
// 6.保证当前bean依赖的bean的初始化,有依赖，先执行getBean
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注册一个依赖bean，在销毁给定bean之前销毁它。
registerDependentBean(dep, beanName);
getBean(dep);
}
}
// Create bean instance.
// 7.Singleton类型，检查Singleton模式bean;
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//7.Prototype类型，每次都要从新创建bean
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
//创建bean之前钩子
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//创建bean之后钩子
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//7.其他Scope类型，用Scope控制创建bean;比较常用，如：request、session、application等生命周期
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<Object>() {
@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;
}
}
// Check if required type matches the type of the actual bean instance.
// 8.检查所需类型是否与实际bean实例的类型匹配。
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type [" +
ClassUtils.getQualifiedName(requiredType) + "]", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
|
源码注解中都是分步骤了解源码；先从Singleton模式开始说
（1).Singleton
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
|
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
// 1.先从singletonObjects缓存Map获取bean对象
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
//BeanFactory请求destroy，不能在创建对象的标示
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 + "'");
}
//2.验证循环依赖，往singletonsCurrentlyInCreation添加beanName，添加失败，就有循环依赖问题
beforeSingletonCreation(beanName);
boolean newSingleton = false;
//处理循环依赖异常集合
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
//3.ObjectFactory对象创建bean对象
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
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;
}
//4.往singletonsCurrentlyInCreation移除beanName，移除失败，throw IllegalStateException 已创建对象异常
afterSingletonCreation(beanName);
}
// 5.创建bean对象成功，
// singletonObjects添加bean对象,singletonFactories和earlySingletonObjects移除beanName
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
|
（2).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
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
|
@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;
// 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.
// 1.解析指定bean定义的bean类
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
// 2. 处理MethodOverride
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.
// 3.处理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);
}
// 4.RootBeanDefinition创建对象
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
//1.创建 BeanWrapper
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.
// 2.处理merged BeanPostProcessor
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// 3.处理Singleton模式；
// singletonFactories添加ObjectFactory，earlySingletonObjects移除beanName,registeredSingletons添加beanName
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<Object>() {
@Override
public Object getObject() throws BeansException {
//获取早期访问指定bean的引用，通常用于解析循环引用。
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//4.处理bean中属性
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
//5.处理bean中初始化值和BeanPostProcessors
// (1).处理继承Aware接口，赋值相应接口方法传值
// (2).处理BeanPostProcessor的postProcessBeforeInitialization
// (3).InitializingBean接口处理afterPropertiesSet方法，处理自己实现InitMethod
// (4).处理BeanPostProcessor的postProcessAfterInitialization
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);
}
}
// 6.处理Singleton模式
// 处理singletonFactories中ObjectFactory，earlySingletonObjects添加对象，移除singletonFactories
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
//dependentBeanMap 移除依赖关系beanname
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String>(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.");
}
}
}
}
// Register bean as disposable.
// 7.注册DisposableBean接口
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
|
（3).解析Singleton模式循环依赖
构造器参数循环依赖，只能抛出BeanCurrentlyInCreationException；set参数循环依赖,就不throw异常；why??
DefaultSingletonBeanRegistry处理Singleton模式
1
2
3
4
5
6
7
8
9
10
11
12
|
/** Cache of singleton objects: bean name --> bean instance */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
/** Cache of singleton factories: bean name --> ObjectFactory */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
/** Cache of early singleton objects: bean name --> bean instance */
private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
/** Names of beans that are currently in creation */
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));
|
创建Singleton流程:
1.调用getSingleton，参数为beanName;从缓存中获取对象
- singletonObjects获取对象，为空时候，singletonsCurrentlyInCreation包含beanName，理singletonFactories中ObjectFactory，earlySingletonObjects添加对象，移除singletonFactories
这时得到一个零时对象；
2:调用getSingleton,参数ObjectFactory对象，内容只是createBean
3:往singletonsCurrentlyInCreation添加beanName
4.执行createBean，随后创建实例
5.singletonFactories添加ObjectFactory，earlySingletonObjects移除beanName,ObjectFactory保存零时对象；
6.执行初始化属性,就如set操作
7.处理singletonFactories中ObjectFactory，earlySingletonObjects添加对象，移除singletonFactories
8.singletonsCurrentlyInCreation移除beanName
9.singletonObjects添加bean对象,singletonFactories和earlySingletonObjects移除beanName
从流程中可以看出，singletonObjects是对象容器，singletonFactories创建bean，创建ObjectFactory对象保存零时对象值；earlySingletonObjects处理保存零时对象值；
singletonsCurrentlyInCreation创建对象表示；
从而可以看出set参数循环依赖，就不会throw异常；
构造器参数循环依赖，在构造对象值时，没创建ingletonFactories，所有根据singletonsCurrentlyInCreation值包含beanName就throw BeanCurrentlyInCreationException;
（4).Prototype模式处理
getBean 中部分代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
//7.Prototype类型，每次都要从新创建bean
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
//创建bean之前钩子；ThreadLocal保存当前beanName值
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//创建bean之后钩子；ThreadLocal移除当前beanName值
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
|
