spring 自定义标签(component-scan)的详细解析二

今天药忘吃喽~ 2023-10-07 12:49 15阅读 0赞

上一篇我们讲解了spring.xml 和默认标签的解析过程，今天我们重点讲解自定义标签 （以注解扫描标签component-scan为例），详细讲解扫描标签的解析过程并把有注解的类，封装成BeanDefinition对象。

spring.xml配置为：

注意这里：上面的 xmlns:context="http://www.springframework.org/schema/context" 和 <context：这类自定义标签是向对应的，后面的业务会通过SPI思想寻找相应的实现类。

1、从DefaultBeanDefinitionDocumentReader 里开始

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

2、进入BeanDefinitionParserDelegate

@Nullable
    public BeanDefinition parseCustomElement(Element ele) {
       return parseCustomElement(ele, null);//继续点击
    }

a、根据当前解析标签的头信息找到对应的namespaceUri

e、根据namespaceUri找到对应的解析类，然后调用paser方法完成标签解析

@Nullable
    public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
    //获取标签的uri 例如注解标签的uri：http\://www.springframework.org/schema/context
       String namespaceUri = getNamespaceURI(ele);
       if (namespaceUri == null) {
          return null;
       }
    //spi思想，通过uri获取对应的解析类如：org.springframework.context.config.ContextNamespaceHandler，
    //详细看一下这个类的获取方式，在resolve 上ctrl+t进入
       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));
    }

3、DefaultNamespaceHandlerResolver 中

b、加载spring所有jar中的spring.handlers文件。并建立映射关系

c、 然后根据namespaceUri从映射关系中找到对应的实现了NamespaceHandler接口的类

d、调用类的init方法，init方法是注册了各种自定义标签的解析类

@Override
    @Nullable
    public NamespaceHandler resolve(String namespaceUri) {
       //获取spring中所有jar包里面所有的 "META-INF/spring.handlers"文件，并且建立映射关系
       Map<String, Object> handlerMappings = getHandlerMappings();
       //根据namespaceUri：http://www.springframework.org/schema/p，获取到这个命名空间的处理类
       Object handlerOrClassName = handlerMappings.get(namespaceUri);
       if (handlerOrClassName == null) {
          return null;
       }
       else if (handlerOrClassName instanceof NamespaceHandler) {
          return (NamespaceHandler) handlerOrClassName;
       }
       else {
          String className = (String) handlerOrClassName;
          try {//通过反射获取解析类
             Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
             if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
                throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
                      "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
             }//通过单例获取一个
             NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
             //调用处理类的init方法，在init方法中完成标签元素解析类的注册，这里很重要，一会还有用到，可以自己看一下
             namespaceHandler.init();
             handlerMappings.put(namespaceUri, namespaceHandler);//通过map形式保存起来
             return namespaceHandler;
          }
           //删除暂时无用的
       }
    }

namespaceHandler.init();初始化：来到这发现很多自定义标签

public class ContextNamespaceHandler extends NamespaceHandlerSupport {
    
    	@Override
    	public void init() {
    		registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());
    		registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());
    		registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());
    		registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());
    		registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());
    		registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    		registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());
    		registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());
    	}
    
    }

选择一个看看进入：自定义标签名和对应的解析实现类放到map中，value是接口名，后面解析用到。

private final Map<String, BeanDefinitionParser> parsers = new HashMap<>();
    
    protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {
    		this.parsers.put(elementName, parser);
    	}

初始化之后，map中value值由类的全路径名称换成实体类，供下游使用。

![2f62162563c24b60ac6e1420fa8561a4.png][] META-INF/spring.handlers 文件中内容在context相关jar中：

![78b47a761c42459fa377d44e0d20bc77.png][]

getHandlerMappings()建立映射关系：

private Map<String, Object> getHandlerMappings() {
    		Map<String, Object> handlerMappings = this.handlerMappings;
    		if (handlerMappings == null) {
    			synchronized (this) {
    				handlerMappings = this.handlerMappings;
    				if (handlerMappings == null) {
    					if (logger.isTraceEnabled()) {
    						logger.trace("Loading NamespaceHandler mappings from [" + this.handlerMappingsLocation + "]");
    					}
    					try {
    						//加载"META-INF/spring.handlers"文件过程
    						Properties mappings =
    								PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
    						if (logger.isTraceEnabled()) {
    							logger.trace("Loaded NamespaceHandler mappings: " + mappings);
    						}
    						//所有"META-INF/spring.handlers"文件里面的内容建立映射关系
    						handlerMappings = new ConcurrentHashMap<>(mappings.size());
    						CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
    						this.handlerMappings = handlerMappings;
    					}
    					catch (IOException ex) {
    						throw new IllegalStateException(
    								"Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
    					}
    				}
    			}
    		}
    		return handlerMappings;
    	}

这时候发现 this.handlerMappings 本身不为空，因为上面的步骤添加了部分数据。、

![93f3633dfe7b497a9b6466bb32563704.png][]

已经加入了映射关系，那么从哪个阶段添加的呢？这时候我们应该回到上面找到流转化成Document 的流程看看。

![3651392d063d467ca8dd6ff842483fbe.png][]

这里也有JDK的API我们详细看看

[参考赋值][Link 1]

4、点击handler.parse 方法 进入NamespaceHandler的实现类 NamespaceHandlerSupport implements NamespaceHandler 这里，也是ContextNamespaceHandler的父类

如图：

![528ac80ef5634a38b3a689a9add3e9d1.png][]

代码

@Override
    @Nullable
    public BeanDefinition parse(Element element, ParserContext parserContext) {
    //这里去map中去解析类，找到对应的实现类，接口
       BeanDefinitionParser parser = findParserForElement(element, parserContext);
    //然后ctrl+t进入 ，开始正式解析自定义标签
       return (parser != null ? parser.parse(element, parserContext) : null);
    }

取出实现类接口： 调用paser方法完成标签解析

@Nullable
    private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
       String localName = parserContext.getDelegate().getLocalName(element);
     //上面初始化init方法时已经存好，直接取就行
    //这里通过 "component-scan",取到 new ComponentScanBeanDefinitionParser() 这个类
       BeanDefinitionParser parser = this.parsers.get(localName);
       if (parser == null) {
          parserContext.getReaderContext().fatal(
                "Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
       }
       return parser;
    }

5、点击parser.parse 方法 进入ComponentScanBeanDefinitionParser implements BeanDefinitionParser 类中，即实现类，上游取出来的，如图：

![ffa739545222498b96b6193c98927e08.png][]

1、扫描路径。.class后缀的文件、要判断类上是否有注解、如果有注解完成beanDefinition注册

@Override
    @Nullable
    public BeanDefinition parse(Element element, ParserContext parserContext) {
       //获取basePackage属性  例如：base-package="com.nandao.test"，或 com.enjoy.jack
       String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
       basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
       //可以用逗号分开，即可以有多个路径
       String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
             ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
       //创建注解扫描器
       ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
       //扫描并把扫描的类封装成beanDefinition对象  核心方法，点击进入
       Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
       registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
       return null;
    }

如图：

![a427f8e11a0141dc9455439b37b493c0.png][]

创建注解扫描器： configureScanner(parserContext, element);

protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
    		boolean useDefaultFilters = true;
    		if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
    			useDefaultFilters = Boolean.parseBoolean(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
    		}
    
    		// 此处重点，把 @Component 初始化到集合里
    		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 {
    			parseBeanNameGenerator(element, scanner);
    		}
    		catch (Exception ex) {
    			parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
    		}
    
    		try {
    			parseScope(element, scanner);
    		}
    		catch (Exception ex) {
    			parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
    		}
    
    		parseTypeFilters(element, scanner, parserContext);
    
    		return scanner;
    	}

进入：

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() {
            //注解初始化到list中 private final List<TypeFilter> includeFilters = new LinkedList<>();
    		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.
    		}
    	}

6、进入 ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider 类

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) {
          //1、循环扫描到有注解的类并封装成BeanDefinition对象，点击进入
          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);
             }
             if (candidate instanceof AnnotatedBeanDefinition) {
                //支持了@Lazy @DependOn注解
                AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
             }
             if (checkCandidate(beanName, candidate)) {
                BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                //这里不看
                definitionHolder =
                      AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                beanDefinitions.add(definitionHolder);
    
                //2、BeanDefinition注册，核心方法 点击进入
                registerBeanDefinition(definitionHolder, this.registry);
             }
          }
       }
       return beanDefinitions;
    }

protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
    //点击进入 BeanDefinitionReaderUtils 类
       BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
    }

7、来到ClassPathScanningCandidateComponentProvider implements EnvironmentCapable, ResourceLoaderAware

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
       if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
          return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
       }
       else {//此方法循环递归扫描 文件夹里的文件并生成beanDefinition,点击进入
          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;
    
          //这里递归寻找文件
          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 {
                   //包装了类的基本信息的对象
                   MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
                   //如果类上面有includeFilters注解即 @Component 注解，就生成ScannedGenericBeanDefinition
                   if (isCandidateComponent(metadataReader)) {
                      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);//统一放到BeanDefinition集合里
                      }
             //删除不重要的代码，节约空间
       }
        
       return candidates;
    }

判断 接口(isCandidateComponent(metadataReader))

protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
    		for (TypeFilter tf : this.excludeFilters) {
    			if (tf.match(metadataReader, getMetadataReaderFactory())) {
    				return false;
    			}
    		}
          //这个在上面创建注解扫描器的时候已经添加了 @Component ，此时在这里过滤
    		for (TypeFilter tf : this.includeFilters) {
    			if (tf.match(metadataReader, getMetadataReaderFactory())) {
    				return isConditionMatch(metadataReader);
    			}
    		}
    		return false;
    	}

8、BeanDefinitionReaderUtils 工具类

public static void registerBeanDefinition(
          BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
          throws BeanDefinitionStoreException {
    
       // Register bean definition under primary name.
       String beanName = definitionHolder.getBeanName();
    
       //完成BeanDefinition的注册，重点看，进去后你就有似曾相识的感觉！ctrl+t 进入
       registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
    
       //建立别名和 id的映射，这样就可以根据别名获取到id
       // Register aliases for bean name, if any.
       String[] aliases = definitionHolder.getAliases();
       if (aliases != null) {
          for (String alias : aliases) {
             registry.registerAlias(beanName, alias);
          }
       }
    }

9、来到 DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable 类，在上一篇解析spring 默认标签的时候，最终也是进入到这个方法处理beanDefinition

@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();
          }
         
    
       //先判断BeanDefinition是否已经注册
       BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
       if (existingDefinition != null) {
          if (!isAllowBeanDefinitionOverriding()) {
             throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
          }
         //不重要的暂时删除
       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;
                if (this.manualSingletonNames.contains(beanName)) {
                   Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                   updatedSingletons.remove(beanName);
                   this.manualSingletonNames = updatedSingletons;
                }
             }
          }
          else {
             //把beanDefinition缓存到map中
             // Still in startup registration phase
             this.beanDefinitionMap.put(beanName, beanDefinition);
    
             //把beanName放到beanDefinitionNames list中，这个list着重记住，bean实例化的时候需要用到
             this.beanDefinitionNames.add(beanName);
             this.manualSingletonNames.remove(beanName);
          }
          this.frozenBeanDefinitionNames = null;
       }
       if (existingDefinition != null || containsSingleton(beanName)) {
          resetBeanDefinition(beanName);
       }
    }

看看这个接口registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

主要为了三个对象：

ConfigurationClassPostProcessor 、AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor

这三个对象后面的业务会重点使用

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.parseBoolean(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);
    	}

点击：

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

10、到这里我们完全解析了spring 的自定义标签，核心流程做了大概讲解，由于篇幅问题，没有面面俱到。如果小伙伴看到这里有任何不明白的地方，随时留意。下篇内容更精彩，敬请期待！

[2f62162563c24b60ac6e1420fa8561a4.png]: https://img-blog.csdnimg.cn/2f62162563c24b60ac6e1420fa8561a4.png
[78b47a761c42459fa377d44e0d20bc77.png]: https://img-blog.csdnimg.cn/78b47a761c42459fa377d44e0d20bc77.png
[93f3633dfe7b497a9b6466bb32563704.png]: https://img-blog.csdnimg.cn/93f3633dfe7b497a9b6466bb32563704.png
[3651392d063d467ca8dd6ff842483fbe.png]: https://img-blog.csdnimg.cn/3651392d063d467ca8dd6ff842483fbe.png
[Link 1]: https://blog.csdn.net/nandao158/article/details/125683812?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22125683812%22%2C%22source%22%3A%22nandao158%22%7D&ctrtid=NtSQh
[528ac80ef5634a38b3a689a9add3e9d1.png]: https://img-blog.csdnimg.cn/528ac80ef5634a38b3a689a9add3e9d1.png
[ffa739545222498b96b6193c98927e08.png]: https://img-blog.csdnimg.cn/ffa739545222498b96b6193c98927e08.png
[a427f8e11a0141dc9455439b37b493c0.png]: https://img-blog.csdnimg.cn/a427f8e11a0141dc9455439b37b493c0.png