這一次搞懂Spring自定義標(biāo)簽以及注解解析原理說(shuō)明

更新時(shí)間：2020年08月27日 10:29:21 作者：夜勿語(yǔ)

這篇文章主要介紹了這一次搞懂Spring自定義標(biāo)簽以及注解解析原理說(shuō)明，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。一起跟隨小編過(guò)來(lái)看看吧

前言

在上一篇文章中分析了Spring是如何解析默認(rèn)標(biāo)簽的，并封裝為BeanDefinition注冊(cè)到緩存中，這一篇就來(lái)看看對(duì)于像context這種自定義標(biāo)簽是如何解析的。同時(shí)我們常用的注解如：@Service、@Component、@Controller標(biāo)注的類(lèi)也是需要在xml中配置<context:component-scan>才能自動(dòng)注入到IOC容器中，所以本篇也會(huì)重點(diǎn)分析注解解析原理。

正文

自定義標(biāo)簽解析原理

在上一篇分析默認(rèn)標(biāo)簽解析時(shí)看到過(guò)這個(gè)類(lèi)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)) {

  //默認(rèn)標(biāo)簽解析
  parseDefaultElement(ele, delegate);
  }
  else {

  //自定義標(biāo)簽解析
  delegate.parseCustomElement(ele);
  }
 }
 }
 }
 else {
 delegate.parseCustomElement(root);
 }
 }

現(xiàn)在我們就來(lái)看看parseCustomElement這個(gè)方法，但在點(diǎn)進(jìn)去之前不妨想想自定義標(biāo)簽解析應(yīng)該怎么做。

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

可以看到和默認(rèn)標(biāo)簽解析是一樣的，只不過(guò)由decorate方法改為了parse方法，但具體是如何解析的呢？這里我就以component-scan標(biāo)簽的解析為例，看看注解是如何解析為BeanDefinition對(duì)象的。

注解解析原理

進(jìn)入到parse方法中，首先會(huì)進(jìn)入NamespaceHandlerSupport類(lèi)中：

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

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

下面就來(lái)驗(yàn)證我們的猜想：

 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.
 // 創(chuàng)造ClassPathBeanDefinitionScanner對(duì)象，用來(lái)掃描basePackage包下符合條件（默認(rèn)是@Component標(biāo)注的類(lèi)）的類(lèi)，
 // 并創(chuàng)建BeanDefinition類(lèi)注冊(cè)到緩存中
 ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
 Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
 registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

 return null;
 }

可以看到流程和我們猜想的基本一致，首先創(chuàng)建了一個(gè)掃描器ClassPathBeanDefinitionScanner對(duì)象，然后通過(guò)這個(gè)掃描器去掃描classpath下的文件并注冊(cè)，最后調(diào)用了registerComponents方法，這個(gè)方法的作用稍后來(lái)講，我們先來(lái)看看掃描器是如何創(chuàng)建的：

 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的子標(biāo)簽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());
 }
 }
 }
 }

上面不重要的方法我已經(jīng)刪掉了，首先獲取use-default-filters屬性，傳入到ClassPathBeanDefinitionScanner構(gòu)造器中判斷是否使用默認(rèn)的過(guò)濾器，如果是就調(diào)用registerDefaultFilters方法將@Component注解過(guò)濾器添加到includeFilters屬性中；

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

 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) {
 // 這里就是實(shí)際掃描符合條件的類(lèi)并封裝為ScannedGenericBeanDefinition對(duì)象
 Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
 // 接著在每個(gè)單獨(dú)解析未解析的信息并注冊(cè)到緩存中
 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對(duì)象，該對(duì)象持有AnnotationMetadataReadingVisitor對(duì)象
  MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
  if (isCandidateComponent(metadataReader)) {
  // 將AnnotationMetadataReadingVisitor對(duì)象設(shè)置到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;
 }

這個(gè)方法實(shí)現(xiàn)很復(fù)雜，首先是掃描找到符合條件的類(lèi)并封裝成BeanDefinition對(duì)象，接著去設(shè)置該對(duì)象是否可作為根據(jù)類(lèi)型自動(dòng)裝配的標(biāo)記，然后解析@Lazy、@Primary、@DependsOn等注解，最后才將其注冊(cè)到容器中。

需要注意的是和xml解析不同的是在掃描過(guò)程中，創(chuàng)建的是ScannedGenericBeanDefinition對(duì)象：

該類(lèi)是GenericBeanDefinition對(duì)象的子類(lèi)，并持有了AnnotationMetadata對(duì)象的引用，進(jìn)入下面這行代碼：

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

我們可以發(fā)現(xiàn)AnnotationMetadata實(shí)際上是AnnotationMetadataReadingVisitor對(duì)象：

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

以上就是Spring注解的掃描解析過(guò)程，現(xiàn)在還剩一個(gè)方法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);
 }

在該標(biāo)簽中有一個(gè)屬性annotation-config，該屬性的作用是，當(dāng)配置為true時(shí)，才會(huì)去注冊(cè)一個(gè)個(gè)BeanPostProcessor類(lèi)，這個(gè)類(lèi)非常重要，比如：ConfigurationClassPostProcessor支持@Configuration注解，AutowiredAnnotationBeanPostProcessor支持@Autowired注解，CommonAnnotationBeanPostProcessor支持@Resource、@PostConstruct、@PreDestroy等注解。這里只是簡(jiǎn)單提提，詳細(xì)分析留待后篇。

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

定義我們自己的標(biāo)簽

通過(guò)上面的分析，我相信對(duì)于定義自己的標(biāo)簽流程應(yīng)該大致清楚了，如下：

首先設(shè)計(jì)一個(gè)標(biāo)簽并定義其N(xiāo)amespaceHandler類(lèi)，讓它繼承NamespaceHandlerSupport類(lèi)；

其次定義標(biāo)簽對(duì)應(yīng)的解析器，并實(shí)現(xiàn)parse方法，在parse方法中解析我們的標(biāo)簽，將其封裝為BeanDefinition對(duì)象并注冊(cè)到容器中；

最后在classpath/META-INF文件夾下創(chuàng)建一個(gè)spring.handler文件，并定義標(biāo)簽的命名空間和NamespaceHandler的映射關(guān)系。

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

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

但是這個(gè)文件是在什么時(shí)候被讀取的呢？是不是應(yīng)該在解析xml之前就把規(guī)范設(shè)置好？實(shí)際上就是在調(diào)用XmlBeanDefinitionReader的doLoadDocument方法時(shí)讀取的該文件：

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

總結(jié)

通過(guò)兩篇文章完成了對(duì)Spring XML標(biāo)簽和注解解析的源碼分析，整體流程多看幾遍還是不復(fù)雜，關(guān)鍵是要學(xué)習(xí)到其中的設(shè)計(jì)思想：裝飾、模板、委托、SPI；

掌握其中我們可以使用到的擴(kuò)展點(diǎn)：xml解析前后擴(kuò)展、自定義標(biāo)簽擴(kuò)展、自定義注解擴(kuò)展（本篇沒(méi)有講解，可以思考一下）；深刻理解BeanDefinition對(duì)象，可以看到所有標(biāo)簽和注解類(lèi)都會(huì)封裝為該對(duì)象，因此接下來(lái)對(duì)象實(shí)例化都是根據(jù)該對(duì)象進(jìn)行的。

以上這篇這一次搞懂Spring自定義標(biāo)簽以及注解解析原理說(shuō)明就是小編分享給大家的全部?jī)?nèi)容了，希望能給大家一個(gè)參考，也希望大家多多支持腳本之家。

您可能感興趣的文章: