spring源码解析bean定义六ContextNamespaceHandler二

前言

本次介绍ContextNamespaceHandler解析之annotation-config、component-scan

正文

按照上一篇文章的方法找到这个方法

org.springframework.beans.factory.xml.NamespaceHandlerSupport#parse

@Override
   @Nullable
   public BeanDefinition parse(Element element, ParserContext parserContext) {
//    获得bean定义解析器
      BeanDefinitionParser parser = findParserForElement(element, parserContext);
      return (parser != null ? parser.parse(element, parserContext) : null);
   }

进入到这个方法

org.springframework.context.annotation.AnnotationConfigBeanDefinitionParser#parse

@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
   Object source = parserContext.extractSource(element);

   // Obtain bean definitions for all relevant BeanPostProcessors.注册注解处理器
   Set<BeanDefinitionHolder> processorDefinitions =
         AnnotationConfigUtils.registerAnnotationConfigProcessors(parserContext.getRegistry(), source);

   // Register component for the surrounding <context:annotation-config> element.
   CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), source);
   parserContext.pushContainingComponent(compDefinition);

   // Nest the concrete beans in the surrounding component.
   for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
      parserContext.registerComponent(new BeanComponentDefinition(processorDefinition));
   }

   // Finally register the composite component.
   parserContext.popAndRegisterContainingComponent();

   return 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<>(4);

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

      if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
         RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
         def.setSource(source);
         beanDefs.add(registerPostProcessor(registry, def, REQUIRED_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;
   }

这个标签解析的时候注册一些bean定义解析器。

下面介绍component-scan解析

返回到这个方法

org.springframework.beans.factory.xml.NamespaceHandlerSupport#parse的最后一行代码

@Override
   @Nullable
   public BeanDefinition parse(Element element, ParserContext parserContext) {
//    获得bean定义解析器
      BeanDefinitionParser parser = findParserForElement(element, parserContext);
      return (parser != null ? parser.parse(element, parserContext) : null);
   }

进入到这个方法

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parse

@Override
   @Nullable
   public BeanDefinition parse(Element element, ParserContext parserContext) {
//    获取base-package属性
      String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
//    解析占位符
      basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
//    扫描的包可以是多个用分隔符分开
      String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
            ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

      // Actually scan for bean definitions and register them. 扫描bean定义注册
      ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
//    bean定义扫描
      Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
//    注册组件
      registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

      return null;
   }

进入这个方法

protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
      boolean useDefaultFilters = true;
//    如果有这个use-default-filters属性 使用默认的filter进行包扫描
      if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
         useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
      }

      // Delegate bean definition registration to scanner class.创建bean定义扫描器
      ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);
      scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
//    设置自动装配模式
      scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());

      if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {
         scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));
      }

      try {
//       解析beanName生成器
         parseBeanNameGenerator(element, scanner);
      }
      catch (Exception ex) {
         parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
      }

      try {
//       解析bean的scope
         parseScope(element, scanner);
      }
      catch (Exception ex) {
         parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
      }

      parseTypeFilters(element, scanner, parserContext);

      return scanner;
   }

找到这行代码

// Delegate bean definition registration to scanner class.创建bean定义扫描器
ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);

进入这个方法

protected ClassPathBeanDefinitionScanner createScanner(XmlReaderContext readerContext, boolean useDefaultFilters) {
   return new ClassPathBeanDefinitionScanner(readerContext.getRegistry(), useDefaultFilters,
         readerContext.getEnvironment(), readerContext.getResourceLoader());
}

进入这个方法

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
         Environment environment, @Nullable ResourceLoader resourceLoader) {

      Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
      this.registry = registry;

//    如果用默认的包扫描过滤器
      if (useDefaultFilters) {
//       注册默认的过滤器
         registerDefaultFilters();
      }
      setEnvironment(environment);
      setResourceLoader(resourceLoader);
   }

进入这个方法

protected void registerDefaultFilters() {
//    注册@Component类型的过滤器，只要带有这个注解的bean定义都会被扫描，也包括包装这个注解的注解
      this.includeFilters.add(new AnnotationTypeFilter(Component.class));
      ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
      try {
//       @ManagedBean也会被扫描
         this.includeFilters.add(new AnnotationTypeFilter(
               ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
         logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
      }
      catch (ClassNotFoundException ex) {
         // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
      }
      try {
//       @Named也会被扫描
         this.includeFilters.add(new AnnotationTypeFilter(
               ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
         logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
      }
      catch (ClassNotFoundException ex) {
         // JSR-330 API not available - simply skip.
      }
   }

返回到这个方法

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#configureScanner这一行代码

//        解析beanName生成器
         parseBeanNameGenerator(element, scanner);

进入这个方法

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parseBeanNameGenerator

protected void parseBeanNameGenerator(Element element, ClassPathBeanDefinitionScanner scanner) {
//    获取这个属性name-generator，如果没有指定beanName生成器就用AnnotationBeanNameGenerator这个
      if (element.hasAttribute(NAME_GENERATOR_ATTRIBUTE)) {
         BeanNameGenerator beanNameGenerator = (BeanNameGenerator) instantiateUserDefinedStrategy(
               element.getAttribute(NAME_GENERATOR_ATTRIBUTE), BeanNameGenerator.class,
               scanner.getResourceLoader().getClassLoader());
         scanner.setBeanNameGenerator(beanNameGenerator);
      }
   }

返回到这个方法这一行代码

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#configureScanner

//        解析bean的scope
         parseScope(element, scanner);

进入这个方法

protected void parseScope(Element element, ClassPathBeanDefinitionScanner scanner) {
      // Register ScopeMetadataResolver if class name provided.
      if (element.hasAttribute(SCOPE_RESOLVER_ATTRIBUTE)) {
         if (element.hasAttribute(SCOPED_PROXY_ATTRIBUTE)) {
            throw new IllegalArgumentException(
                  "Cannot define both 'scope-resolver' and 'scoped-proxy' on <component-scan> tag");
         }
         ScopeMetadataResolver scopeMetadataResolver = (ScopeMetadataResolver) instantiateUserDefinedStrategy(
               element.getAttribute(SCOPE_RESOLVER_ATTRIBUTE), ScopeMetadataResolver.class,
               scanner.getResourceLoader().getClassLoader());
         scanner.setScopeMetadataResolver(scopeMetadataResolver);
      }

//    获取scoped-proxy属性
      if (element.hasAttribute(SCOPED_PROXY_ATTRIBUTE)) {
         String mode = element.getAttribute(SCOPED_PROXY_ATTRIBUTE);
//       cglib动态代理
         if ("targetClass".equals(mode)) {
            scanner.setScopedProxyMode(ScopedProxyMode.TARGET_CLASS);
         }
//       jdk动态代理
         else if ("interfaces".equals(mode)) {
            scanner.setScopedProxyMode(ScopedProxyMode.INTERFACES);
         }
         else if ("no".equals(mode)) {
            scanner.setScopedProxyMode(ScopedProxyMode.NO);
         }
         else {
            throw new IllegalArgumentException("scoped-proxy only supports 'no', 'interfaces' and 'targetClass'");
         }
      }
   }

返回到这个方法org.springframework.context.annotation.ComponentScanBeanDefinitionParser#configureScanner这一行代码

//     解析扫描过滤器
      parseTypeFilters(element, scanner, parserContext);

进入这个方法

protected void parseTypeFilters(Element element, ClassPathBeanDefinitionScanner scanner, ParserContext parserContext) {
      // Parse exclude and include filter elements.
      ClassLoader classLoader = scanner.getResourceLoader().getClassLoader();
      NodeList nodeList = element.getChildNodes();
      for (int i = 0; i < nodeList.getLength(); i++) {
         Node node = nodeList.item(i);
         if (node.getNodeType() == Node.ELEMENT_NODE) {
            String localName = parserContext.getDelegate().getLocalName(node);
            try {
//             include-filter节点
               if (INCLUDE_FILTER_ELEMENT.equals(localName)) {
//                创建类型过滤器
                  TypeFilter typeFilter = createTypeFilter((Element) node, classLoader, parserContext);
                  scanner.addIncludeFilter(typeFilter);
               }
//             exclude-filter节点
               else if (EXCLUDE_FILTER_ELEMENT.equals(localName)) {
                  TypeFilter typeFilter = createTypeFilter((Element) node, classLoader, parserContext);
                  scanner.addExcludeFilter(typeFilter);
               }
            }
            catch (ClassNotFoundException ex) {
               parserContext.getReaderContext().warning(
                     "Ignoring non-present type filter class: " + ex, parserContext.extractSource(element));
            }
            catch (Exception ex) {
               parserContext.getReaderContext().error(
                     ex.getMessage(), parserContext.extractSource(element), ex.getCause());
            }
         }
      }
   }

找到这个方法

   创建类型过滤器
                  TypeFilter typeFilter = createTypeFilter((Element) node, classLoader, parserContext);

进入创建包扫描过滤器这个方法

protected TypeFilter createTypeFilter(Element element, @Nullable ClassLoader classLoader,
         ParserContext parserContext) throws ClassNotFoundException {

//    获取type属性
      String filterType = element.getAttribute(FILTER_TYPE_ATTRIBUTE);
//    获取expression属性
      String expression = element.getAttribute(FILTER_EXPRESSION_ATTRIBUTE);
      expression = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(expression);
//    注解类型
      if ("annotation".equals(filterType)) {
         return new AnnotationTypeFilter((Class<Annotation>) ClassUtils.forName(expression, classLoader));
      }
//    指定类或接口的全名
      else if ("assignable".equals(filterType)) {
         return new AssignableTypeFilter(ClassUtils.forName(expression, classLoader));
      }
//    aspectj表达式
      else if ("aspectj".equals(filterType)) {
         return new AspectJTypeFilter(expression, classLoader);
      }
//    正则表达式
      else if ("regex".equals(filterType)) {
         return new RegexPatternTypeFilter(Pattern.compile(expression));
      }
//    TypeFilter自定义实现
      else if ("custom".equals(filterType)) {
         Class<?> filterClass = ClassUtils.forName(expression, classLoader);
         if (!TypeFilter.class.isAssignableFrom(filterClass)) {
            throw new IllegalArgumentException(
                  "Class is not assignable to [" + TypeFilter.class.getName() + "]: " + expression);
         }
         return (TypeFilter) BeanUtils.instantiateClass(filterClass);
      }
      else {
         throw new IllegalArgumentException("Unsupported filter type: " + filterType);
      }
   }

支持以上这几种包扫描过滤器配置方式。

返回到这个方法这一行代码

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parse

//     bean定义扫描
      Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);

进入这个方法

org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
      Assert.notEmpty(basePackages, "At least one base package must be specified");
      Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
      for (String basePackage : basePackages) {
         Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
         for (BeanDefinition candidate : candidates) {
//          解析scope的metadata信息
            ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
            candidate.setScope(scopeMetadata.getScopeName());
//          解析beanName
            String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
            if (candidate instanceof AbstractBeanDefinition) {
//             解析一般的bean定义属性
               postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
            }
            if (candidate instanceof AnnotatedBeanDefinition) {
               AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
            }
            if (checkCandidate(beanName, candidate)) {
               BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
               definitionHolder =
                     AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
               beanDefinitions.add(definitionHolder);
//             注册bean定义
               registerBeanDefinition(definitionHolder, this.registry);
            }
         }
      }
      return beanDefinitions;
   }

找到这一行代码

//           解析beanName
            String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);

找到这个方法

org.springframework.context.annotation.AnnotationBeanNameGenerator#generateBeanName

@Override
   public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
      if (definition instanceof AnnotatedBeanDefinition) {
//       从注解中获取beanName
         String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
         if (StringUtils.hasText(beanName)) {
            // Explicit bean name found.
            return beanName;
         }
      }
      // Fallback: generate a unique default bean name.
      return buildDefaultBeanName(definition, registry);
   }

找到这行代码

//        从注解中获取beanName
         String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);

从注解配置中获取beanName

@Nullable
protected String determineBeanNameFromAnnotation(AnnotatedBeanDefinition annotatedDef) {
   AnnotationMetadata amd = annotatedDef.getMetadata();
   Set<String> types = amd.getAnnotationTypes();
   String beanName = null;
   for (String type : types) {
      AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(amd, type);
      if (attributes != null && isStereotypeWithNameValue(type, amd.getMetaAnnotationTypes(type), attributes)) {
         Object value = attributes.get("value");
         if (value instanceof String) {
            String strVal = (String) value;
            if (StringUtils.hasLength(strVal)) {
               if (beanName != null && !strVal.equals(beanName)) {
                  throw new IllegalStateException("Stereotype annotations suggest inconsistent " +
                        "component names: '" + beanName + "' versus '" + strVal + "'");
               }
               beanName = strVal;
            }
         }
      }
   }
   return beanName;
}

如果注解中没有配置beanName，就自动生成beanName

return buildDefaultBeanName(definition, registry);

protected String buildDefaultBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
   return buildDefaultBeanName(definition);
}

protected String buildDefaultBeanName(BeanDefinition definition) {
   String beanClassName = definition.getBeanClassName();
   Assert.state(beanClassName != null, "No bean class name set");
   String shortClassName = ClassUtils.getShortName(beanClassName);
   return Introspector.decapitalize(shortClassName);
}

默认生成的beanName是类的简单名称

返回到这个方法org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan的这一行

//              解析一般的bean定义属性
               postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);

//              解析一般的bean定义注解
               AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);

进入这个方法

org.springframework.context.annotation.AnnotationConfigUtils#processCommonDefinitionAnnotations(org.springframework.beans.factory.annotation.AnnotatedBeanDefinition, org.springframework.core.type.AnnotatedTypeMetadata)

static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
//    解析lazy注解
      AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
      if (lazy != null) {
//       获取value的属性值是否开启延迟加载
         abd.setLazyInit(lazy.getBoolean("value"));
      }
      else if (abd.getMetadata() != metadata) {
         lazy = attributesFor(abd.getMetadata(), Lazy.class);
         if (lazy != null) {
            abd.setLazyInit(lazy.getBoolean("value"));
         }
      }

//    获取Primary注解值
      if (metadata.isAnnotated(Primary.class.getName())) {
         abd.setPrimary(true);
      }
//    解析DependsOn注解
      AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
      if (dependsOn != null) {
//       获取value属性值
         abd.setDependsOn(dependsOn.getStringArray("value"));
      }

      if (abd instanceof AbstractBeanDefinition) {
         AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
//       解析Role注解
         AnnotationAttributes role = attributesFor(metadata, Role.class);
         if (role != null) {
//          获取value属性值
            absBd.setRole(role.getNumber("value").intValue());
         }
//       解析Description注解
         AnnotationAttributes description = attributesFor(metadata, Description.class);
         if (description != null) {
//          获取value属性值
            absBd.setDescription(description.getString("value"));
         }
      }
   }

返回到这个方法org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan的这一行

definitionHolder =
      AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);

static BeanDefinitionHolder applyScopedProxyMode(
         ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {

      ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
//    如果没有开启动态代理，直接返回bean定义
      if (scopedProxyMode.equals(ScopedProxyMode.NO)) {
         return definition;
      }
//    如果是cglib动态代理
      boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
//    创建动态代理
      return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
   }

返回到这个方法的这一行代码

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parse

@Override
   @Nullable
   public BeanDefinition parse(Element element, ParserContext parserContext) {
//    获取base-package属性
      String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
//    解析占位符
      basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
//    扫描的包可以是多个用分隔符分开
      String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
            ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

      // Actually scan for bean definitions and register them. 扫描bean定义注册
      ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
//    bean定义扫描
      Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
//    注册组件
      registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

      return null;
   }

进入这个方法

protected void registerComponents(
         XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {

      Object source = readerContext.extractSource(element);
      CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);

      for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {
         compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));
      }

      // Register annotation config processors, if necessary.
      boolean annotationConfig = true;
//    节点有annotation-config属性
      if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
         annotationConfig = Boolean.valueOf(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
      }
      if (annotationConfig) {
         Set<BeanDefinitionHolder> processorDefinitions =
//             注册注解解析器
               AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
         for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
            compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
         }
      }

//    出发组件注册事件
      readerContext.fireComponentRegistered(compositeDef);
   }

component-scan节点解析完了。

最后

本次介绍到这里，以上内容仅供参考。

扫码关注

进群讨论

快到碗里来

spring源码解析bean定义六ContextNamespaceHandler二

猜你喜欢