SpringBoot 注解 @Value 实现源码分析

我就是我 2023-10-02 11:56 87阅读 0赞

文章目录

  • 前言
    1. @Value 的源码处理流程
    1. 源码分析
      • 2.1 后置处理器 AutowiredAnnotationBeanPostProcessor 的注册
      • 2.2 属性处理器 PropertySourcesPropertyResolver 的注册
      • 2.3 @Value 标注字段的依赖处理

前言

SpringBoot 提供了很多开箱即用的实用工具，比如我们可以使用 @Value 注解获取容器中的配置数据，自动完成属性的赋值，本文即从源码角度来解析 @Value 的实现机制

1. @Value 的源码处理流程

@Value 实现属性注入的源码流程如下图所示，笔者将其从组件的准备到组件的使用分为了三个部分：

  1. @Value 后置处理器 AutowiredAnnotationBeanPostProcessor 的注册，这个后置处理器主要用于识别获取 @Value 中配置的属性字符串
  2. @Value 属性值来源处理器 PropertySourcesPropertyResolver 的注册，该处理器负责从容器中取得指定的属性值
  3. 创建 Bean 对象时，容器使用以上两个组件对 @Value 标注的属性进行依赖注入

在这里插入图片描述

2. 源码分析

2.1 后置处理器 AutowiredAnnotationBeanPostProcessor 的注册

  1. 在 SpringBoot 注解 @Import 的原理-ConfigurationClassPostProcessor 源码解析 中，笔者分析了 SpringBoot 的基础注解 @Import 功能实现依赖的核心组件 ConfigurationClassPostProcessor 的注册，本文 @Value 依赖的组件 AutowiredAnnotationBeanPostProcessor 的注册流程与其基本一致，都是从 SpringApplication#prepareContext() 方法触发，一直调用到 AnnotationConfigUtils#registerAnnotationConfigProcessors() 方法

    AnnotationConfigUtils#registerAnnotationConfigProcessors() 负责解析注册比较重要的后置处理器，本文主要关注以下几个步骤：

    1. 新建 ContextAnnotationAutowireCandidateResolver 处理器，并通过beanFactory.setAutowireCandidateResolver() 调用 DefaultListableBeanFactory#setAutowireCandidateResolver() 方法将其缓存到容器内，后续将使用它来获取 @Value 注解中配置的字符串
    2. 将 AutowiredAnnotationBeanPostProcessor 包装为 BeanDefinition 并注册，这个 Bean 后置处理器将用于处理 Bean 的内部属性依赖
    1. public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
    2.          BeanDefinitionRegistry registry, @Nullable Object source) {
  1.          DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
  2.          if (beanFactory != null) {
  4.              if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
  6.                  beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
  7.              }
  8.              if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
  10.                  beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
  11.              }
  12.          }
  14.          Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
  16.          if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  18.              RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
  19.              def.setSource(source);
  20.              beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
  21.          }
  23.          if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  25.              RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
  26.              def.setSource(source);
  27.              beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
  28.          }
  30.          // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
  31.          if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  33.              RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
  34.              def.setSource(source);
  35.              beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
  36.          }
  38.          // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
  39.          if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  41.              RootBeanDefinition def = new RootBeanDefinition();
  42.              try {
  44.                  def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
  45.                          AnnotationConfigUtils.class.getClassLoader()));
  46.              }
  47.              catch (ClassNotFoundException ex) {
  49.                  throw new IllegalStateException(
  50.                          "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
  51.              }
  52.              def.setSource(source);
  53.              beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
  54.          }
  56.          if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
  58.              RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
  59.              def.setSource(source);
  60.              beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
  61.          }
  63.          if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
  65.              RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
  66.              def.setSource(source);
  67.              beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
  68.          }
  70.          return beanDefs;
  71.      }

  1. DefaultListableBeanFactory#setAutowireCandidateResolver() 方的处理很简单，可以看到就是一个赋值操作，将新建的 AutowireCandidateResolver 子类 ContextAnnotationAutowireCandidateResolver 对象保存在内部

    1. public void setAutowireCandidateResolver(final AutowireCandidateResolver autowireCandidateResolver) {
    3.      Assert.notNull(autowireCandidateResolver, "AutowireCandidateResolver must not be null");
    4.      if (autowireCandidateResolver instanceof BeanFactoryAware) {
    6.          if (System.getSecurityManager() != null) {
    8.              AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
    10.                  ((BeanFactoryAware) autowireCandidateResolver).setBeanFactory(DefaultListableBeanFactory.this);
    11.                  return null;
    12.              }, getAccessControlContext());
    13.          }
    14.          else {
    16.              ((BeanFactoryAware) autowireCandidateResolver).setBeanFactory(this);
    17.          }
    18.      }
    19.      this.autowireCandidateResolver = autowireCandidateResolver;
    20.  }

2.2 属性处理器 PropertySourcesPropertyResolver 的注册

  1. 在 SpringBoot 自动配置原理源码分析 中笔者分析了自动配置的实现原理，则可以知道自动配置类PropertyPlaceholderAutoConfiguration 中的 @Bean 标注的方法将被触发，用于创建对应的配置类对象 PropertySourcesPlaceholderConfigurer

    1. @Configuration(proxyBeanMethods = false)
    2. @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
    3. public class PropertyPlaceholderAutoConfiguration {
  1.      @Bean
  2.      @ConditionalOnMissingBean(search = SearchStrategy.CURRENT)
  3.      public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer() {
  5.          return new PropertySourcesPlaceholderConfigurer();
  6.      }
  8.     }

  1. PropertySourcesPlaceholderConfigurer 实现了 BeanFactoryPostProcessor 接口，则当容器刷新时创建 Bean 工厂后会被用于对 Bean 工厂进行后置处理，触发 PropertySourcesPlaceholderConfigurer#postProcessBeanFactory() 方法，该方法比较重要的处理如下：

    1. 初始化属性来源列表 propertySources，可以看到此处会将 Environment 作为属性值来源
    2. 新建封装了属性来源列表 propertySources 的 PropertySourcesPropertyResolver 对象，该对象主要负责从属性源中获取指定的属性值
    3. 调用 PropertySourcesPlaceholderConfigurer#processProperties() 方法将 PropertySourcesPropertyResolver 对象入参，进行下一步配置
    1. public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    3.      if (this.propertySources == null) {
    5.          this.propertySources = new MutablePropertySources();
    6.          if (this.environment != null) {
    8.              this.propertySources.addLast(
    9.                  new PropertySource<Environment>(ENVIRONMENT_PROPERTIES_PROPERTY_SOURCE_NAME, this.environment) {
    11.                      @Override
    12.                      @Nullable
    13.                      public String getProperty(String key) {
    15.                          return this.source.getProperty(key);
    16.                      }
    17.                  }
    18.              );
    19.          }
    20.          try {
    22.              PropertySource<?> localPropertySource =
    23.                      new PropertiesPropertySource(LOCAL_PROPERTIES_PROPERTY_SOURCE_NAME, mergeProperties());
    24.              if (this.localOverride) {
    26.                  this.propertySources.addFirst(localPropertySource);
    27.              }
    28.              else {
    30.                  this.propertySources.addLast(localPropertySource);
    31.              }
    32.          }
    33.          catch (IOException ex) {
    35.              throw new BeanInitializationException("Could not load properties", ex);
    36.          }
    37.      }
    39.      processProperties(beanFactory, new PropertySourcesPropertyResolver(this.propertySources));
    40.      this.appliedPropertySources = this.propertySources;
    41.  }

  2. PropertySourcesPlaceholderConfigurer#processProperties() 方法的重要处理如下：

    1. 通过 propertyResolver.setPlaceholderPrefix() 等方法调用，为 PropertySourcesPropertyResolver 对象设置属性解析的前后缀为 ${}，分隔符为 :
    2. 使用 lambda 表达式 作为 StringValueResolver 的实现，随后调用父类 PlaceholderConfigurerSupport#doProcessProperties() 方法
    1. protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess,
    2.          final ConfigurablePropertyResolver propertyResolver) throws BeansException {
  1.          propertyResolver.setPlaceholderPrefix(this.placeholderPrefix);
  2.          propertyResolver.setPlaceholderSuffix(this.placeholderSuffix);
  3.          propertyResolver.setValueSeparator(this.valueSeparator);
  5.          StringValueResolver valueResolver = strVal -> {
  7.              String resolved = (this.ignoreUnresolvablePlaceholders ?
  8.                      propertyResolver.resolvePlaceholders(strVal) :
  9.                      propertyResolver.resolveRequiredPlaceholders(strVal));
  10.              if (this.trimValues) {
  12.                  resolved = resolved.trim();
  13.              }
  14.              return (resolved.equals(this.nullValue) ? null : resolved);
  15.          };
  17.          doProcessProperties(beanFactoryToProcess, valueResolver);
  18.      }

  1. PlaceholderConfigurerSupport#doProcessProperties() 方法中，本文主要关注beanFactoryToProcess.addEmbeddedValueResolver() 调用。这个处理实际调用到AbstractBeanFactory#addEmbeddedValueResolver() 方法，会将上一步骤构造的 lambda 表达式作为 StringValueResolver 的实例保存在 Bean 工厂内部

    1. protected void doProcessProperties(ConfigurableListableBeanFactory beanFactoryToProcess,
    2.          StringValueResolver valueResolver) {
  1.          BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver);
  3.          String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames();
  4.          for (String curName : beanNames) {
  6.              // Check that we're not parsing our own bean definition,
  7.              // to avoid failing on unresolvable placeholders in properties file locations.
  8.              if (!(curName.equals(this.beanName) && beanFactoryToProcess.equals(this.beanFactory))) {
  10.                  BeanDefinition bd = beanFactoryToProcess.getBeanDefinition(curName);
  11.                  try {
  13.                      visitor.visitBeanDefinition(bd);
  14.                  }
  15.                  catch (Exception ex) {
  17.                      throw new BeanDefinitionStoreException(bd.getResourceDescription(), curName, ex.getMessage(), ex);
  18.                  }
  19.              }
  20.          }
  22.          // New in Spring 2.5: resolve placeholders in alias target names and aliases as well.
  23.          beanFactoryToProcess.resolveAliases(valueResolver);
  25.          // New in Spring 3.0: resolve placeholders in embedded values such as annotation attributes.
  26.          beanFactoryToProcess.addEmbeddedValueResolver(valueResolver);
  27.      }

  1. AbstractBeanFactory#addEmbeddedValueResolver() 方法的实现如下，可以看到只是个内部缓存动作，至此解析由 ${} 包裹的属性的属性处理器已经注册到容器内部

    1. @Override
    2.  public void addEmbeddedValueResolver(StringValueResolver valueResolver) {
    4.      Assert.notNull(valueResolver, "StringValueResolver must not be null");
    5.      this.embeddedValueResolvers.add(valueResolver);
    6.  }

2.3 @Value 标注字段的依赖处理

  1. 容器刷新过程中会触发创建 Bean 对象，这个流程必然调用到 DefaultListableBeanFactory#createBean() 方法，而这个方法由其父类方法AbstractAutowireCapableBeanFactory#createBean() 实现，可以看到以下调用中最终将触发执行 AbstractAutowireCapableBeanFactory#doCreateBean() 方法

    1. @Override
    2.  @SuppressWarnings("unchecked")
    3.  public <T> T createBean(Class<T> beanClass) throws BeansException {
    5.      // Use prototype bean definition, to avoid registering bean as dependent bean.
    6.      RootBeanDefinition bd = new RootBeanDefinition(beanClass);
    7.      bd.setScope(SCOPE_PROTOTYPE);
    8.      bd.allowCaching = ClassUtils.isCacheSafe(beanClass, getBeanClassLoader());
    9.      return (T) createBean(beanClass.getName(), bd, null);
    10.  }
    12.  @Override
    13.  protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    14.          throws BeanCreationException {
  1.          if (logger.isTraceEnabled()) {
  3.              logger.trace("Creating instance of bean '" + beanName + "'");
  4.          }
  5.          RootBeanDefinition mbdToUse = mbd;
  7.          // Make sure bean class is actually resolved at this point, and
  8.          // clone the bean definition in case of a dynamically resolved Class
  9.          // which cannot be stored in the shared merged bean definition.
  10.          Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
  11.          if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
  13.              mbdToUse = new RootBeanDefinition(mbd);
  14.              mbdToUse.setBeanClass(resolvedClass);
  15.          }
  17.          // Prepare method overrides.
  18.          try {
  20.              mbdToUse.prepareMethodOverrides();
  21.          }
  22.          catch (BeanDefinitionValidationException ex) {
  24.              throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
  25.                      beanName, "Validation of method overrides failed", ex);
  26.          }
  28.          try {
  30.              // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  31.              Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  32.              if (bean != null) {
  34.                  return bean;
  35.              }
  36.          }
  37.          catch (Throwable ex) {
  39.              throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
  40.                      "BeanPostProcessor before instantiation of bean failed", ex);
  41.          }
  43.          try {
  45.              Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  46.              if (logger.isTraceEnabled()) {
  48.                  logger.trace("Finished creating instance of bean '" + beanName + "'");
  49.              }
  50.              return beanInstance;
  51.          }
  52.          catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
  54.              // A previously detected exception with proper bean creation context already,
  55.              // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
  56.              throw ex;
  57.          }
  58.          catch (Throwable ex) {
  60.              throw new BeanCreationException(
  61.                      mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
  62.          }
  63.      }

  1. AbstractAutowireCapableBeanFactory#doCreateBean() 方法比较长，核心为以下两步：

    1. 调用 AbstractAutowireCapableBeanFactory#createBeanInstance() 方法创建属性空白的 Bean 实例
    2. 调用 AbstractAutowireCapableBeanFactory#populateBean() 方法为 Bean 实例填充属性
    1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    2.          throws BeanCreationException {
  1.          // Instantiate the bean.
  2.          BeanWrapper instanceWrapper = null;
  3.          if (mbd.isSingleton()) {
  5.              instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  6.          }
  7.          if (instanceWrapper == null) {
  9.              instanceWrapper = createBeanInstance(beanName, mbd, args);
  10.          }
  11.          final Object bean = instanceWrapper.getWrappedInstance();
  12.          Class<?> beanType = instanceWrapper.getWrappedClass();
  13.          if (beanType != NullBean.class) {
  15.              mbd.resolvedTargetType = beanType;
  16.          }
  18.          // Allow post-processors to modify the merged bean definition.
  19.          synchronized (mbd.postProcessingLock) {
  21.              if (!mbd.postProcessed) {
  23.                  try {
  25.                      applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  26.                  }
  27.                  catch (Throwable ex) {
  29.                      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  30.                              "Post-processing of merged bean definition failed", ex);
  31.                  }
  32.                  mbd.postProcessed = true;
  33.              }
  34.          }
  36.          // Eagerly cache singletons to be able to resolve circular references
  37.          // even when triggered by lifecycle interfaces like BeanFactoryAware.
  38.          boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  39.                  isSingletonCurrentlyInCreation(beanName));
  40.          if (earlySingletonExposure) {
  42.              if (logger.isTraceEnabled()) {
  44.                  logger.trace("Eagerly caching bean '" + beanName +
  45.                          "' to allow for resolving potential circular references");
  46.              }
  47.              addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  48.          }
  50.          // Initialize the bean instance.
  51.          Object exposedObject = bean;
  52.          try {
  54.              populateBean(beanName, mbd, instanceWrapper);
  55.              exposedObject = initializeBean(beanName, exposedObject, mbd);
  56.          }
  57.          catch (Throwable ex) {
  59.              if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
  61.                  throw (BeanCreationException) ex;
  62.              }
  63.              else {
  65.                  throw new BeanCreationException(
  66.                          mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
  67.              }
  68.          }
  70.          if (earlySingletonExposure) {
  72.              Object earlySingletonReference = getSingleton(beanName, false);
  73.              if (earlySingletonReference != null) {
  75.                  if (exposedObject == bean) {
  77.                      exposedObject = earlySingletonReference;
  78.                  }
  79.                  else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
  81.                      String[] dependentBeans = getDependentBeans(beanName);
  82.                      Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
  83.                      for (String dependentBean : dependentBeans) {
  85.                          if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
  87.                              actualDependentBeans.add(dependentBean);
  88.                          }
  89.                      }
  90.                      if (!actualDependentBeans.isEmpty()) {
  92.                          throw new BeanCurrentlyInCreationException(beanName,
  93.                                  "Bean with name '" + beanName + "' has been injected into other beans [" +
  94.                                  StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
  95.                                  "] in its raw version as part of a circular reference, but has eventually been " +
  96.                                  "wrapped. This means that said other beans do not use the final version of the " +
  97.                                  "bean. This is often the result of over-eager type matching - consider using " +
  98.                                  "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
  99.                      }
  100.                  }
  101.              }
  102.          }
  104.          // Register bean as disposable.
  105.          try {
  107.              registerDisposableBeanIfNecessary(beanName, bean, mbd);
  108.          }
  109.          catch (BeanDefinitionValidationException ex) {
  111.              throw new BeanCreationException(
  112.                      mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  113.          }
  115.          return exposedObject;
  116.      }

  1. AbstractAutowireCapableBeanFactory#populateBean() 方法内容比较多，本文重点关注其使用 InstantiationAwareBeanPostProcessor 后置处理器处理 Bean 属性的逻辑

    1. protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    3.      if (bw == null) {
    5.          if (mbd.hasPropertyValues()) {
    7.              throw new BeanCreationException(
    8.                      mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
    9.          }
    10.          else {
    12.              // Skip property population phase for null instance.
    13.              return;
    14.          }
    15.      }
    17.      // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
    18.      // state of the bean before properties are set. This can be used, for example,
    19.      // to support styles of field injection.
    20.      if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    22.          for (BeanPostProcessor bp : getBeanPostProcessors()) {
    24.              if (bp instanceof InstantiationAwareBeanPostProcessor) {
    26.                  InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    27.                  if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
    29.                      return;
    30.                  }
    31.              }
    32.          }
    33.      }
    35.      PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
    37.      int resolvedAutowireMode = mbd.getResolvedAutowireMode();
    38.      if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
    40.          MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
    41.          // Add property values based on autowire by name if applicable.
    42.          if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
    44.              autowireByName(beanName, mbd, bw, newPvs);
    45.          }
    46.          // Add property values based on autowire by type if applicable.
    47.          if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
    49.              autowireByType(beanName, mbd, bw, newPvs);
    50.          }
    51.          pvs = newPvs;
    52.      }
    54.      boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    55.      boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
    57.      PropertyDescriptor[] filteredPds = null;
    58.      if (hasInstAwareBpps) {
    60.          if (pvs == null) {
    62.              pvs = mbd.getPropertyValues();
    63.          }
    64.          for (BeanPostProcessor bp : getBeanPostProcessors()) {
    66.              if (bp instanceof InstantiationAwareBeanPostProcessor) {
    68.                  InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    69.                  PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
    70.                  if (pvsToUse == null) {
    72.                      if (filteredPds == null) {
    74.                          filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
    75.                      }
    76.                      pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
    77.                      if (pvsToUse == null) {
    79.                          return;
    80.                      }
    81.                  }
    82.                  pvs = pvsToUse;
    83.              }
    84.          }
    85.      }
    86.      if (needsDepCheck) {
    88.          if (filteredPds == null) {
    90.              filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
    91.          }
    92.          checkDependencies(beanName, mbd, filteredPds, pvs);
    93.      }
    95.      if (pvs != null) {
    97.          applyPropertyValues(beanName, mbd, bw, pvs);
    98.      }
    99.  }

  2. 在2.1节中注册的 AutowiredAnnotationBeanPostProcessor 就实现了 InstantiationAwareBeanPostProcessor 接口，则此处 AutowiredAnnotationBeanPostProcessor#postProcessProperties() 将被触发调用，可以看到此处的关键处理有两步：

    1. 调用 AutowiredAnnotationBeanPostProcessor#findAutowiringMetadata() 方法创建注入元数据对象 InjectionMetadata
    2. 调用 InjectionMetadata#inject() 方法进行数据注入
    1. public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    3.      InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    4.      try {
    6.          metadata.inject(bean, beanName, pvs);
    7.      }
    8.      catch (BeanCreationException ex) {
    10.          throw ex;
    11.      }
    12.      catch (Throwable ex) {
    14.          throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
    15.      }
    16.      return pvs;
    17.  }

  3. AutowiredAnnotationBeanPostProcessor#findAutowiringMetadata() 的处理是，先从缓存中获取 InjectionMetadata 对象，获取不到则调用 AutowiredAnnotationBeanPostProcessor#buildAutowiringMetadata() 构建

    1. private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
    3.      // Fall back to class name as cache key, for backwards compatibility with custom callers.
    4.      String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
    5.      // Quick check on the concurrent map first, with minimal locking.
    6.      InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
    7.      if (InjectionMetadata.needsRefresh(metadata, clazz)) {
    9.          synchronized (this.injectionMetadataCache) {
    11.              metadata = this.injectionMetadataCache.get(cacheKey);
    12.              if (InjectionMetadata.needsRefresh(metadata, clazz)) {
    14.                  if (metadata != null) {
    16.                      metadata.clear(pvs);
    17.                  }
    18.                  metadata = buildAutowiringMetadata(clazz);
    19.                  this.injectionMetadataCache.put(cacheKey, metadata);
    20.              }
    21.          }
    22.      }
    23.      return metadata;
    24.  }

  4. AutowiredAnnotationBeanPostProcessor#buildAutowiringMetadata() 方法实现如下，可以看到这里会将目标类定义的字段 Field 和 方法 Method 分别处理。具体逻辑是通过 AutowiredAnnotationBeanPostProcessor#findAutowiredAnnotation() 方法获取字段或者方法上标注的特定注解，如果能获取到说明需要处理依赖注入，则生成对应的 InjectedElement 实例，代表一个需要处理注入的元素

    1. private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
    3.     if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
    5.         return InjectionMetadata.EMPTY;
    6.     }
    8.     List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
    9.     Class<?> targetClass = clazz;
    11.     do {
    13.         final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
    15.         ReflectionUtils.doWithLocalFields(targetClass, field -> {
    17.             MergedAnnotation<?> ann = findAutowiredAnnotation(field);
    18.             if (ann != null) {
    20.                 if (Modifier.isStatic(field.getModifiers())) {
    22.                     if (logger.isInfoEnabled()) {
    24.                         logger.info("Autowired annotation is not supported on static fields: " + field);
    25.                     }
    26.                     return;
    27.                 }
    28.                 boolean required = determineRequiredStatus(ann);
    29.                 currElements.add(new AutowiredFieldElement(field, required));
    30.             }
    31.         });
    33.         ReflectionUtils.doWithLocalMethods(targetClass, method -> {
    35.             Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
    36.             if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
    38.                 return;
    39.             }
    40.             MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
    41.             if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
    43.                 if (Modifier.isStatic(method.getModifiers())) {
    45.                     if (logger.isInfoEnabled()) {
    47.                         logger.info("Autowired annotation is not supported on static methods: " + method);
    48.                     }
    49.                     return;
    50.                 }
    51.                 if (method.getParameterCount() == 0) {
    53.                     if (logger.isInfoEnabled()) {
    55.                         logger.info("Autowired annotation should only be used on methods with parameters: " +
    56.                                 method);
    57.                     }
    58.                 }
    59.                 boolean required = determineRequiredStatus(ann);
    60.                 PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
    61.                 currElements.add(new AutowiredMethodElement(method, required, pd));
    62.             }
    63.         });
    65.         elements.addAll(0, currElements);
    66.         targetClass = targetClass.getSuperclass();
    67.     }
    68.     while (targetClass != null && targetClass != Object.class);
    70.     return InjectionMetadata.forElements(elements, clazz);
    71. }

  5. AutowiredAnnotationBeanPostProcessor#findAutowiredAnnotation() 方法其实就是查看字段或者方法上是否存在指定的三个注解 @Autowired、@Value、@Inject

    1. @Nullable
    2.  private MergedAnnotation<?> findAutowiredAnnotation(AccessibleObject ao) {
    4.      MergedAnnotations annotations = MergedAnnotations.from(ao);
    5.      for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
    7.          MergedAnnotation<?> annotation = annotations.get(type);
    8.          if (annotation.isPresent()) {
    10.              return annotation;
    11.          }
    12.      }
    13.      return null;
    14.  }

  6. 经过以上步骤，Bean 对象需要处理依赖注入的元素都封装在了 InjectionMetadata 对象中，回到步骤4第2步， InjectionMetadata#inject() 方法遍历其内部待填充属性的元素，调用其InjectedElement#inject()进行属性注入

    1. public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    3.      Collection<InjectedElement> checkedElements = this.checkedElements;
    4.      Collection<InjectedElement> elementsToIterate =
    5.              (checkedElements != null ? checkedElements : this.injectedElements);
    6.      if (!elementsToIterate.isEmpty()) {
    8.          for (InjectedElement element : elementsToIterate) {
    10.              if (logger.isTraceEnabled()) {
    12.                  logger.trace("Processing injected element of bean '" + beanName + "': " + element);
    13.              }
    14.              element.inject(target, beanName, pvs);
    15.          }
    16.      }
    17.  }

  7. 本文以字段属性注入为例，AutowiredFieldElement#inject() 方法的实现如下，核心逻辑可分为两步：

    1. 调用 DefaultListableBeanFactory#resolveDependency() 从容器中获取字段的属性值
    2. field.set() 反射调用字段赋值方法，完成属性值的注入
    1. @Override
    2.      protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
    4.          Field field = (Field) this.member;
    5.          Object value;
    6.          if (this.cached) {
    8.              value = resolvedCachedArgument(beanName, this.cachedFieldValue);
    9.          }
    10.          else {
    12.              DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
    13.              desc.setContainingClass(bean.getClass());
    14.              Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
    15.              Assert.state(beanFactory != null, "No BeanFactory available");
    16.              TypeConverter typeConverter = beanFactory.getTypeConverter();
    17.              try {
    19.                  value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
    20.              }
    21.              catch (BeansException ex) {
    23.                  throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
    24.              }
    25.              synchronized (this) {
    27.                  if (!this.cached) {
    29.                      if (value != null || this.required) {
    31.                          this.cachedFieldValue = desc;
    32.                          registerDependentBeans(beanName, autowiredBeanNames);
    33.                          if (autowiredBeanNames.size() == 1) {
    35.                              String autowiredBeanName = autowiredBeanNames.iterator().next();
    36.                              if (beanFactory.containsBean(autowiredBeanName) &&
    37.                                      beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
    39.                                  this.cachedFieldValue = new ShortcutDependencyDescriptor(
    40.                                          desc, autowiredBeanName, field.getType());
    41.                              }
    42.                          }
    43.                      }
    44.                      else {
    46.                          this.cachedFieldValue = null;
    47.                      }
    48.                      this.cached = true;
    49.                  }
    50.              }
    51.          }
    52.          if (value != null) {
    54.              ReflectionUtils.makeAccessible(field);
    55.              field.set(bean, value);
    56.          }
    57.      }

  8. DefaultListableBeanFactory#resolveDependency() 会做常规的判断，核心是调用DefaultListableBeanFactory#doResolveDependency() 方法

    1. public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
    2.         @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
  1.         descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
  2.         if (Optional.class == descriptor.getDependencyType()) {
  4.             return createOptionalDependency(descriptor, requestingBeanName);
  5.         }
  6.         else if (ObjectFactory.class == descriptor.getDependencyType() ||
  7.                 ObjectProvider.class == descriptor.getDependencyType()) {
  9.             return new DependencyObjectProvider(descriptor, requestingBeanName);
  10.         }
  11.         else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
  13.             return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
  14.         }
  15.         else {
  17.             Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
  18.                     descriptor, requestingBeanName);
  19.             if (result == null) {
  21.                 result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
  22.             }
  23.             return result;
  24.         }
  25.      }

  1. DefaultListableBeanFactory#doResolveDependency() 方法重要流程分为以下几步：

    1. getAutowireCandidateResolver().getSuggestedValue(descriptor) 调用 2.1节提到的解析器 ContextAnnotationAutowireCandidateResolver#getSuggestedValue() 方法，将元素的注解中配置的字符串取出来。例如字段上标注了@Value("#{'${spring.data.users:nathan}'.split(',')}")，则这个步骤将取得字符串 #{'${spring.data.users:nathan}'.split(',')}
    2. 调用父类 AbstractBeanFactory#resolveEmbeddedValue() 方法解析字符串#{'${spring.data.users:nathan}'.split(',')} 中 ${} 包裹的部分，具体逻辑为使用键 spring.data.users 去容器中获取属性值，获取不到则使用冒号: 后默认的 nathan 作为值，方法返回后取得字符串 #{'nathan'.split(',')}
    3. 调用父类 AbstractBeanFactory#evaluateBeanDefinitionString() 方法使用 SpEL 表达式 解析字符串 #{'nathan'.split(',')}，本例中实际是个字符串分割的操作，方法返回后获得一个字符串数组对象 [“nathan”]
    4. 调用类型转换器 TypeConverter#convertIfNecessary() 方法将以上步骤处理取得的值转换为目标字段的类型并返回
    1. @Nullable
    2. public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
    3.         @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
  1.         InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
  2.         try {
  4.             Object shortcut = descriptor.resolveShortcut(this);
  5.             if (shortcut != null) {
  7.                 return shortcut;
  8.             }
  10.             Class<?> type = descriptor.getDependencyType();
  11.             Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
  12.             if (value != null) {
  14.                 if (value instanceof String) {
  16.                     String strVal = resolveEmbeddedValue((String) value);
  17.                     BeanDefinition bd = (beanName != null && containsBean(beanName) ?
  18.                             getMergedBeanDefinition(beanName) : null);
  19.                     value = evaluateBeanDefinitionString(strVal, bd);
  20.                 }
  21.                 TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
  22.                 try {
  24.                     return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
  25.                 }
  26.                 catch (UnsupportedOperationException ex) {
  28.                     // A custom TypeConverter which does not support TypeDescriptor resolution...
  29.                     return (descriptor.getField() != null ?
  30.                             converter.convertIfNecessary(value, type, descriptor.getField()) :
  31.                             converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
  32.                 }
  33.             }
  35.             Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
  36.             if (multipleBeans != null) {
  38.                 return multipleBeans;
  39.             }
  41.             Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
  42.             if (matchingBeans.isEmpty()) {
  44.                 if (isRequired(descriptor)) {
  46.                     raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
  47.                 }
  48.                 return null;
  49.             }
  51.             String autowiredBeanName;
  52.             Object instanceCandidate;
  54.             if (matchingBeans.size() > 1) {
  56.                 autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
  57.                 if (autowiredBeanName == null) {
  59.                     if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
  61.                         return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
  62.                     }
  63.                     else {
  65.                         // In case of an optional Collection/Map, silently ignore a non-unique case:
  66.                         // possibly it was meant to be an empty collection of multiple regular beans
  67.                         // (before 4.3 in particular when we didn't even look for collection beans).
  68.                         return null;
  69.                     }
  70.                 }
  71.                 instanceCandidate = matchingBeans.get(autowiredBeanName);
  72.             }
  73.             else {
  75.                 // We have exactly one match.
  76.                 Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
  77.                 autowiredBeanName = entry.getKey();
  78.                 instanceCandidate = entry.getValue();
  79.             }
  81.             if (autowiredBeanNames != null) {
  83.                 autowiredBeanNames.add(autowiredBeanName);
  84.             }
  85.             if (instanceCandidate instanceof Class) {
  87.                 instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
  88.             }
  89.             Object result = instanceCandidate;
  90.             if (result instanceof NullBean) {
  92.                 if (isRequired(descriptor)) {
  94.                     raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
  95.                 }
  96.                 result = null;
  97.             }
  98.             if (!ClassUtils.isAssignableValue(type, result)) {
  100.                 throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
  101.             }
  102.             return result;
  103.         }
  104.         finally {
  106.             ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
  107.         }
  108.     }

  1. AbstractBeanFactory#resolveEmbeddedValue() 方法比较简单，就是遍历内部缓存的 StringValueResolver 列表，去获取目标属性值。在 2.2节步骤5 中，我们已经注册一个 lambda 表达式 作为 StringValueResolver 在容器内部，则此处会触发PropertySourcesPlaceholderConfigurer#processProperties() 中构造的表达式执行

    1. public String resolveEmbeddedValue(@Nullable String value) {
    3.     if (value == null) {
    5.         return null;
    6.     }
    7.     String result = value;
    8.     for (StringValueResolver resolver : this.embeddedValueResolvers) {
    10.         result = resolver.resolveStringValue(result);
    11.         if (result == null) {
    13.             return null;
    14.         }
    15.     }
    16.     return result;
    17. }

  2. PropertySourcesPlaceholderConfigurer#processProperties() 中构造的表达式如下，可以看到此处最终使用目标键获取属性的操作是在调用的 PropertySourcesPropertyResolver#resolveRequiredPlaceholders() 方法中

    1. protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess,
    2.         final ConfigurablePropertyResolver propertyResolver) throws BeansException {
  1.         propertyResolver.setPlaceholderPrefix(this.placeholderPrefix);
  2.         propertyResolver.setPlaceholderSuffix(this.placeholderSuffix);
  3.         propertyResolver.setValueSeparator(this.valueSeparator);
  5.         StringValueResolver valueResolver = strVal -> {
  7.             String resolved = (this.ignoreUnresolvablePlaceholders ?
  8.                     propertyResolver.resolvePlaceholders(strVal) :
  9.                     propertyResolver.resolveRequiredPlaceholders(strVal));
  10.             if (this.trimValues) {
  12.                 resolved = resolved.trim();
  13.             }
  14.             return (resolved.equals(this.nullValue) ? null : resolved);
  15.         };
  17.         ......
  18.     }

  1. PropertySourcesPropertyResolver#resolveRequiredPlaceholders() 由其父类 AbstractPropertyResolver#resolveRequiredPlaceholders()实现，主要流程分为两步：

    1. 调用 AbstractPropertyResolver#createPlaceholderHelper() 方法创建 PropertyPlaceholderHelper对象
    2. 调用 AbstractPropertyResolver#doResolvePlaceholders() 方法，进而调用 PropertyPlaceholderHelper#replacePlaceholders() 方法获取属性值，处理原字符串替换
    1. public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException {
    3.     if (this.strictHelper == null) {
    5.         this.strictHelper = createPlaceholderHelper(false);
    6.     }
    7.     return doResolvePlaceholders(text, this.strictHelper);
    8. }
    10. private String doResolvePlaceholders(String text, PropertyPlaceholderHelper helper) {
    12.     return helper.replacePlaceholders(text, this::getPropertyAsRawString);
    13. }

  2. PropertyPlaceholderHelper#replacePlaceholders() 方法只是个入口，核心在 PropertyPlaceholderHelper#parseStringValue() 方法的实现，重要逻辑如下：

    1. 递归查找目标字符串中 ${} 包裹的字符串，直到最里层
    2. 使用分隔符 : 切割 ${} 包裹的字符串，将其前半部分作为入参调用 PlaceholderResolver#resolvePlaceholder() 方法取容器中的目标属性值（没有取到则将分隔符 : 后面的字符串作为目标值），替换掉原字符串部分
    3. 递归收束，最终返回给调用方的即为替换掉了 ${} 包裹内容的字符串
    1. public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) {
    3.     Assert.notNull(value, "'value' must not be null");
    4.     return parseStringValue(value, placeholderResolver, null);
    5. }
    7. protected String parseStringValue(
    8.         String value, PlaceholderResolver placeholderResolver, @Nullable Set<String> visitedPlaceholders) {
  1.         int startIndex = value.indexOf(this.placeholderPrefix);
  2.         if (startIndex == -1) {
  4.             return value;
  5.         }
  7.         StringBuilder result = new StringBuilder(value);
  8.         while (startIndex != -1) {
  10.             int endIndex = findPlaceholderEndIndex(result, startIndex);
  11.             if (endIndex != -1) {
  13.                 String placeholder = result.substring(startIndex + this.placeholderPrefix.length(), endIndex);
  14.                 String originalPlaceholder = placeholder;
  15.                 if (visitedPlaceholders == null) {
  17.                     visitedPlaceholders = new HashSet<>(4);
  18.                 }
  19.                 if (!visitedPlaceholders.add(originalPlaceholder)) {
  21.                     throw new IllegalArgumentException(
  22.                             "Circular placeholder reference '" + originalPlaceholder + "' in property definitions");
  23.                 }
  24.                 // Recursive invocation, parsing placeholders contained in the placeholder key.
  25.                 placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
  26.                 // Now obtain the value for the fully resolved key...
  27.                 String propVal = placeholderResolver.resolvePlaceholder(placeholder);
  28.                 if (propVal == null && this.valueSeparator != null) {
  30.                     int separatorIndex = placeholder.indexOf(this.valueSeparator);
  31.                     if (separatorIndex != -1) {
  33.                         String actualPlaceholder = placeholder.substring(0, separatorIndex);
  34.                         String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
  35.                         propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
  36.                         if (propVal == null) {
  38.                             propVal = defaultValue;
  39.                         }
  40.                     }
  41.                 }
  42.                 if (propVal != null) {
  44.                     // Recursive invocation, parsing placeholders contained in the
  45.                     // previously resolved placeholder value.
  46.                     propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
  47.                     result.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
  48.                     if (logger.isTraceEnabled()) {
  50.                         logger.trace("Resolved placeholder '" + placeholder + "'");
  51.                     }
  52.                     startIndex = result.indexOf(this.placeholderPrefix, startIndex + propVal.length());
  53.                 }
  54.                 else if (this.ignoreUnresolvablePlaceholders) {
  56.                     // Proceed with unprocessed value.
  57.                     startIndex = result.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
  58.                 }
  59.                 else {
  61.                     throw new IllegalArgumentException("Could not resolve placeholder '" +
  62.                             placeholder + "'" + " in value \"" + value + "\"");
  63.                 }
  64.                 visitedPlaceholders.remove(originalPlaceholder);
  65.             }
  66.             else {
  68.                 startIndex = -1;
  69.             }
  70.         }
  71.         return result.toString();
  72.     }

  1. 回到步骤11第3步，SpEL 表达式的解析入口为 AbstractBeanFactory#evaluateBeanDefinitionString() 方法，此处使用了 Spring 中 SpEL 表达式模块的相关 API， 本文不做进一步分析，有兴趣的读者可以自行搜索学习

    1. protected Object evaluateBeanDefinitionString(@Nullable String value, @Nullable BeanDefinition beanDefinition) {
    3.     if (this.beanExpressionResolver == null) {
    5.         return value;
    6.     }
    8.     Scope scope = null;
    9.     if (beanDefinition != null) {
    11.         String scopeName = beanDefinition.getScope();
    12.         if (scopeName != null) {
    14.             scope = getRegisteredScope(scopeName);
    15.         }
    16.     }
    17.     return this.beanExpressionResolver.evaluate(value, new BeanExpressionContext(this, scope));
    18.  }
  2. 回到步骤11第4步，经过类型转换器将处理得到的属性值转换为目标字段的类型后，方法栈再回到步骤9第2步，一次属性注入的流程基本结束。类型转换的部分本文不再分析，读者有兴趣可以自行深入，至此 @Value 实现原理的分析暂告段落

发表评论

表情：
评论列表 （有 0 条评论，87人围观）

还没有评论，来说两句吧...

相关阅读