关于java:一文搞定-Spring-Bean-的创建全过程

37次阅读

共计 33626 个字符，预计需要花费 85 分钟才能阅读完成。

1.1 Spring 测试环境搭建

Spring 模块概览，绿色是模块，Spring 中八大模块，彩色示意该模块蕴含的 jar 包（组件）。例如咱们想要用 IOC 容器，也就是绿色的 CoreContainer，咱们须要导入 Beans，Core,Context,SpEL（spring-expression）四个包。

Spring 模块概览

  • Test：测试相干
  • Core Container：IOC 容器
  • AOP：面向切面编程
  • Aspects：切面
  • Instrumenttation：跟 JDK 关联，个别不必
  • Messaging：音讯服务，个别不必
  • Data Access/Integration：数据拜访与集成（JDBC 拜访，Transaction 事务，ORM 对象关系映射，OXM 和 XML 映射个别不必，JMS 为 Java 音讯服务 Java-message-service 个别不必）
  • Web：Web 服务（WebSocket 网络通信协定，Servlet, Web，Portlet 个别不必）

最偷懒的形式，是间接导入 Spring-Framework。然而可能导入不必要的包，导致我的项目打包后比拟大

因为 Spring-Content 中的 ApplicationContent 是整个 IOC 的入口。咱们导入 Spring-context 包即可 

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.3.RELEASE</version>
</dependency>

咱们导入 spring-content 后，默认会导入该组件的依赖 jar，spring-content 底层的依赖能够看到，实际上咱们是导入了 Core Container 模块：

  <dependencies>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.2.3.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>5.2.3.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.2.3.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>5.2.3.RELEASE</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>

新建 Spring 配置文件 spring.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       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.xsd">

    <!-- 注册一个对象，spring 回主动创立这个对象 -->
    <!--
    一个 bean 标签就示意一个对象
    id: 这个对象的惟一标识
    class: 注册对象的齐全限定名
    -->
    <bean id="hello" class="com.xiaodai.service.Hello">
        <!-- 应用 property 标签给对象的属性赋值
        name: 示意属性的名称
        value：示意属性的值
        -->
        <property name="id" value="1"></property>
        <property name="name" value="zhangsan"></property>
        <property name="age" value="18"></property>
    </bean>
</beans>

编写测试类：

import com.xiaodai.service.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {public static void main(String[] args) {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Hello hello = applicationContext.getBean("hello", Hello.class);
        System.out.println(hello.getName());

    }

}

1.2 Debug 容器创立过程

从测试类的 new ClassPathXmlApplicationContext(“spring.xml”) 开始 debug，进入 ClassPathXmlApplicationContext，能够看到:

 public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
   throws BeansException {super(parent);
  // 设置配置文件门路
  setConfigLocations(configLocations);
  if (refresh) {
          // 外围步骤
   refresh();}
 }

加载配置文件后，进入 refresh() 办法，该办法是容器初始化的外围步骤。该办法蕴含十三个办法：

        @Override
 public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {
   // Prepare this context for refreshing.
   /** 
    * 筹备刷新，做一些最根本的筹备化工作
   **/
   prepareRefresh();

   // Tell the subclass to refresh the internal bean factory.
   /** 
    * 取得一个刷新的 bean 容器，本质就是获取工厂。* 加载 xml 等配置文件，用该文件产生的 BeanDefinition 来创立一个工厂
   **/
   ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

   // Prepare the bean factory for use in this context.
   /**
    * 筹备 bean 工厂
   **/
   prepareBeanFactory(beanFactory);

   try {
    // Allows post-processing of the bean factory in context subclasses.
    // 后置加强，不便扩大
    postProcessBeanFactory(beanFactory);

    // Invoke factory processors registered as beans in the context.
    // 实例化并且执行 BeanFactoryPostProcessors
    invokeBeanFactoryPostProcessors(beanFactory);

    // Register bean processors that intercept bean creation.
    // 实例化并且注册所有的 BeanPostProcessor
    registerBeanPostProcessors(beanFactory);

    // Initialize message source for this context.
    // 国际化设置，个别用不到
    initMessageSource();

    // Initialize event multicaster for this context.
    // 初始化应用程序的多波器和播送器
    initApplicationEventMulticaster();

    // Initialize other special beans in specific context subclasses.
    // 空办法，预留给子类做扩大
    onRefresh();

    // Check for listener beans and register them.
    // 注册监听器
    registerListeners();

    // Instantiate all remaining (non-lazy-init) singletons.
    // 工作中罕用，面试常问。实例化所有非懒加载的实例对象
    finishBeanFactoryInitialization(beanFactory);

    // Last step: publish corresponding event.
    // 实现刷新
    finishRefresh();}

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

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

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

    // Propagate exception to caller.
    throw ex;
   }

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

1.3 AbstractApplicationContext 的 refresh() 蕴含的 13 个办法剖析

联合概览图一个一个办法剖析：

Bean 工厂实例化 Bean 概览图

办法 1：prepareRefresh() => 筹备工作

筹备刷新，做一些最根本的筹备化工作 

 protected void prepareRefresh() {
  // Switch to active.
  // 设置开始工夫
  this.startupDate = System.currentTimeMillis();
  // 敞开状态设置为 false
  this.closed.set(false);
  // 沉闷状态设置为 true
  this.active.set(true);

        // 打印日志
  if (logger.isDebugEnabled()) {if (logger.isTraceEnabled()) {logger.trace("Refreshing" + this);
   }
   else {logger.debug("Refreshing" + getDisplayName());
   }
  }

  // Initialize any placeholder property sources in the context environment.
  // 初始化属性资源
  initPropertySources();

  // Validate that all properties marked as required are resolvable:
  // see ConfigurablePropertyResolver#setRequiredProperties
  // 获取环境信息，验证属性信息
  getEnvironment().validateRequiredProperties();

  // Store pre-refresh
  // 存储预刷新的一些利用信息的监听器
  ApplicationListeners...
  if (this.earlyApplicationListeners == null) {this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
  }
  else {
   // Reset local application listeners to pre-refresh state.
   this.applicationListeners.clear();
   this.applicationListeners.addAll(this.earlyApplicationListeners);
  }

  // Allow for the collection of early ApplicationEvents,
  // to be published once the multicaster is available...
  // 创立一些监听器事件的汇合
  this.earlyApplicationEvents = new LinkedHashSet<>();}

总结：1. 设置启动事件 2. 设置敞开沉闷的状态 3. 获取环境对象并设置属性值 4. 设置监听器以及须要公布事件的汇合

重要的点：

  • 获取环境信息，验证属性信息，getEnvironment().validateRequiredProperties();
  • 存储预刷新的一些利用信息的监听器，在 Spring 中是空实现，然而 SpringBoot 中，是有具体的值的

办法 2：obtainFreshBeanFactory() => 取得一个刷新的 bean 容器

取得一个刷新的 bean 容器，本质就是获取工厂。创立容器对象 DefaultListableBeanFactory; 加载 xml 配置文件的属性到以后的工厂中，最重要的就是 BeanDefinition

Bean 工厂实例继承关系图

AbstractRefreshableApplicationContext:

    // 只有进到这个办法，那么咱们创立的肯定是一个新的工厂
 @Override
 protected final void refreshBeanFactory() throws BeansException {if (hasBeanFactory()) {
      // 如果存在先销毁，后敞开
   destroyBeans();
   closeBeanFactory();}
  try {
      // 创立 bean 工厂，这里应用的就是 DefaultListableBeanFactory。此时创立的工厂外面的属性值都是默认值
   DefaultListableBeanFactory beanFactory = createBeanFactory();
   // 序列化 id
   beanFactory.setSerializationId(getId());
   // 设置一些属性值
   customizeBeanFactory(beanFactory);
   // 加载 bean 的定义属性值。该办法有很多重载，非常复杂，外围是 do 操作
   // 实现配置文件或者配置类文件的加载
   loadBeanDefinitions(beanFactory);
   synchronized (this.beanFactoryMonitor) {this.beanFactory = beanFactory;}
  }
  catch (IOException ex) {throw new ApplicationContextException("I/O error parsing bean definition source for" + getDisplayName(), ex);
  }
 }

办法 3：prepareBeanFactory(beanFactory) => 筹备（初始化）Bean 工厂

为办法 2 拿到的工厂，设置某些具体的值 

 protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  // Tell the internal bean factory to use the context's class loader etc.
  // 为 bean 工厂设置类加载器
  beanFactory.setBeanClassLoader(getClassLoader());
  // 设置 SPEL 解析器
  beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
  beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

  // Configure the bean factory with context callbacks.
  // 增加一个 BeanPostProcessor
  beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
  // 疏忽对应接口的实现
  beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
  beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
  beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
  beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
  beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
  beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

  // BeanFactory interface not registered as resolvable type in a plain factory.
  // MessageSource registered (and found for autowiring) as a bean.
        // 注册一些依赖
  beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
  beanFactory.registerResolvableDependency(ResourceLoader.class, this);
  beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
  beanFactory.registerResolvableDependency(ApplicationContext.class, this);

  // Register early post-processor for detecting inner beans as
  // ApplicationListeners 增加一个 BeanPostProcessor 增强器
  ApplicationListeners.
  beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

  // Detect a LoadTimeWeaver and prepare for weaving, if found.
  if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
   // Set a temporary ClassLoader for type matching.
   beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  }

  // Register default environment beans.
  if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
  }
  if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
  }
  if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
  }
 }

办法 4：postProcessBeanFactory(beanFactory) => 后置加强 Bean(扩大实现)

空办法，不便扩大

办法 5：invokeBeanFactoryPostProcessors(beanFactory) => 执行 BFPP

实例化并且执行 BeanFactoryPostProcessors

 /**
  * Instantiate and invoke all registered BeanFactoryPostProcessor beans,
  * respecting explicit order if given.
  * <p>Must be called before singleton instantiation.
  * 单例对象之前肯定调用，因为单例 bean 创立后就只有一份
  */
 protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

  // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
  // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
  if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
   beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  }
 }

办法 6：registerBeanPostProcessors(beanFactory) => 注册 BPP

实例化并且注册所有的 BeanPostProcessor。实例化 Bean 之前的筹备工作 

 /**
  * Instantiate and register all BeanPostProcessor beans,
  * respecting explicit order if given.
  * <p>Must be called before any instantiation of application beans.
  */
 protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
 }

办法 7：initMessageSource() => 国际化设置

办法 8：initApplicationEventMulticaster() => 初始化应用程序的多波器和播送器

也属于筹备工作

办法 9：onRefresh() => 预留给子类做扩大

空办法

办法 10：registerListeners() => 注册监听器

也属于筹备工作 

 /**
  * Add beans that implement ApplicationListener as listeners.
  * Doesn't affect other listeners, which can be added without being beans.
  */
 protected void registerListeners() {
  // Register statically specified listeners first.
  for (ApplicationListener<?> listener : getApplicationListeners()) {getApplicationEventMulticaster().addApplicationListener(listener);
  }

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

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

办法 11：finishBeanFactoryInitialization(beanFactory) => 实例化所有单例对象

面试常问，工作罕用。过程比较复杂 

 /**
  * Finish the initialization of this context's bean factory,
  * initializing all remaining singleton beans.
  */
 protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  // Initialize conversion service for this context.
  /**
   * 把类型转化操作，设置到以后的 beanFactory 外面去
  **/
  if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
    beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
   beanFactory.setConversionService(beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
  }

  // Register a default embedded value resolver if no bean post-processor
  // (such as a PropertyPlaceholderConfigurer bean) registered any before:
  // at this point, primarily for resolution in annotation attribute values.
  /**
   * 判断以后的 beanFactory 有没有内置的值处理器
  **/
  if (!beanFactory.hasEmbeddedValueResolver()) {beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
  }

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

  // Stop using the temporary ClassLoader for type matching.
  // 设置类加载器
  beanFactory.setTempClassLoader(null);

  // Allow for caching all bean definition metadata, not expecting further changes.
  /**
   * 解冻：某些 bean 不须要进行批改操作了，放入
  **/
  beanFactory.freezeConfiguration();

  // Instantiate all remaining (non-lazy-init) singletons.
  /**
   * 实例化所有非懒加载的实例对象 (重要)
  **/
  beanFactory.preInstantiateSingletons();}

实例化所有非懒加载的实例对象办法：

 @Override
 public void preInstantiateSingletons() throws BeansException {if (logger.isTraceEnabled()) {logger.trace("Pre-instantiating singletons in" + this);
  }

  // Iterate over a copy to allow for init methods which in turn register new bean definitions.
  // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  /**
   * 拿到所有注册 bean 的名称
   **/
  List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

  // Trigger initialization of all non-lazy singleton beans...
  // 循环去创立咱们须要的单例对象
  for (String beanName : beanNames) {
      // 拿到 bean 的定义信息，就是咱们在 xml 配置文件外面指定的一些属性
   RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
   // 是否是形象的，是否是单例的，是否是懒加载的
   if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
       // 判断以后类是否实现了 factoryBean 接口。个别没实现，间接进入上面的 getBean
    if (isFactoryBean(beanName)) {Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
     if (bean instanceof FactoryBean) {final FactoryBean<?> factory = (FactoryBean<?>) bean;
      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 {
        // 通过 beanName。拿到 bean
     getBean(beanName);
    }
   }
  }

  // Trigger post-initialization callback for all applicable beans...
  for (String beanName : beanNames) {Object singletonInstance = getSingleton(beanName);
   if (singletonInstance instanceof SmartInitializingSingleton) {final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
    if (System.getSecurityManager() != null) {AccessController.doPrivileged((PrivilegedAction<Object>) () -> {smartSingleton.afterSingletonsInstantiated();
      return null;
     }, getAccessControlContext());
    }
    else {smartSingleton.afterSingletonsInstantiated();
    }
   }
  }
 }

重要办法：

  • getMergedLocalBeanDefinition
 /**
  * Return a merged RootBeanDefinition, traversing the parent bean definition
  * if the specified bean corresponds to a child bean definition.
  * @param beanName the name of the bean to retrieve the merged definition for
  * @return a (potentially merged) RootBeanDefinition for the given bean
  * @throws NoSuchBeanDefinitionException if there is no bean with the given name
  * @throws BeanDefinitionStoreException in case of an invalid bean definition
  */
  // 返回一个合并好的 RootBeanDefinition。整合子类和父类
 protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
  // Quick check on the concurrent map first, with minimal locking.
  RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
  if (mbd != null && !mbd.stale) {return mbd;}
  return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
 }
  • getBean() => doGetBean()
 /**
  * Return an instance, which may be shared or independent, of the specified bean.
  * @param name the name of the bean to retrieve
  * @param requiredType the required type of the bean to retrieve
  * @param args arguments to use when creating a bean instance using explicit arguments
  * (only applied when creating a new instance as opposed to retrieving an existing one)
  * @param typeCheckOnly whether the instance is obtained for a type check,
  * not for actual use
  * @return an instance of the bean
  * @throws BeansException if the bean could not be created
  */
 @SuppressWarnings("unchecked")
 protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
   @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

        // 获取 beanName
  final String beanName = transformedBeanName(name);
  Object bean;

  // Eagerly check singleton cache for manually registered singletons.
  // 单例查看，如果一级，二级，三级缓存中存在该 Bean, 间接获取到了
  Object sharedInstance = getSingleton(beanName);
  if (sharedInstance != null && args == null) {if (logger.isTraceEnabled()) {if (isSingletonCurrentlyInCreation(beanName)) {
     logger.trace("Returning eagerly cached instance of singleton bean'" + beanName +
       "'that is not fully initialized yet - a consequence of a circular reference");
    }
    else {logger.trace("Returning cached instance of singleton bean'" + beanName + "'");
    }
   }
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  }

  else {
   // Fail if we're already creating this bean instance:
   // We're assumably within a circular reference.
   // 如果是单例对象的话，尝试解决循环依赖问题
   if (isPrototypeCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName);
   }

   // Check if bean definition exists in this factory.
   // 获取父类容器
   BeanFactory parentBeanFactory = getParentBeanFactory();
   if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    // Not found -> check parent.
    String nameToLookup = originalBeanName(name);
    if (parentBeanFactory instanceof AbstractBeanFactory) {return ((AbstractBeanFactory) parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
    }
    else if (args != null) {
     // Delegation to parent with explicit args.
     return (T) parentBeanFactory.getBean(nameToLookup, args);
    }
    else if (requiredType != null) {
     // No args -> delegate to standard getBean method.
     return parentBeanFactory.getBean(nameToLookup, requiredType);
    }
    else {return (T) parentBeanFactory.getBean(nameToLookup);
    }
   }

            // 标记位。如果不是类型查看，示意要创立 bean, 此处在汇合中做一个记录
   if (!typeCheckOnly) {markBeanAsCreated(beanName);
   }

   try {
       // 获取 beanDefinition
    final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    // 检测 beanDefinition
    checkMergedBeanDefinition(mbd, beanName, args);

    // Guarantee initialization of beans that the current bean depends on.
    // 查看以后的 bean 是否有其余依赖的 bean
    String[] dependsOn = mbd.getDependsOn();
    if (dependsOn != null) {
        // 如果有依赖的 bean, 咱们要先递归解决其余依赖的 bean
     for (String dep : dependsOn) {if (isDependent(beanName, dep)) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,
         "Circular depends-on relationship between'" + beanName + "'and'" + dep + "'");
      }
      registerDependentBean(dep, beanName);
      try {getBean(dep);
      }
      catch (NoSuchBeanDefinitionException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,
         "'"+ beanName +"' depends on missing bean '"+ dep +"'", ex);
      }
     }
    }

    // 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);
     }
     catch (IllegalStateException ex) {
      throw new BeanCreationException(beanName,
        "Scope'" + scopeName + "'is not active for the current thread; consider" +
        "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
        ex);
     }
    }
   }
   catch (BeansException ex) {cleanupAfterBeanCreationFailure(beanName);
    throw ex;
   }
  }

  // Check if required type matches the type of the actual bean instance.
  if (requiredType != null && !requiredType.isInstance(bean)) {
   try {T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
    if (convertedBean == null) {throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    }
    return convertedBean;
   }
   catch (TypeMismatchException ex) {if (logger.isTraceEnabled()) {
     logger.trace("Failed to convert bean'" + name + "'to required type'" +
       ClassUtils.getQualifiedName(requiredType) + "'", ex);
    }
    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
   }
  }
  return (T) bean;
 }
  • getSingleton
 /**
  * Return the (raw) singleton object registered under the given name,
  * creating and registering a new one if none registered yet.
  * @param beanName the name of the bean
  * @param singletonFactory the ObjectFactory to lazily create the singleton
  * with, if necessary
  * @return the registered singleton object
  */
 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 {
        // 实际上就是调用了 CreateBean
     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;
  }
 }
  • doCreateBean => 通过上办法的 singletonObject = singletonFactory.getObject(); 进入的 
 /**
  * Actually create the specified bean. Pre-creation processing has already happened
  * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
  * <p>Differentiates between default bean instantiation, use of a
  * factory method, and autowiring a constructor.
  * @param beanName the name of the bean
  * @param mbd the merged bean definition for the bean
  * @param args explicit arguments to use for constructor or factory method invocation
  * @return a new instance of the bean
  * @throws BeanCreationException if the bean could not be created
  * @see #instantiateBean
  * @see #instantiateUsingFactoryMethod
  * @see #autowireConstructor
  */
 protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
   throws BeanCreationException {

  // Instantiate the bean.
  BeanWrapper instanceWrapper = null;
  if (mbd.isSingleton()) {instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  }
  if (instanceWrapper == null) {
      /**
       * 外围的创立实例化 Bean 的过程
      **/
   instanceWrapper = createBeanInstance(beanName, mbd, args);
  }
  final Object bean = instanceWrapper.getWrappedInstance();
  Class<?> beanType = instanceWrapper.getWrappedClass();
  if (beanType != NullBean.class) {mbd.resolvedTargetType = beanType;}

  // Allow post-processors to modify the merged bean definition.
  synchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {
    try {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.
  boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    isSingletonCurrentlyInCreation(beanName));
    
  /**
   * 解决循环依赖。应用三级缓存
  **/
  if (earlySingletonExposure) {if (logger.isTraceEnabled()) {
    logger.trace("Eagerly caching bean'" + beanName +
      "'to allow for resolving potential circular references");
   }
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  }

  // Initialize the bean instance.
  Object exposedObject = bean;
  try {
      /**
       * 填充属性，上文的实例化只是默认属性值。填充属性是初始化的第一步，第二步是执行 init 办法
      **/
   populateBean(beanName, mbd, instanceWrapper);
   /**
    * 执行 init 办法
   **/
   exposedObject = initializeBean(beanName, exposedObject, mbd);
  }
  catch (Throwable ex) {if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {throw (BeanCreationException) ex;
   }
   else {
    throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
   }
  }

  if (earlySingletonExposure) {Object earlySingletonReference = getSingleton(beanName, false);
   if (earlySingletonReference != null) {if (exposedObject == bean) {exposedObject = earlySingletonReference;}
    else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {String[] dependentBeans = getDependentBeans(beanName);
     Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
     for (String dependentBean : dependentBeans) {if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {actualDependentBeans.add(dependentBean);
      }
     }
     if (!actualDependentBeans.isEmpty()) {
      throw new BeanCurrentlyInCreationException(beanName,
        "Bean with name'" + beanName + "'has been injected into other beans [" +
        StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
        "] in its raw version as part of a circular reference, but has eventually been" +
        "wrapped. This means that said other beans do not use the final version of the" +
        "bean. This is often the result of over-eager type matching - consider using" +
        "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
     }
    }
   }
  }

  // Register bean as disposable.
  try {
      /**
       * 须要销毁的时候，销毁的钩子函数
      **/
   registerDisposableBeanIfNecessary(beanName, bean, mbd);
  }
  catch (BeanDefinitionValidationException ex) {
   throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  }

  return exposedObject;
 }

面试题：为甚么循环依赖的解决要应用三级缓存？

  • createBeanInstance => 外围的创立和实例化 bean 的过程，由 doCreateBean 调用

大量的反射呈现在该办法中，用来创建对象 

 /**
  * Create a new instance for the specified bean, using an appropriate instantiation strategy:
  * factory method, constructor autowiring, or simple instantiation.
  * @param beanName the name of the bean
  * @param mbd the bean definition for the bean
  * @param args explicit arguments to use for constructor or factory method invocation
  * @return a BeanWrapper for the new instance
  * @see #obtainFromSupplier
  * @see #instantiateUsingFactoryMethod
  * @see #autowireConstructor
  * @see #instantiateBean
  */
 protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
  // Make sure bean class is actually resolved at this point.
  Class<?> beanClass = resolveBeanClass(mbd, beanName);

  if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,
     "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
  }

  Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
  if (instanceSupplier != null) {return obtainFromSupplier(instanceSupplier, beanName);
  }

  if (mbd.getFactoryMethodName() != null) {return instantiateUsingFactoryMethod(beanName, mbd, args);
  }

  // Shortcut when re-creating the same bean...
  boolean resolved = false;
  boolean autowireNecessary = false;
  if (args == null) {synchronized (mbd.constructorArgumentLock) {if (mbd.resolvedConstructorOrFactoryMethod != null) {
     resolved = true;
     autowireNecessary = mbd.constructorArgumentsResolved;
    }
   }
  }
  if (resolved) {if (autowireNecessary) {return autowireConstructor(beanName, mbd, null, null);
   }
   else {return instantiateBean(beanName, mbd);
   }
  }

  // Candidate constructors for autowiring?
  // 结构器
  Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
  if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
    mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {return autowireConstructor(beanName, mbd, ctors, args);
  }

  // Preferred constructors for default construction?
  ctors = mbd.getPreferredConstructors();
  if (ctors != null) {return autowireConstructor(beanName, mbd, ctors, null);
  }

  // No special handling: simply use no-arg constructor.
  /**
   * 默认无参结构
   **/
  return instantiateBean(beanName, mbd);
 }
  • instantiateBean(beanName, mbd) => 默认无参结构 
 /**
  * Instantiate the given bean using its default constructor.
  * @param beanName the name of the bean
  * @param mbd the bean definition for the bean
  * @return a BeanWrapper for the new instance
  */
 protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
  try {
   Object beanInstance;
   final BeanFactory parent = this;
   if (System.getSecurityManager() != null) {beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
            // 实例化只会分配内存空间，设置默认值
      getInstantiationStrategy().instantiate(mbd, beanName, parent),
      getAccessControlContext());
   }
   else {beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
   }
   BeanWrapper bw = new BeanWrapperImpl(beanInstance);
   initBeanWrapper(bw);
   return bw;
  }
  catch (Throwable ex) {
   throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
  }
 }
  • instantiate
 @Override
 public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
  // Don't override the class with CGLIB if no overrides.
  if (!bd.hasMethodOverrides()) {
   Constructor<?> constructorToUse;
   synchronized (bd.constructorArgumentLock) {constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
    if (constructorToUse == null) {final Class<?> clazz = bd.getBeanClass();
     if (clazz.isInterface()) {throw new BeanInstantiationException(clazz, "Specified class is an interface");
     }
     try {if (System.getSecurityManager() != null) {
       constructorToUse = AccessController.doPrivileged((PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
      }
      else {constructorToUse = clazz.getDeclaredConstructor();
      }
      bd.resolvedConstructorOrFactoryMethod = constructorToUse;
     }
     catch (Throwable ex) {throw new BeanInstantiationException(clazz, "No default constructor found", ex);
     }
    }
   }
   return BeanUtils.instantiateClass(constructorToUse);
  }
  else {
   // Must generate CGLIB subclass.
   return instantiateWithMethodInjection(bd, beanName, owner);
  }
 }
  • BeanUtils.instantiateClass => 通过结构器反射创立 bean
 /**
  * Convenience method to instantiate a class using the given constructor.
  * <p>Note that this method tries to set the constructor accessible if given a
  * non-accessible (that is, non-public) constructor, and supports Kotlin classes
  * with optional parameters and default values.
  * @param ctor the constructor to instantiate
  * @param args the constructor arguments to apply (use {@code null} for an unspecified
  * parameter, Kotlin optional parameters and Java primitive types are supported)
  * @return the new instance
  * @throws BeanInstantiationException if the bean cannot be instantiated
  * @see Constructor#newInstance
  */
 public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {Assert.notNull(ctor, "Constructor must not be null");
  try {ReflectionUtils.makeAccessible(ctor);
   if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {return KotlinDelegate.instantiateClass(ctor, args);
   }
   else {Class<?>[] parameterTypes = ctor.getParameterTypes();
    Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
    Object[] argsWithDefaultValues = new Object[args.length];
    for (int i = 0 ; i < args.length; i++) {if (args[i] == null) {Class<?> parameterType = parameterTypes[i];
      argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
     }
     else {argsWithDefaultValues[i] = args[i];
     }
    }
    return ctor.newInstance(argsWithDefaultValues);
   }
  }
  catch (InstantiationException ex) {throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
  }
  catch (IllegalAccessException ex) {throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
  }
  catch (IllegalArgumentException ex) {throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
  }
  catch (InvocationTargetException ex) {throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
  }
 }

办法 12：finishRefresh() => 实现刷新 

 /**
  * Finish the refresh of this context, invoking the LifecycleProcessor's
  * onRefresh() method and publishing the
  * {@link org.springframework.context.event.ContextRefreshedEvent}.
  */
 protected void finishRefresh() {// Clear context-level resource caches (such as ASM metadata from scanning).
  // 
  clearResourceCaches();

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

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

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

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

办法 13：resetCommonCaches() => 缓存重置 

 /**
  * Reset Spring's common reflection metadata caches, in particular the
  * {@link ReflectionUtils}, {@link AnnotationUtils}, {@link ResolvableType}
  * and {@link CachedIntrospectionResults} caches.
  * @since 4.2
  * @see ReflectionUtils#clearCache()
  * @see AnnotationUtils#clearCache()
  * @see ResolvableType#clearCache()
  * @see CachedIntrospectionResults#clearClassLoader(ClassLoader)
  */
 protected void resetCommonCaches() {ReflectionUtils.clearCache();
  AnnotationUtils.clearCache();
  ResolvableType.clearCache();
  CachedIntrospectionResults.clearClassLoader(getClassLoader());
 }

最初回顾整个流程概览图：

Bean 工厂实例化 Bean 概览图

作者：x1aoda1

起源：www.cnblogs.com/darope/p/13917264.html

近期热文举荐：

1.600+ 道 Java 面试题及答案整顿 (2021 最新版)

2. 终于靠开源我的项目弄到 IntelliJ IDEA 激活码了，真香！

3. 阿里 Mock 工具正式开源，干掉市面上所有 Mock 工具！

4.Spring Cloud 2020.0.0 正式公布，全新颠覆性版本！

5.《Java 开发手册（嵩山版）》最新公布，速速下载！

感觉不错，别忘了顺手点赞 + 转发哦！

正文完
java
发表至： java
2021-04-02
 0
白话CMPPSGIP
关于java:说说软件为什么要分层
面试被问分布式事务2PC3PCTCC这样解释没毛病
关于java:30个类手写Spring核心原理之AOP代码织入5