主要内容：
一、IOC容器的初始化流
创建IOC容器
注册配置类
BeanFactory后置处理器
Bean的后置处理器
创建Bean对象
IOC容器的初始化流程
从：
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
进入：
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
refresh();
}
一：创建IOC容器
1.this（）：先执行父类的初始化方法，创建IOC容器
public GenericApplicationContext() {
this.beanFactory = new DefaultListableBeanFactory();
}
2.执行初始化方法创建BeanDefinition读取器和classPath下扫描器
public AnnotationConfigApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
3.this.reader = new AnnotatedBeanDefinitionReader(this)的创建过程：
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
this(registry, getOrCreateEnvironment(registry));
}
4.执行AnnotatedBeanDefinitionReader的构造器：重点在最后一行的注册注解配置处理器
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
Assert.notNull(environment, "Environment must not be null");
this.registry = registry;
this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); //注册注解配置处理器
}
5.1这个方法把下面对象注册到IOC容器里面
5.2ConfigurationClassPostProcessor对象注册的代码
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry); //创建IOC容器
....
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(4);
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) { //注册5.2ConfigurationClassPostProcessor对象到IOC容器中
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
6、执行this.scanner = new ClassPathBeanDefinitionScanner(this);
先走父类
public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters) {
this(useDefaultFilters, new StandardEnvironment());
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
this(registry, true);
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment) {
this(registry, useDefaultFilters, environment,
(registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment, @Nullable ResourceLoader resourceLoader) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
this.registry = registry;
if (useDefaultFilters) {
registerDefaultFilters();
}
setEnvironment(environment);
setResourceLoader(resourceLoader);
}
protected void registerDefaultFilters() {
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
try {
this.includeFilters.add(new AnnotationTypeFilter(
((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
}
try {
this.includeFilters.add(new AnnotationTypeFilter(
((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
registerDefaultFilters（）把加了@Component注解的的class对象添加到includeFilters列表
问题1：加了@Component注解的类是怎么注册到SpringIOC容器里面的？
二：注册配置类
1.register(annotatedClasses);把用户指定的类加载到IOC容器里面
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
refresh();
}
public void register(Class<?>... annotatedClasses) {
Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
this.reader.register(annotatedClasses);
}
2.进入上面创建的reader的注册方法里面
public void register(Class<?>... annotatedClasses) {
for (Class<?> annotatedClass : annotatedClasses) {
registerBean(annotatedClass);
}
}
public void registerBean(Class<?> annotatedClass) {
doRegisterBean(annotatedClass, null, null, null);
}
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);//创建BeanDefinition对象
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) { //处理 @Condition注解
return;
}
abd.setInstanceSupplier(instanceSupplier); //设置对象是单例模式还是多例模式，默认单例
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName()); //获取BeanName,设置的化就采用默认值，否则类名第一个字母小写
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd); //处理Lazy，primary等注解
.....
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);//判断对象是否需要代理，不需要直接返回，需要的化，重新创建BeanDefinition加入代理的信息
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry); //注册配置类到IOC容器
}
3、调用shouldSkip（）处理@Condition注解
public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) { //如果没有不是@Condition注解直接返回fasle
return false;
}
if (phase == null) { //下面递归调用本方法
if (metadata instanceof AnnotationMetadata &&
ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
}
return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
}
List<Condition> conditions = new ArrayList<>();
for (String[] conditionClasses : getConditionClasses(metadata)) { //phase不为空的时候，执行所有condition类的match方法。
for (String conditionClass : conditionClasses) {
Condition condition = getCondition(conditionClass, this.context.getClassLoader());
conditions.add(condition);
}
}
....
return false;
}
4、调用processCommonDefinitionAnnotations处理下面的的注解
static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
if (lazy != null) {
abd.setLazyInit(lazy.getBoolean("value"));
}
else if (abd.getMetadata() != metadata) {
lazy = attributesFor(abd.getMetadata(), Lazy.class);
if (lazy != null) {
abd.setLazyInit(lazy.getBoolean("value"));
}
}
if (metadata.isAnnotated(Primary.class.getName())) {
abd.setPrimary(true);
}
AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
if (dependsOn != null) {
abd.setDependsOn(dependsOn.getStringArray("value"));
}
if (abd instanceof AbstractBeanDefinition) {
AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
AnnotationAttributes role = attributesFor(metadata, Role.class);
if (role != null) {
absBd.setRole(role.getNumber("value").intValue());
}
AnnotationAttributes description = attributesFor(metadata, Description.class);
if (description != null) {
absBd.setDescription(description.getString("value"));
}
}
}
三、BeanFactory后置处理器 1、beanFactory后置处理器（以ConfigurationClassPostProcessor为例）
1.1、ConfigurationClassPostProcessor继承关系
1.2、接口说明
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}
public interface BeanFactoryPostProcessor {
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}
2、refresh()->invokeBeanFactoryPostProcessors方法执行beanFactory后置处理器
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
//2.1.1、执行IOC容器beanFactoryPostProcessors列表里面存在的BeanDefinitionRegistryPostProcessor处理器
//2.1.2、把实现了BeanDefinitionRegistryPostProcessor接口的对象放到registryPostProcessors列表
//2.1.3、把只实现BeanFactoryPostProcessor接口的放到regularPostProcessors
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
List<BeanDefinitionRegistryPostProcessor> 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);
}
}
//2.2、获取所有注册到IOC容器里面的BeanDefinitionRegistryPostProcessor对象的beanName
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
//2.3、按照一定的顺序执行postProcessBeanDefinitionRegistry方法，并且放到registryPostProcessors列表
List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
....
else {
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
//2.4、获取所有BeanFactoryPostProcessor对象并且执行postProcessBeanFactory方法
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
....
}
3、ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry方法
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
....
processConfigBeanDefinitions(registry);
}
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
//注册BeanDefinitions
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
}
四、注册Bean的后置处理器：registerBeanPostProcessors(beanFactory);
1、注册bean后置处理器到IOC并且创建对象
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
....
//根据实现的额接口不同，放入到不同的列表里面
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//创建Bean
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
....
....
}
五、创建Bean对象
1、refresh()->finishBeanFactoryInitialization()->preInstantiateSingletons()
// Instantiate all remaining (non-lazy-init) singletons. finishBeanFactoryInitialization(beanFactory);
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
....
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();
}
@Override
public void preInstantiateSingletons() throws BeansException {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Pre-instantiating singletons in " + this);
}
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);//是否创建对象
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {//是否是FactoryBean，是则调用getObject()方法
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) () ->
((SmartFactoryBean<?>) factory).isEagerInit(),
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
else {
getBean(beanName);
}
}
}
2、getBean(beanName)方法核心步骤
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
下面几个关键的方法需要分析下getSingleton，createBean 和 getObjectForBeanInstance
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
....
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);//从Bean的实例中获取对象
}
else {
....
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
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);
}
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);
}
....
}
....
return (T) bean;
}
getSingleton方法执行流程【缓存中获取单例bean】
bean的加载过程。单例bean在spring容器中只会被创建一次，后续再获取Bean直接从单例缓存中获取，当然这里也只是尝试加载，首先尝试从缓存中加载，然后再次尝试从singletonFactories中加载。
因为在创建单例bean 的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，spring创建bean的原则是不等bean创建完成就会将创建的bean的ObjectFactory提早曝光加入到缓存中，
一旦下一个bean创建时需要 依赖上一个Bean，则直接使用ObjectFactory。
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);//参数true设置标识允许早期依赖
}
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);//如果此bean正在加载，则不会处理后面逻辑
if (singletonObject == null && allowEarlyReference) {//当某些方法需要提前初始化的时候
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();//调用预先设定的getObject方法，创建bean
this.earlySingletonObjects.put(beanName, singletonObject);//记录在缓存中earlySingletonObjects和singletonFactories互斥
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
- singletonObjects:用于保存BeanName和创建Bean实例之间的关系，bean name->bean instance
- singletonFactories:用于保存BeanName和创建bean工厂之间的关系，bean name->ObjectFactory
- earlySingletonObjects:也是保存BeanName和创建Bean实例之间的关系，与singletonObjects不同在于，当一个单例bean被放到这里面后，那么当bean还在创建过程中，就可以通过getBean方法获取到了，其目的是为了检测循环引用。
- registeredSingletons：用来保存当前所有已注册的Bean
getObjectForBeanInstance方法执行流程
在getBean方法中，getObjectForBeanInstance是个高频率使用的方法，无论是从缓存中获取bean还是根据不同的scope策略加载bean。总之我们得到Bean的实例后要做的第一步就是调用这个方法来检测当前Bean是否是FactoryBean类型
如果是，那么需要调用该Bean对应 的FactoryBean实例中的getObject()作为返回值。
无论是从缓存中获取到Bean还是通过不同的scope策略加载的Bean都只是最原始的Bean状态，并不一定是我们想要的Bean。
举个例子：假如我们需要对工厂Bean进行处理，那么这里得到的是工厂Bean的初始状态，但是我们正真需要的是工厂Bean中定义的factory-method方法中返回的Bean，而getObjectForBeanInstance方法就是完成这个工作的。
下面来分析下getObjectForBeanInstance这个方法：
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// 如果指定的name是工厂相关（以&为前缀）且BeanInstance又不是FactoryBean类型则验证不通过
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
// 现在我们有了这个Bean实例，这个实例可能会是正常的Bean或者FactoryBean
// 如果是FactoryBean我们使用它创建实例，但是如果用户想要直接获取工厂实例而不是工厂的getObject方法对应的实例，那么传入的name应该加入前缀&
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
//加载FactoryBean
Object object = null;
if (mbd == null) {
//尝试从缓存中加载Bean
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// 到这块已经明确了beanInstance一定是FactoryBean类型
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
//是否是用户定义的而不是应用程序本身定义的
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
从上面代码来看，大多是些辅助代码以及一些功能性的判断，而正真的核心委托给getObjectFromFactoryBean，我们来看看这个方法：
这个方法里面只做了一件事情，就是返回的Bean如果是单例，那么就必须要保证全局唯一，同时也因为是单例的，所以不必重复创建，可以使用缓存来提高性能，
也就是说，以及加载过就要记录下来以便于下次复用，否则的化就直接获取了。
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
if (factory.isSingleton() && containsSingleton(beanName)) {//如果是单例模式
synchronized (getSingletonMutex()) {//锁住全局变量
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
object = doGetObjectFromFactoryBean(factory, beanName);
//缓存中获取bean
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
if (shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
}
this.factoryBeanObjectCache.put(beanName, object);
}
}
return object;
}
}
else {
Object object = doGetObjectFromFactoryBean(factory, beanName);//执行这个方法，会去调用getObject方法
if (shouldPostProcess) {
try {
object = postProcessObjectFromFactoryBean(object, beanName);//调用ObjectFactory的后处理器
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
下面看下：doGetObjectFromFactoryBean方法：
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 {
object = factory.getObject();//直接调用getObject方法
}
}
...
return object;
}
上面我们已经讲述了FactoryBean的调用方法，如果Bean声明为FactoryBean类型，则当提取Bean的时候取到的并不是FactoryBean而是FactoryBean中对应的getObject方法返回的Bean，
而doGetObjectFromFactoryBean正是实现了这个功能的。但是我们看到了上面的方法中除了调用object = factory.getObject()得到我们想要的结果后并没有直接返回，而是接下来又调用
postProcessObjectFromFactoryBean来做后置处理，我们进入这个后置处理方法，看看：
protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
return applyBeanPostProcessorsAfterInitialization(object, beanName);
}
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
对于后置处理器的使用，后续会讲解到，这里我们需要明确一点：在Spring中获取Bean的规则中有一条：尽可能保证所有的Bean初始化后都会调用注册的
BeanPostProcessor的postProcessAfterInitialization方法进行处理，在实际开发中大可以争对此特性设计自己的业务逻辑。
获取单例：
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
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);
}
如果缓存不存在已经加载的单例Bean，就需要从头开始Bean的加载过程，而Spring中使用了getSingleton的重载方法实现Bean的加载过程
进入getSingleton方法
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 + "'");
}
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
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;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
protected void beforeSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {//将当前需要创建的Bean记录在缓存中，这样可以对循环依赖进行检测
throw new BeanCurrentlyInCreationException(beanName);
}
}
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {//当Bean加载结束后需要移除缓存中对该Bean的正在加载状态的记录
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
返回处理结果
虽然我们已经从外部了解到了加载Bean的逻辑架构，但现在我们还并没有开始对Bean加载功能的探索，之前提到过，Bean的加载逻辑其实是在传入的ObjectFactory类型的参数singletonFactory中定义的，
我们反推参数的获取，得到如下的代码：
sharedInstance = getSingleton(beanName,new ObjectFactory<Object>() {
public Object getObject() throws BeansException{
try{
return createBean(beanName, mbd, args);
}catch(BeansException ex){
destroySingleton(beanName);
throw ex;
}
}
})
ObjectFactory的核心部分其实只是调用了createBean的方法，所以我们还需要到createBean方法中寻找真理！
准备创建Bean [createBean方法执行流程]
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
....
try {
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 @Nullable Object[] args)
throws BeanCreationException {
....
try {
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
.....
}
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);//执行aware接口相关方法
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);//Bean后置处理器的前置方法
}
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);//Bean后置处理器的后置方法
}
return wrappedBean;
}
此方法中最吸引我们的无疑是两个方法：applyBeanPostProcessorsBeforeInitialization以及applyBeanPostProcessorsAfterInitialization。这两个方法是实现非常简单，
无非是对后处理器中的所有 InstantiationAwareBeanPostProcessor类型的后置处理器BeanPostProcessor进行postProcessBeforeInitialization方法和postProcessAfterInitialization方法的调用
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
根据上面代码可知：Bean的实例化前调用，也就是将AbstractBeanDefinition转换为BeanWrapper前的处理。给子类一个修改BeanDefinition的机会，也就是说当程序经过这个方法后，
Bean可能已经不是我们认为的Bean了，而是经过代理后的Bean，可能是CGLIB生成的，也可能是通过其它技术生成的。后面会分析到。
到这里，结束创建单例的对象
SpringBean的生命周期总结
源码分析流程：
1、执行refresh（）刷新方法
2、finishBeanFactoryInitialization(beanFactory);
3、beanFactory.preInstantiateSingletons();
4、getBean(beanName)->doGetBean()->createBean()->doCreateBean()->createBeanInstance()初始化对象（默认情况下使用Java反射机制初始化对象，也可以通过CGLIB）
5、initializeBean（）
6、invokeAwareMethods（）判断是否有Aware接口依赖信息
7、applyBeanPostProcessorsBeforeInitialization（）执行前置处理
8、invokeInitMethods（）执行init()方法
8、applyBeanPostProcessorsAfterInitialization（）执行后置处理
本文参考：
书籍：Spring源码深度解析