Spring核心API

BeanFactory

org.springframework.beans.factory（BeanFactory）是用于访问Spring Bean 容器的接口，典型的工厂模式，用于生产Bean 的一个Bean工厂模式，其提供了生产Bean所需的最基本规则。

BeanFactory的所有方法：

BeanDefinition

功能：BeanDefinition是bean在Spring中的描述，有了BeanDefinition可以创建Bean，BeanDefinition是Bean在Spring中的定义的形态。

BeanDefinition beanDefinition = new BeanDefinition() {
            @Override
            public void setAttribute(String s, Object o) {

            }

            @Override
            public Object getAttribute(String s) {
                return null;
            }

            @Override
            public Object removeAttribute(String s) {
                return null;
            }

            @Override
            public boolean hasAttribute(String s) {
                return false;
            }

            @Override
            public String[] attributeNames() {
                return new String[0];
            }

            @Override
            public void setParentName(String s) {
                //设置父definition的名称
            }

            @Override
            public String getParentName() {
                //返回当前bean definition的父definition的名字
                return null;
            }

            @Override
            public void setBeanClassName(String s) {
                //指定bean definition的类名
            }

            @Override
            public String getBeanClassName() {
                //返回当前bean definition定义的类名
                return null;
            }

            @Override
            public void setScope(String s) {
                   //设置bean的范围,如:单例,多实例
            }

            @Override
            public String getScope() {
                //返回当前bean的目标范围
                return null;
            }

            @Override
            public void setLazyInit(boolean b) {
                //设置是否延迟初始化
            }

            @Override
            public boolean isLazyInit() {
                //bean是否是延迟初始化
                return false;
            }

            @Override
            public void setDependsOn(String... strings) {
                //设置当前bean初始化所依赖的beans的名称
            }

            @Override
            public String[] getDependsOn() {
                //返回当前bean所依赖的其他bean的名称
                return new String[0];
            }

            @Override
            public void setAutowireCandidate(boolean b) {
                
                //设置bean是否对其他bean是自动装配的候选bean

            }

            @Override
            public boolean isAutowireCandidate() {
                return false;
            }

            @Override
            public void setPrimary(boolean b) {
                //设置是否主要的候选bean
            }

            @Override
            public boolean isPrimary() {
                //bean是否为自动装配的主要候选bean
                return false;
            }

            @Override
            public void setFactoryBeanName(String s) {

            }

            @Override
            public String getFactoryBeanName() {
                //返回factory bean的名称
                return null;
            }

            @Override
            public void setFactoryMethodName(String s) {

            }

            @Override
            public String getFactoryMethodName() {
                //返回工厂方法的名称
                return null;
            }

            @Override
            public ConstructorArgumentValues getConstructorArgumentValues() {
                //返回bean的构造函数参数
                return null;
            }

            @Override
            public MutablePropertyValues getPropertyValues() {
                //返回一个用于新的bean实例上的属性值
                return null;
            }

            @Override
            public void setInitMethodName(String s) {

            }

            @Override
            public String getInitMethodName() {
                return null;
            }

            @Override
            public void setDestroyMethodName(String s) {

            }

            @Override
            public String getDestroyMethodName() {
                return null;
            }

            @Override
            public void setRole(int i) {

            }

            @Override
            public int getRole() {
                return 0;
            }

            @Override
            public void setDescription(String s) {

            }

            @Override
            public String getDescription() {
                return null;
            }

            @Override
            public ResolvableType getResolvableType() {
                return null;
            }

            @Override
            public boolean isSingleton() {
                // bean是否是单例
                return false;
            }

            @Override
            public boolean isPrototype() {
                //bean是否是多实例
                return false;
            }

            @Override
            public boolean isAbstract() {
                //当前bean是否是abstract,意味着不能被实例化
                return false;
            }

            @Override
            public String getResourceDescription() {
                return null;
            }

            @Override
            public BeanDefinition getOriginatingBeanDefinition() {
                //返回原始的BeanDefinition,如果不存在返回null
                return 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
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
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212

BeanDefinition接口

顶级基础接口，用来描述Bean，里面存放Bean元数据，比如Bean类名，scope、属性、构造函数参数列表、依赖的bean、是否是单例类、是否是懒加载等一系列信息。

向上：

• BeanMetadataElement接口：BeanDefinition元数据，返回该Bean的来源
• AttributeAccessor接口：提供对BeanDefinition属性操作能力

向下：

**AbstractBeanDefinition类：**抽象类统一实现了BeanDefinition定义的一部分操作，可以说是定义了BeanDefinition很多默认的属性。 正是在AbstractBeanDefinition基础上， Spring衍生出了一些列 BeaDefinition。这里我们可以关注下重写的equals(),hashcode(), toString()方法

此外initMethodName属性，destroyMethodName 属性， 这两个属性bean的生命周期有关，

从AbstractBeanDefinition上衍生出来的几个类

RootBeanDefinition: 代表一个xml,java Config来的BeanDefinition

ChildBeanDefinition: 从Spring2.5开始，ChildBeanDefinition已经不再使用，取而代之的是GenericBeanDefinition。GenericBeanDefinition: spring2.5后注册bean首选的是GenericBeanDefinition。GenericBeanDefinition 允许动态的设置父bean.GenericBeanDefinition可以作为RootBeanDefinition与ChildBeanDefinition的替代品。

AnnotatedBeanDefinition接口： 表示注解类型BeanDefinition。有两个重要的属性，AnnotationMetadata，MethodMetadata分别表示BeanDefinition的注解元信息和方法元信息 实现了此接口的BeanDefinition可以获取到注解元数据和方法元数据

AnnotatedGenericBeanDefinition类: 表示@Configuration注解注释的BeanDefinition类 ScannedGenericBeanDefinition类: 表示@Component、@Service、@Controller等注解注释的Bean类操作动作也可分为两种： 一种是针对自身的操作: 自提提供给外部的可以操作其本身的动作 另一种是外部对BeanDefinition 的操作

**BeanDefinitionRegistry接口：**具有增，查，删BeanDefinition的能力。一次只能注册一个BeanDefinition.实现类SimpleBeanDefinitionRegistry，DefaultListableBeanFactory，GenericApplicationContext等 一般实现类里都都有一个 private final Map beanDefinitionMap = new ConcurrentHashMap()来存储BeanDefinition.

BeanDefinitionReader接口： 既可以使用BeanDefinitionRegistry构造。也可以通过loadBeanDefinitions 把配置加载为多个BeanDefinition并注册到BeanDefinitionRegistry中。 可以说是高效版本的 BeanDefinitionRegistry. 实现类有XmlBeanDefinitionReader从xml中读取BeanDefinition； PropertiesBeanDefinitionReader从Properties文件读取BeanDefinition

AnnotatedBeanDefinitionReader类： 对带有注解的BeanDefinition进行注册

ClassPathBeanDefinitionScanner类： 可以扫描到@Component @Repository @Service @Controller

的BeanDefinition注册到容器中。

其他形态BeanDefinitionHolder： BeanDefinition包装类。

Bean

Bean是我们需要的对象，是我们从spring内得到的结果，也就是对象实例

定义

从定义层面看.Bean其实就是我们需要的对象.

操作

我们来看看Bean在spring有哪些操作相关的接口或类。

• SingletonBeanRegistry接口：与BeanDefinition的注册相应的。Bean的操作也有一个类似的接口来操作 Bean.SingletonBeanRegistry接口提供了对Bean的注册，获取，存在性判断等功能。
• InitializingBean:对于实现 InitializingBean的Bean，它将执行 afterPropertiesSet(); 在所有的 bean 属性被设置之后。
• InstantiationStrategy:提供 Bean实例化的策略接口，
• DisposableBean:对于 实现了DisposableBean的Bean ，它将运行 destroy()在 Spring 容器释放该 bean 之后
• FactoryBean: 生产Bean的Bean.

其他形态

BeanWrapper: 对Bean的包装.BeanWrapper可以看作是一个从 BeanDefinition 到 Bean 过程中间的产物，

可以称为”低级 bean“，在一般情况下，我们不会在实际项目中用到它。BeanWrapper 是 Spring 框架中重要的组件类，它就相当于一个代理类，Spring 委托 BeanWrapper 完成 Bean 属性的填充工作。在 bean 实例被

InstantiatioonStrategy 创建出来后，Spring 容器会将 Bean 实例通过 BeanWrapper 包裹起来，是通过

BeanWrapper.setWrappedInstance() 完成的

总结：

BeanDefinition是物料，Bean是成品，理解BeanDefinition与Bean的关系是理解spring的基础。