spring源码阅读-内置bean的注册过程

main

AnnotationConfigApplicationContext aac = 
						new AnnotationConfigApplicationContext(AppConfig.class);

看看这么简单的一行代码都做了什么。

 public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
 	private final AnnotatedBeanDefinitionReader reader;
 	private final ClassPathBeanDefinitionScanner scanner;
 
 	public AnnotationConfigApplicationContext() {
          //这里的reader会注册系统内置的开天辟地的6个bean,后面做重点分析 
 		this.reader = new AnnotatedBeanDefinitionReader(this);
 		this.scanner = new ClassPathBeanDefinitionScanner(this);
 	}
 	
 	public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) {
 		super(beanFactory);
 		this.reader = new AnnotatedBeanDefinitionReader(this);
 		this.scanner = new ClassPathBeanDefinitionScanner(this);
 	}
 
 	public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
 		//这里隐式调用父类的无参构造方法,创建BeanFactory类实例DefaultListableBeanFactory
 		//调用自己的无参构造方法创建一个reader
 		//会注册系统内置的bean到BeanDefinitionMap中 大概有6个左右
 		this();
 		//把入参对应的类注册到beanDefinitionMap中1
 		register(componentClasses);
 		refresh();
 	}
 
 	public AnnotationConfigApplicationContext(String... basePackages) {
 		this();
 		scan(basePackages);
 		refresh();
 	}
 }

重点关注下上图代码中第11行代码 this.reader = new AnnotatedBeanDefinitionReader(this); 找到对应的代码

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
	this(registry, getOrCreateEnvironment(registry));
}

可以看到又调用了其他的构造方法,继续进到方法里面看。

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
   Assert.notNull(environment, "Environment must not be null");
   this.registry = registry;
   this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
   AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

重点关注下第6行代码 ***AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);***，找到对应的方法

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
   registerAnnotationConfigProcessors(registry, null);
}

发现里面又调用了其他的注册方法,继续跟踪。

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
      BeanDefinitionRegistry registry, @Nullable Object source) {

   DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
   if (beanFactory != null) {
      if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
         beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
      }
      if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
         beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
      }
   }

   Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
   //这里开始注册系统内置的bean
   if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
   if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
   if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition();
      try {
         def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
               AnnotationConfigUtils.class.getClassLoader()));
      }
      catch (ClassNotFoundException ex) {
         throw new IllegalStateException(
               "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
      }
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
   }

   if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
   }

   return beanDefs;
}

registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)

这里的registry就是DefaultListableBeanFactory, registry.contains 实际上就是看beanDefinitionMap中是否存在指定的key，也就是beanName。

可以看到逻辑很简单，就是判断了一堆系统内置的bean是否在beanDefinitionMap(狭义的spring容器)中存在()，如果不存在则调用registerPostProcessor 注册到容器中，同时加入到beanDefs这个Set中，那我们再关注下这个**registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME)**这个方法具体的内容。

private static BeanDefinitionHolder registerPostProcessor(
      BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

   definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
   registry.registerBeanDefinition(beanName, definition);
   return new BeanDefinitionHolder(definition, beanName);
}

继续调用registry的方法，这里的registerBeanDefinition是BeanDefinitionRegistry接口提供的方法，而这里对应的实现类是DefaultListableBeanFactory,所以我们关注下DefaultListableBeanFactory这个类里面关于注册bean的具体实现。

@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
      throws BeanDefinitionStoreException {

   Assert.hasText(beanName, "Bean name must not be empty");
   Assert.notNull(beanDefinition, "BeanDefinition must not be null");

   if (beanDefinition instanceof AbstractBeanDefinition) {
      try {
         ((AbstractBeanDefinition) beanDefinition).validate();
      }
      catch (BeanDefinitionValidationException ex) {
         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
               "Validation of bean definition failed", ex);
      }
   }

   BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
   if (existingDefinition != null) {
      if (!isAllowBeanDefinitionOverriding()) {
         throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
      }
       //用户创建的 role=ROLE_APPLICATION  系统内置的role=ROLE_INFRASTRUCTURE
      else if (existingDefinition.getRole() < beanDefinition.getRole()) {
         // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
         if (logger.isInfoEnabled()) {
            logger.info("Overriding user-defined bean definition for bean '" + beanName +
                  "' with a framework-generated bean definition: replacing [" +
                  existingDefinition + "] with [" + beanDefinition + "]");
         }
      }
      else if (!beanDefinition.equals(existingDefinition)) {
         if (logger.isDebugEnabled()) {
            logger.debug("Overriding bean definition for bean '" + beanName +
                  "' with a different definition: replacing [" + existingDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
      else {
         if (logger.isTraceEnabled()) {
			//equivalent 相等的 相同的 等价的
            logger.trace("Overriding bean definition for bean '" + beanName +
                  "' with an equivalent definition: replacing [" + existingDefinition +
                  "] with [" + beanDefinition + "]");
         }
      }
       //如果对应的beanName存在于beanDefinitionMap且允许覆盖则将新的beanDefinition放入到beanDefinitionMap中
      this.beanDefinitionMap.put(beanName, beanDefinition);
   }
   else {
      if (hasBeanCreationStarted()) {
         // Cannot modify startup-time collection elements anymore (for stable iteration)
         synchronized (this.beanDefinitionMap) {
            this.beanDefinitionMap.put(beanName, beanDefinition);
            List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
            updatedDefinitions.addAll(this.beanDefinitionNames);
            updatedDefinitions.add(beanName);
            this.beanDefinitionNames = updatedDefinitions;
            removeManualSingletonName(beanName);
         }
      }
      else {
         // Still in startup registration phase
         this.beanDefinitionMap.put(beanName, beanDefinition);
         this.beanDefinitionNames.add(beanName);
          //这里对应的实际代码也很简单就是从factoryBeanCreatedCache中移除掉这个beanName 暂且不分析。
          //
          removeManualSingletonName(beanName);
      }
      this.frozenBeanDefinitionNames = null;
   }

   if (existingDefinition != null || containsSingleton(beanName)) {
      resetBeanDefinition(beanName);
   }
}

整体分了个if…else… 用beanName是否存在于beanDefinitionMap做了区分,还是比较好理解的。在else里用hasBeanCreationStarted()又做了条件区分，我们关注下这个方法。

private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
protected boolean hasBeanCreationStarted() {
   return !this.alreadyCreated.isEmpty();
}

可以看到就是个set集合 , 我们大概猜测下在正式生成bean的时候会往里面放值，此处暂且不分析。

在发现有bean已经开始创建的时候，先给this.beanDefinitionMap加锁，这里是为了防止其他的线程操作这个对象导致一些问题，然后通过getBeanDefinitionNames重新生成一个list将要注册的beanName放进去，再赋值给beanDefinitionMap，这些也都是正常逻辑，没毛病。

再关注下 removeManualSingletonName(beanName); 这个方法，在实际往

private void updateManualSingletonNames(Consumer<Set<String>> action, Predicate<Set<String>> condition) {
    if (hasBeanCreationStarted()) {
        // Cannot modify startup-time collection elements anymore (for stable iteration)
        synchronized (this.beanDefinitionMap) {
            if (condition.test(this.manualSingletonNames)) {
                Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                action.accept(updatedSingletons);
                this.manualSingletonNames = updatedSingletons;
            }
        }
    }
    else {
        // Still in startup registration phase
        if (condition.test(this.manualSingletonNames)) {
            action.accept(this.manualSingletonNames);
        }
    }
}

依然是在往map或者set中存值或者取值做判断。暂且分析到此。

遗留一:

DefaultListableBeanFactory作为spring一个很重要的类,里面很多逻辑都是用map或者set完成的。通过看源码发现里面定义了如下这些常用到的属性变量，我们需要看代码分析下每个变量的价值和使用环境。

manualSingletonNames
beanDefinitionMap
allBeanNamesByType
singletonBeanNamesByType
beanDefinitionNames
manualSingletonNames
frozenBeanDefinitionNames

到这里系统内置bean注册的过程就执行完了。