這一次搞懂Spring自定義標(biāo)簽以及注解解析原理說明
前言
在上一篇文章中分析了Spring是如何解析默認標(biāo)簽的，并封裝為BeanDefinition注冊到緩存中，這一篇就來看看對于像context這種自定義標(biāo)簽是如何解析的。同時我們常用的注解如：@Service、@Component、@Controller標(biāo)注的類也是需要在xml中配置<context:component-scan>才能自動注入到IOC容器中，所以本篇也會重點分析注解解析原理。
正文
自定義標(biāo)簽解析原理
在上一篇分析默認標(biāo)簽解析時看到過這個類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)) {
//默認標(biāo)簽解析
parseDefaultElement(ele, delegate);
}
else {
//自定義標(biāo)簽解析
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}
現(xiàn)在我們就來看看parseCustomElement這個方法，但在點進去之前不妨想想自定義標(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));
}
可以看到和默認標(biāo)簽解析是一樣的，只不過由decorate方法改為了parse方法，但具體是如何解析的呢？這里我就以component-scan標(biāo)簽的解析為例，看看注解是如何解析為BeanDefinition對象的。
注解解析原理
進入到parse方法中，首先會進入NamespaceHandlerSupport類中：
public BeanDefinition parse(Element element, ParserContext parserContext) {
BeanDefinitionParser parser = findParserForElement(element, parserContext);
return (parser != null ? parser.parse(element, parserContext) : null);
}
首先通過findParserForElement方法去找到對應(yīng)的解析器，然后委托給解析器ComponentScanBeanDefinitionParser解析。在往下看之前，我們先想一想，如果是我們自己要去實現(xiàn)這個注解解析過程會怎么做。是不是應(yīng)該首先通過配置的basePackage屬性，去掃描該路徑下所有的class文件，然后判斷class文件是否符合條件，即是否標(biāo)注了@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.
// 創(chuàng)造ClassPathBeanDefinitionScanner對象，用來掃描basePackage包下符合條件（默認是@Component標(biāo)注的類）的類，
// 并創(chuàng)建BeanDefinition類注冊到緩存中
ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
return null;
}
可以看到流程和我們猜想的基本一致，首先創(chuàng)建了一個掃描器ClassPathBeanDefinitionScanner對象，然后通過這個掃描器去掃描classpath下的文件并注冊，最后調(diào)用了registerComponents方法，這個方法的作用稍后來講，我們先來看看掃描器是如何創(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)造器中判斷是否使用默認的過濾器，如果是就調(diào)用registerDefaultFilters方法將@Component注解過濾器添加到includeFilters屬性中；
創(chuàng)建后緊接著調(diào)用了parseTypeFilters方法去解析include-filter和exclude-filter子標(biāo)簽，并分別添加到includeFilters和excludeFilters標(biāo)簽中（關(guān)于這兩個標(biāo)簽的作用這里不再贅述），所以這一步就是創(chuàng)建包含過濾器的class掃描器，接著就可以調(diào)用scan方法完成掃描注冊了（如果我們要自定義注解是不是也可以這樣實現(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) {
// 這里就是實際掃描符合條件的類并封裝為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對象設(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;
}
這個方法實現(xiàn)很復(fù)雜，首先是掃描找到符合條件的類并封裝成BeanDefinition對象，接著去設(shè)置該對象是否可作為根據(jù)類型自動裝配的標(biāo)記，然后解析@Lazy、@Primary、@DependsOn等注解，最后才將其注冊到容器中。
需要注意的是和xml解析不同的是在掃描過程中，創(chuàng)建的是ScannedGenericBeanDefinition對象：
該類是GenericBeanDefinition對象的子類，并持有了AnnotationMetadata對象的引用，進入下面這行代碼：
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
我們可以發(fā)現(xiàn)AnnotationMetadata實際上是AnnotationMetadataReadingVisitor對象：
從上圖中我們可以看到該對象具有很多屬性，基本上包含了我們類的所有信息，所以后面在對象實例化時需要的信息都是來自于這里。
以上就是Spring注解的掃描解析過程，現(xiàn)在還剩一個方法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)簽中有一個屬性annotation-config，該屬性的作用是，當(dāng)配置為true時，才會去注冊一個個BeanPostProcessor類，這個類非常重要，比如：ConfigurationClassPostProcessor支持@Configuration注解，AutowiredAnnotationBeanPostProcessor支持@Autowired注解，CommonAnnotationBeanPostProcessor支持@Resource、@PostConstruct、@PreDestroy等注解。這里只是簡單提提，詳細分析留待后篇。
至此，自定義標(biāo)簽和注解的解析原理就分析完了，下面就看看如何定義我們自己的標(biāo)簽。
定義我們自己的標(biāo)簽
通過上面的分析，我相信對于定義自己的標(biāo)簽流程應(yīng)該大致清楚了，如下：
首先設(shè)計一個標(biāo)簽并定義其NamespaceHandler類，讓它繼承NamespaceHandlerSupport類；
其次定義標(biāo)簽對應(yīng)的解析器，并實現(xiàn)parse方法，在parse方法中解析我們的標(biāo)簽，將其封裝為BeanDefinition對象并注冊到容器中；
最后在classpath/META-INF文件夾下創(chuàng)建一個spring.handler文件，并定義標(biāo)簽的命名空間和NamespaceHandler的映射關(guān)系。
這就是我們從之前的源碼分析中理解到的，但這里實際還忽略了一個步驟，這也是之前分析時沒講到的，你能想到是什么么？我們設(shè)計的標(biāo)簽需不需要一個規(guī)范？不可能讓其他人隨便寫，否則怎么識別呢？因此需要一個規(guī)范約束。同樣，在Spring的META-INF文件夾下都會有一個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
但是這個文件是在什么時候被讀取的呢？是不是應(yīng)該在解析xml之前就把規(guī)范設(shè)置好？實際上就是在調(diào)用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;
}
總結(jié)
通過兩篇文章完成了對Spring XML標(biāo)簽和注解解析的源碼分析，整體流程多看幾遍還是不復(fù)雜，關(guān)鍵是要學(xué)習(xí)到其中的設(shè)計思想：裝飾、模板、委托、SPI；
掌握其中我們可以使用到的擴展點：xml解析前后擴展、自定義標(biāo)簽擴展、自定義注解擴展（本篇沒有講解，可以思考一下）；深刻理解BeanDefinition對象，可以看到所有標(biāo)簽和注解類都會封裝為該對象，因此接下來對象實例化都是根據(jù)該對象進行的。
以上這篇這一次搞懂Spring自定義標(biāo)簽以及注解解析原理說明就是小編分享給大家的全部內(nèi)容了，希望能給大家一個參考，也希望大家多多支持腳本之家。
- Springboot項目使用html5的video標(biāo)簽完成視頻播放功能
- SpringBoot使用Thymeleaf自定義標(biāo)簽的實例代碼
- springboot 自定義權(quán)限標(biāo)簽(tld),在freemarker引用操作
- SpringMVC form標(biāo)簽引入及使用方法
- Spring Cloud體系實現(xiàn)標(biāo)簽路由的方法示例
- spring boot 集成 shiro 自定義密碼驗證 自定義freemarker標(biāo)簽根據(jù)權(quán)限渲染不同頁面(推薦
- springboot 在ftl頁面上使用shiro標(biāo)簽的實例代碼
- Spring源碼解密之默認標(biāo)簽的解析
- SpringMVC表單標(biāo)簽知識點詳解
- 如何使用Spring自定義Xml標(biāo)簽
相關(guān)文章
關(guān)于application.yml數(shù)據(jù)庫配置方式
這篇文章主要介紹了關(guān)于application.yml數(shù)據(jù)庫配置方式,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-08-08
這篇文章主要介紹了SpringBoot整合JDBC的實現(xiàn)，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-01-01
Java獲取接口的所有實現(xiàn)類方法總結(jié)示例
這篇文章主要給大家介紹了關(guān)于Java獲取接口的所有實現(xiàn)類方法的相關(guān)資料,文中通過代碼介紹的非常詳細,對大家的學(xué)習(xí)或者工作具有一定的參考借鑒價值,需要的朋友可以參考下2024-06-06
SpringBoot整合Shiro實現(xiàn)登錄認證的方法
這篇文章主要介紹了SpringBoot整合Shiro實現(xiàn)登錄認證的方法，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-02-02
這篇文章主要介紹了Eclipse+Webservice簡單開發(fā)實例的相關(guān)資料,需要的朋友可以參考下2016-02-02
這篇文章主要介紹了JVM系列之:再談java中的safepoint說明，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-09-09
這篇文章主要介紹了基數(shù)排序簡介及Java語言實現(xiàn)，涉及基數(shù)排序的基本思想簡單介紹和桶排序的分析，以及基數(shù)排序的Java實現(xiàn)，具有一定借鑒價值，需要的朋友可以參考下。2017-11-11
SpringCloud之消息總線Spring Cloud Bus實例代碼
這篇文章主要介紹了SpringCloud之消息總線Spring Cloud Bus實例代碼，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-04-04
今天咱們要聊的是Guava在異步編程中的應(yīng)用,讓我們搞清楚為什么要用Guava來處理異步任務(wù),在Java的世界里，異步編程是個老話題了，但它依舊非常關(guān)鍵,它能讓咱們的應(yīng)用更高效，尤其是在處理那些耗時的I/O操作2023-12-12
這篇文章主要介紹了Java字符串的壓縮與解壓縮的兩種方法，文中通過示例代碼介紹的非常詳細，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-03-03