前言

在上一篇文章中分析了Spring是如何解析默認標簽的，并封裝為BeanDefinition注冊到緩存中，這一篇就來看看對于像context這種自定義標簽是如何解析的。同時我們常用的注解如：@Service、@Component、@Controller標注的類也是需要在xml中配置<context:component-scan>才能自動注入到IOC容器中，所以本篇也會重點分析注解解析原理。

正文

自定義標簽解析原理

在上一篇分析默認標簽解析時看到過這個類DefaultBeanDefinitionDocumentReader的方法parseBeanDefinitions：

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { if (delegate.isDefaultNamespace(root)) { NodeList nl = root.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (node instanceof Element) { Element ele = (Element) node; if (delegate.isDefaultNamespace(ele)) { //默認標簽解析 parseDefaultElement(ele, delegate); } else { //自定義標簽解析 delegate.parseCustomElement(ele); } } } } else { delegate.parseCustomElement(root); } }

現在我們就來看看parseCustomElement這個方法，但在點進去之前不妨想想自定義標簽解析應該怎么做。

public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) { String namespaceUri = getNamespaceURI(ele); if (namespaceUri == null) { return null; } NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri); if (handler == null) { error('Unable to locate Spring NamespaceHandler for XML schema namespace [' + namespaceUri + ']', ele); return null; } return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd)); }

可以看到和默認標簽解析是一樣的，只不過由decorate方法改為了parse方法，但具體是如何解析的呢？這里我就以component-scan標簽的解析為例，看看注解是如何解析為BeanDefinition對象的。

注解解析原理

進入到parse方法中，首先會進入NamespaceHandlerSupport類中：

public BeanDefinition parse(Element element, ParserContext parserContext) { BeanDefinitionParser parser = findParserForElement(element, parserContext); return (parser != null ? parser.parse(element, parserContext) : null); }

首先通過findParserForElement方法去找到對應的解析器，然后委托給解析器ComponentScanBeanDefinitionParser解析。在往下看之前，我們先想一想，如果是我們自己要去實現這個注解解析過程會怎么做。是不是應該首先通過配置的basePackage屬性，去掃描該路徑下所有的class文件，然后判斷class文件是否符合條件，即是否標注了@Service、@Component、@Controller等注解，如果有，則封裝為BeanDefinition對象并注冊到容器中去？

下面就來驗證我們的猜想：

public BeanDefinition parse(Element element, ParserContext parserContext) { 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. // 創造ClassPathBeanDefinitionScanner對象，用來掃描basePackage包下符合條件（默認是@Component標注的類）的類， // 并創建BeanDefinition類注冊到緩存中 ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element); Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages); registerComponents(parserContext.getReaderContext(), beanDefinitions, element); return null; }

可以看到流程和我們猜想的基本一致，首先創建了一個掃描器ClassPathBeanDefinitionScanner對象，然后通過這個掃描器去掃描classpath下的文件并注冊，最后調用了registerComponents方法，這個方法的作用稍后來講，我們先來看看掃描器是如何創建的：

protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) { boolean useDefaultFilters = true; if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) { useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)); } // Delegate bean definition registration to scanner class. 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)); } ... parseTypeFilters(element, scanner, parserContext); return scanner; } 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() { this.includeFilters.add(new AnnotationTypeFilter(Component.class)); ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader(); try { this.includeFilters.add(new AnnotationTypeFilter( ((Class<? extends Annotation>) ClassUtils.forName('javax.annotation.ManagedBean', cl)), false)); logger.trace('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 { this.includeFilters.add(new AnnotationTypeFilter( ((Class<? extends Annotation>) ClassUtils.forName('javax.inject.Named', cl)), false)); logger.trace('JSR-330 ’javax.inject.Named’ annotation found and supported for component scanning'); } catch (ClassNotFoundException ex) { // JSR-330 API not available - simply skip. } } protected void parseTypeFilters(Element element, ClassPathBeanDefinitionScanner scanner, ParserContext parserContext) { // Parse exclude and include filter elements. ClassLoader classLoader = scanner.getResourceLoader().getClassLoader(); // 將component-scan的子標簽include-filter和exclude-filter添加到scanner中 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 { if (INCLUDE_FILTER_ELEMENT.equals(localName)) { TypeFilter typeFilter = createTypeFilter((Element) node, classLoader, parserContext); scanner.addIncludeFilter(typeFilter); } 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()); } } } }

上面不重要的方法我已經刪掉了，首先獲取use-default-filters屬性，傳入到ClassPathBeanDefinitionScanner構造器中判斷是否使用默認的過濾器，如果是就調用registerDefaultFilters方法將@Component注解過濾器添加到includeFilters屬性中；

創建后緊接著調用了parseTypeFilters方法去解析include-filter和exclude-filter子標簽，并分別添加到includeFilters和excludeFilters標簽中（關于這兩個標簽的作用這里不再贅述），所以這一步就是創建包含過濾器的class掃描器，接著就可以調用scan方法完成掃描注冊了（如果我們要自定義注解是不是也可以這樣實現呢？）。

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) { // 這里就是實際掃描符合條件的類并封裝為ScannedGenericBeanDefinition對象 Set<BeanDefinition> candidates = findCandidateComponents(basePackage); // 接著在每個單獨解析未解析的信息并注冊到緩存中 for (BeanDefinition candidate : candidates) { ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate); candidate.setScope(scopeMetadata.getScopeName()); String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry); if (candidate instanceof AbstractBeanDefinition) { postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName); } // 解析@Lazy、@Primary、@DependsOn等注解 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); registerBeanDefinition(definitionHolder, this.registry); } } } return beanDefinitions; } public Set<BeanDefinition> findCandidateComponents(String basePackage) { if (this.componentsIndex != null && indexSupportsIncludeFilters()) { return addCandidateComponentsFromIndex(this.componentsIndex, basePackage); } else { // 主要看這，掃描所有符合條件的class文件并封裝為ScannedGenericBeanDefinition return scanCandidateComponents(basePackage); } } private Set<BeanDefinition> scanCandidateComponents(String basePackage) { Set<BeanDefinition> candidates = new LinkedHashSet<>(); try { String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + resolveBasePackage(basePackage) + ’/’ + this.resourcePattern; // 獲取class文件并加載為Resource Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath); boolean traceEnabled = logger.isTraceEnabled(); boolean debugEnabled = logger.isDebugEnabled(); for (Resource resource : resources) { if (traceEnabled) { logger.trace('Scanning ' + resource); } if (resource.isReadable()) { try { // 獲取SimpleMetadataReader對象，該對象持有AnnotationMetadataReadingVisitor對象 MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource); if (isCandidateComponent(metadataReader)) { // 將AnnotationMetadataReadingVisitor對象設置到ScannedGenericBeanDefinition中 ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader); sbd.setResource(resource); sbd.setSource(resource); if (isCandidateComponent(sbd)) { if (debugEnabled) { logger.debug('Identified candidate component class: ' + resource); } candidates.add(sbd); } } } } } } return candidates; }

這個方法實現很復雜，首先是掃描找到符合條件的類并封裝成BeanDefinition對象，接著去設置該對象是否可作為根據類型自動裝配的標記，然后解析@Lazy、@Primary、@DependsOn等注解，最后才將其注冊到容器中。

需要注意的是和xml解析不同的是在掃描過程中，創建的是ScannedGenericBeanDefinition對象：

該類是GenericBeanDefinition對象的子類，并持有了AnnotationMetadata對象的引用，進入下面這行代碼：

MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);

我們可以發現AnnotationMetadata實際上是AnnotationMetadataReadingVisitor對象：

從上圖中我們可以看到該對象具有很多屬性，基本上包含了我們類的所有信息，所以后面在對象實例化時需要的信息都是來自于這里。

以上就是Spring注解的掃描解析過程，現在還剩一個方法registerComponents，它是做什么的呢？

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

在該標簽中有一個屬性annotation-config，該屬性的作用是，當配置為true時，才會去注冊一個個BeanPostProcessor類，這個類非常重要，比如：ConfigurationClassPostProcessor支持@Configuration注解，AutowiredAnnotationBeanPostProcessor支持@Autowired注解，CommonAnnotationBeanPostProcessor支持@Resource、@PostConstruct、@PreDestroy等注解。這里只是簡單提提，詳細分析留待后篇。

至此，自定義標簽和注解的解析原理就分析完了，下面就看看如何定義我們自己的標簽。

定義我們自己的標簽

通過上面的分析，我相信對于定義自己的標簽流程應該大致清楚了，如下：

首先設計一個標簽并定義其NamespaceHandler類，讓它繼承NamespaceHandlerSupport類；

其次定義標簽對應的解析器，并實現parse方法，在parse方法中解析我們的標簽，將其封裝為BeanDefinition對象并注冊到容器中；

最后在classpath/META-INF文件夾下創建一個spring.handler文件，并定義標簽的命名空間和NamespaceHandler的映射關系。

這就是我們從之前的源碼分析中理解到的，但這里實際還忽略了一個步驟，這也是之前分析時沒講到的，你能想到是什么么？我們設計的標簽需不需要一個規范？不可能讓其他人隨便寫，否則怎么識別呢？因此需要一個規范約束。同樣，在Spring的META-INF文件夾下都會有一個spring.schemas文件，該文件和spring.handler文件一樣，定義了約束文件和約束命名空間的映射關系，下面就是context的spring.schemas文件部分內容：

http://www.springframework.org/schema/context/spring-context-2.5.xsd=org/springframework/context/config/spring-context.xsd

......

http://www.springframework.org/schema/cache/spring-cache.xsd=org/springframework/cache/config/spring-cache.xsd

但是這個文件是在什么時候被讀取的呢？是不是應該在解析xml之前就把規范設置好？實際上就是在調用XmlBeanDefinitionReader的doLoadDocument方法時讀取的該文件：

protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception { return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler, getValidationModeForResource(resource), isNamespaceAware()); } protected EntityResolver getEntityResolver() { if (this.entityResolver == null) { // Determine default EntityResolver to use. ResourceLoader resourceLoader = getResourceLoader(); if (resourceLoader != null) { this.entityResolver = new ResourceEntityResolver(resourceLoader); } else { this.entityResolver = new DelegatingEntityResolver(getBeanClassLoader()); } } return this.entityResolver; } public DelegatingEntityResolver(@Nullable ClassLoader classLoader) { this.dtdResolver = new BeansDtdResolver(); this.schemaResolver = new PluggableSchemaResolver(classLoader); } public static final String DEFAULT_SCHEMA_MAPPINGS_LOCATION = 'META-INF/spring.schemas'; public PluggableSchemaResolver(@Nullable ClassLoader classLoader) { this.classLoader = classLoader; this.schemaMappingsLocation = DEFAULT_SCHEMA_MAPPINGS_LOCATION; }

總結

通過兩篇文章完成了對Spring XML標簽和注解解析的源碼分析，整體流程多看幾遍還是不復雜，關鍵是要學習到其中的設計思想：裝飾、模板、委托、SPI；

掌握其中我們可以使用到的擴展點：xml解析前后擴展、自定義標簽擴展、自定義注解擴展（本篇沒有講解，可以思考一下）；深刻理解BeanDefinition對象，可以看到所有標簽和注解類都會封裝為該對象，因此接下來對象實例化都是根據該對象進行的。

以上這篇這一次搞懂Spring自定義標簽以及注解解析原理說明就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持好吧啦網。