Spring5.0源码深度解析之Spring基于注解启动流程分析

时间 2019-11-13

标签 spring5.0 spring 源码深度解析基于注解启动流程分析栏目 Spring 繁體版

原文原文链接

主要内容：

1、IOC容器的初始化流java

建立IOC容器spring

注册配置类缓存

BeanFactory后置处理器架构

Bean的后置处理器app

建立Bean对象ide

IOC容器的初始化流程

从：源码分析

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);

进入：post

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
   this();
   register(annotatedClasses);
   refresh();
}

一：建立IOC容器

1.this（）：先执行父类的初始化方法，建立IOC容器性能

public GenericApplicationContext() {
   this.beanFactory = new DefaultListableBeanFactory();
}

2.执行初始化方法建立BeanDefinition读取器和classPath下扫描器ui

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

六、执行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容器
}

三、调用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;
}

四、调用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"));
      }
   }
}

3、BeanFactory后置处理器一、beanFactory后置处理器（以ConfigurationClassPostProcessor为例）

1.一、ConfigurationClassPostProcessor继承关系

1.二、接口说明

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
   void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}

public interface BeanFactoryPostProcessor {
   void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}

二、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.一、执行IOC容器beanFactoryPostProcessors列表里面存在的BeanDefinitionRegistryPostProcessor处理器
   //2.1.二、把实现了BeanDefinitionRegistryPostProcessor接口的对象放到registryPostProcessors列表
   //2.1.三、把只实现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.二、获取全部注册到IOC容器里面的BeanDefinitionRegistryPostProcessor对象的beanName
      String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      //2.三、按照必定的顺序执行postProcessBeanDefinitionRegistry方法，而且放到registryPostProcessors列表
      List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    ....

   else {
      invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
   }
    //2.四、获取全部BeanFactoryPostProcessor对象而且执行postProcessBeanFactory方法
   String[] postProcessorNames =
         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
  ....
}

三、ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry方法

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    ....
   processConfigBeanDefinitions(registry);
}

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
      //注册BeanDefinitions
      this.reader.loadBeanDefinitions(configClasses);
      alreadyParsed.addAll(configClasses);
}

4、注册Bean的后置处理器：registerBeanPostProcessors(beanFactory);

一、注册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);
....

....
}

5、建立Bean对象

一、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);
         }
      }
   }

二、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的生命周期总结

源码分析流程：

一、执行refresh（）刷新方法

二、finishBeanFactoryInitialization(beanFactory);

三、beanFactory.preInstantiateSingletons();

四、getBean(beanName)->doGetBean()->createBean()->doCreateBean()->createBeanInstance()初始化对象（默认状况下使用Java反射机制初始化对象，也能够经过CGLIB）

五、initializeBean（）

六、invokeAwareMethods（）判断是否有Aware接口依赖信息

七、applyBeanPostProcessorsBeforeInitialization（）执行前置处理

八、invokeInitMethods（）执行init()方法

八、applyBeanPostProcessorsAfterInitialization（）执行后置处理

本文参考：

书籍：Spring源码深度解析

蚂蚁课堂：http://www.mayikt.com/