Spring源码分析（四）之@Configuration @Bean的方式配置bean

原文地址：http://blog.****.net/jin5203344/article/details/78590111

             在微服务大趋势下Springboot，Springcloud成为更多公司新项目技术框架的选型 ，Springboot简洁的基本零配置，很重要的一点是将以前通过xml方式配置bean转换为

通过@Configuration @Bean的方式来进行，今天主要分析下Spring是如何来实现对这两个注解进行处理的

             通过Springboot的启动来跟踪分析容器的启动（这里只是简单的带过，后面会在springboot源码分析中，详细讲解），run方法具体实现如下：

重点关注refreshContext，在refreshContext中 就有第一篇中分析容器入口的refresh方法

事实上 我们分析的入口依然是refresh这个核心方法，这里就不重复贴源码了，这是我们之前loadBeanDefinitions换成 AnnotationConfigWebApplicationContext 类

AnnotationBeanDefinitionReader 对应构造函数 为：

可以看到 最后一行 注册AnnotationConfigProcessors，有什么用呢，接着看其实现：

这里我们只用关系，configuration注解的处理，实际是向容器中接入了 对Configuration注解的 处理类 ConfigurationClassPostProcessor，

那我们有个疑问，这个类什么时候会调用呢？  回到refresh方法中，有一行关键代码

// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);

方法内容比较多，这里就选取一个分支来说明下

String[] postProcessorNames =
      beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
for (String ppName : postProcessorNames) {
   if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
      priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
      processedBeans.add(ppName);
   }
}
sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
registryPostProcessors.addAll(priorityOrderedPostProcessors);
invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);

第一行：从工厂类中得到所有 BeanDefinitionRegistryPostProcessor类型的bean

第三——九行 循环判断添加到 需要处理的列表中

第十二行：执行具体需要处理的postProcessors

具体实现如下：

private static void invokeBeanDefinitionRegistryPostProcessors(
      Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {

   for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
      postProcessor.postProcessBeanDefinitionRegistry(registry);
   }
}

也就是循环调用postProcessor的 postProcessBeanDefinitionRegistry方法，而ConfigurationClassPostProcessor类的对应方法内部调用逻辑顺序

postProcessBeanDefinitionRegistry  ——》 processConfigBeanDefinitions ——》

从源码注释就能看出  是解析 @Configuration 注解的类  通过ConfigurationClassParser 来进行处理

parser ——》processConfigurationClass ——》doProcessConfigurationClass

其他注解的处理这里暂且不作分析，后面有机会再补上，有兴趣的读者可以自行查看源码学习，原理都差不多，解析到对于的信息添加到configClass中

可以看到通过解析@Bean注解，获取到所有带有@Bean注解的方法，创建对应的BeanMethod添加到configClass中，回到processConfigBeanDefinitions方法

this.reader.loadBeanDefinitions(configClasses);

通过configClasses加载bean定义

查看具体实现

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
   TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
   for (ConfigurationClass configClass : configurationModel) {
      loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
   }
}

循环加载

private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass,
      TrackedConditionEvaluator trackedConditionEvaluator) {

   if (trackedConditionEvaluator.shouldSkip(configClass)) {
      String beanName = configClass.getBeanName();
      if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
         this.registry.removeBeanDefinition(beanName);
      }
      this.importRegistry.removeImportingClassFor(configClass.getMetadata().getClassName());
      return;
   }

   if (configClass.isImported()) {
      registerBeanDefinitionForImportedConfigurationClass(configClass);
   }
   // 循环加载 beanMethod
   for (BeanMethod beanMethod : configClass.getBeanMethods()) {
      loadBeanDefinitionsForBeanMethod(beanMethod);
   }
   loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
   loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

loadBeanDefinitionsForBeanMethod  字面意思  为beanMethod加载beanDefinition

private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
   ConfigurationClass configClass = beanMethod.getConfigurationClass();
   MethodMetadata metadata = beanMethod.getMetadata();
   String methodName = metadata.getMethodName();

   // Do we need to mark the bean as skipped by its condition?
   if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
      configClass.skippedBeanMethods.add(methodName);
      return;
   }
   if (configClass.skippedBeanMethods.contains(methodName)) {
      return;
   }

   // Consider name and any aliases
   AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
   List<String> names = new ArrayList<String>(Arrays.asList(bean.getStringArray("name")));
   String beanName = (names.size() > 0 ? names.remove(0) : methodName);

   // Register aliases even when overridden
   for (String alias : names) {
      this.registry.registerAlias(beanName, alias);
   }

   // Has this effectively been overridden before (e.g. via XML)?
   if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
      return;
   }

   ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata);
   beanDef.setResource(configClass.getResource());
   beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));

   if (metadata.isStatic()) {
      // static @Bean method
      beanDef.setBeanClassName(configClass.getMetadata().getClassName());
      beanDef.setFactoryMethodName(methodName);
   }
   else {
      // instance @Bean method
      beanDef.setFactoryBeanName(configClass.getBeanName());
      beanDef.setUniqueFactoryMethodName(methodName);
   }
   beanDef.setAutowireMode(RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
   beanDef.setAttribute(RequiredAnnotationBeanPostProcessor.SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);

   AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);

   Autowire autowire = bean.getEnum("autowire");
   if (autowire.isAutowire()) {
      beanDef.setAutowireMode(autowire.value());
   }

   String initMethodName = bean.getString("initMethod");
   if (StringUtils.hasText(initMethodName)) {
      beanDef.setInitMethodName(initMethodName);
   }

   String destroyMethodName = bean.getString("destroyMethod");
   if (destroyMethodName != null) {
      beanDef.setDestroyMethodName(destroyMethodName);
   }

   // Consider scoping
   ScopedProxyMode proxyMode = ScopedProxyMode.NO;
   AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
   if (attributes != null) {
      beanDef.setScope(attributes.getAliasedString("value", Scope.class, configClass.getResource()));
      proxyMode = attributes.getEnum("proxyMode");
      if (proxyMode == ScopedProxyMode.DEFAULT) {
         proxyMode = ScopedProxyMode.NO;
      }
   }

   // Replace the original bean definition with the target one, if necessary
   BeanDefinition beanDefToRegister = beanDef;
   if (proxyMode != ScopedProxyMode.NO) {
      BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(
            new BeanDefinitionHolder(beanDef, beanName), this.registry, proxyMode == ScopedProxyMode.TARGET_CLASS);
      beanDefToRegister = new ConfigurationClassBeanDefinition(
            (RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata);
   }

   if (logger.isDebugEnabled()) {
      logger.debug(String.format("Registering bean definition for @Bean method %s.%s()",
            configClass.getMetadata().getClassName(), beanName));
   }

   this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}

通过元数据以及相关信息 装配 注册beanDefinition