2. 程式人生 > >29--aspectj-autoproxy解析及Spring解析自定義標籤

29--aspectj-autoproxy解析及Spring解析自定義標籤

阿新 • • 發佈：2018-12-17

前兩個小節已經介紹了AOP的一些基礎知識回顧並對靜態代理、JDK動態代理、CGLIB動態代理做了一些簡單的介紹，本節介紹AOP標籤的解析過程。

1.aspectj-autoproxy標籤簡介

使用註解方式應用aop需要在配置檔案中配置<aop:aspectj-autoproxy/>, 而該標籤有兩個屬性，proxy-target-class he expose-proxy

  • proxy-target-class 如果被代理的目標物件至少實現了一個介面，則會使用JDK動態代理，所有實現該目標類實現的介面都將被代理；如果該目標物件沒有實現任何介面，則建立CGLIB動態代理。但是可以通過proxy-target-class屬性強制指定使用CGLIB代理。所以如果指定了proxy-target-class="true"
    則將強制開啟CGLIB動態代理。
  • expose-proxy 解決目標物件內部的自我呼叫無法實施切面增強的問題。
2.aspectj-autoproxy標籤解析

在第十七小節，講解了Spring對預設標籤的解析過程，但是沒有對預設標籤解析進行分析，今天就來分析一下Spring是如何解析自定義標籤aspectj-autoproxy的。順便通過對該標籤的解析，補充十七節欠缺的分析。

  • 自定義標籤解析入口 開啟DefaultBeanDefinitionDocumentReader類的parseBeanDefinitions方法
protected void parseBeanDefinitions
 
(Element root, BeanDefinitionParserDelegate delegate) {
    // 1、解析預設名稱空間
    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);
                }
            }
        }
    }
    // 2、解析自定義名稱空間
    else {
        delegate.parseCustomElement(root);
    }
}

通過parseCustomElement解析自定義標籤

  • 自定義標籤解析過程
/**
 * 解析自定義標籤
 * @param ele
 * @param containingBd
 * @return
 */
@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
    // 1、獲取namespaceUri
    String namespaceUri = getNamespaceURI(ele);
    if (namespaceUri == null) {
        return null;
    }
    // 2、根據namespaceUri得到名稱空間解析器
    NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    if (handler == null) {
        error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
        return null;
    }
    // 2、使用名稱空間解析器解析自定義標籤
    return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

對自定義標籤的解析交給了NamespaceHandler介面，通過這個我們就可以知道，如果我們想在Spring中實現自己的自定義標籤，那麼就需要實現NamespaceHandler介面，並通過重寫其中的方法，來完成對自定義標籤的解析。

  • 獲取NamespaceHandler
public NamespaceHandler resolve(String namespaceUri) {
    // 1.獲取所有的namespaceUri，NamespaceHandler鍵值對map集合並得到
    // 當前namespaceUri對應的NamespaceHandler類
    Map<String, Object> handlerMappings = getHandlerMappings();
    Object handlerOrClassName = handlerMappings.get(namespaceUri);
    if (handlerOrClassName == null) {
        return null;
    }
    else if (handlerOrClassName instanceof NamespaceHandler) {
        return (NamespaceHandler) handlerOrClassName;
    }
    else {
        // 2、通過BeanUtils例項化NamespaceHandler並呼叫其init方法進行初始化操作
        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);
            namespaceHandler.init();
            handlerMappings.put(namespaceUri, namespaceHandler);
            return namespaceHandler;
        }
        catch (ClassNotFoundException ex) {
            throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
                    "] for namespace [" + namespaceUri + "]", ex);
        }
        catch (LinkageError err) {
            throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
                    className + "] for namespace [" + namespaceUri + "]", err);
        }
    }
}

該方法非常簡單，首先根據namespaceUri從所有的Map<namespaceUri,NamespaceHandler>中獲取對應的NamespaceHandler實現類，然後通過BeanUtils.instantiateClass例項化該類，最後呼叫NamespaceHandler例項的init方法。

  • AopNamespaceHandler的init方法
public void init() {
    // In 2.0 XSD as well as in 2.1 XSD.
    registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
    registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
    registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

    // Only in 2.0 XSD: moved to context namespace as of 2.1
    registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
}

在該方法中我們已經看到了aspectj-autoproxy標籤，該方法也很簡單，不做過多的分析。接下來分析aspectj-autoproxy解析的過程。

3.通過NamespaceHandler的parse方法解析aspectj-autoproxy標籤
public BeanDefinition parse(Element element, ParserContext parserContext) {
    BeanDefinitionParser parser = findParserForElement(element, parserContext);
    return (parser != null ? parser.parse(element, parserContext) : null);
}

具體的轉換工作委託給了BeanDefinitionParser例項：

public BeanDefinition parse(Element element, ParserContext parserContext) {
    // 1、註冊AnnotationAwareAspectJAutoProxyCreator
    AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
    // 2、處理子標籤<aop:include/>， 指定@Aspect類，支援正則表示式，符合該表示式的切面類才會被應用
    extendBeanDefinition(element, parserContext);
    return null;
}

該轉換過程主要完成兩個功能，註冊AnnotationAwareAspectJAutoProxyCreator和解析子標籤<aop:include/>，我們逐步分析一下：

3.1 註冊AnnotationAwareAspectJAutoProxyCreator
public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(ParserContext parserContext, Element sourceElement) {

    // 1、註冊AnnotationAwareAspectJAutoProxyCreator
    BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            parserContext.getRegistry(),
            parserContext.extractSource(sourceElement));
    // 2、解析子標籤 proxy-target-class 和 expose-proxy
    useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
    // 3、註冊元件併發送元件註冊事件
    registerComponentIfNecessary(beanDefinition, parserContext);
}
  • 註冊AnnotationAwareAspectJAutoProxyCreator
private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry,
			@Nullable Object source) {
    // cls --> org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
    // AUTO_PROXY_CREATOR_BEAN_NAME --> org.springframework.aop.config.internalAutoProxyCreator
    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
        // 如果registry已經包含了internalAutoProxyCreator，
        BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
        // 如果已經註冊的internalAutoProxyCreator不是AnnotationAwareAspectJAutoProxyCreator，則需要判斷優先順序並決定使用哪個
        if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
            int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
            int requiredPriority = findPriorityForClass(cls);
            if (currentPriority < requiredPriority) {
                apcDefinition.setBeanClassName(cls.getName());
            }
        }
        // 如果已經註冊的internalAutoProxyCreator是AnnotationAwareAspectJAutoProxyCreator，則無需特殊處理
        return null;
    }

    RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
    beanDefinition.setSource(source);
    // HIGHEST_PRECEDENCE --> 指定最高優先順序
    beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
    // ROLE_INFRASTRUCTURE --> 表示Spring的內部bean
    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    // 註冊BeanDefinition
    registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
    return beanDefinition;
}
  • 解析子標籤 proxy-target-class 和 expose-proxy
private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, @Nullable Element sourceElement) {
    if (sourceElement != null) {
        // PROXY_TARGET_CLASS_ATTRIBUTE --> proxy-target-class
        boolean proxyTargetClass = Boolean.parseBoolean(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
        if (proxyTargetClass) {
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
        }
        // EXPOSE_PROXY_ATTRIBUTE --> expose-proxy
        boolean exposeProxy = Boolean.parseBoolean(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
        if (exposeProxy) {
            AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
        }
    }
}

該過程最核心的作用就是註冊AnnotationAwareAspectJAutoProxyCreator，關於該類的作用，我們會在下面的章節分析。

3.2 處理子標籤<aop:include/>

<aop:include/>標籤的作用：例如有下面的配置檔案，並指定了<aop:include name="aspectJTest"></aop:include>，則aspectJTest切面類會被應用，且name支援正則表示式，如果配置檔案中的切面類不符合name的表示式，則切面類不會被應用。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

	<!--
		1、proxy-target-class
			如果被代理的目標物件至少實現了一個介面，則會使用JDK動態代理，所有實現該目標類實現的介面都將被代理
			如果該目標物件沒有實現任何介面，則建立CGLIB動態代理。
			但是可以通過proxy-target-class屬性強制指定使用CGLIB代理，
		2、expose-proxy
			解決目標物件內部的自我呼叫無法實施切面增強的問題
	-->
	<aop:aspectj-autoproxy proxy-target-class="true" expose-proxy="true">
		<!-- 指定@Aspect類，支援正則表示式，符合該表示式的切面類才會被應用-->
		<aop:include name="aspectJTest"></aop:include>
	</aop:aspectj-autoproxy>

	<bean id="aopTestBean" class="com.lyc.cn.v2.day04.AopTestBean"></bean>

	<bean name="aspectJTest" class="com.lyc.cn.v2.day04.AspectJTest"></bean>
</beans>

瞭解了標籤的作用之後，我們來看其解析過程，比較簡單就不附加註釋了：

private void extendBeanDefinition(Element element, ParserContext parserContext) {
    BeanDefinition beanDef = parserContext.getRegistry().getBeanDefinition(AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);
    if (element.hasChildNodes()) {
        addIncludePatterns(element, parserContext, beanDef);
    }
}

private void addIncludePatterns(Element element, ParserContext parserContext, BeanDefinition beanDef) {
    ManagedList<TypedStringValue> includePatterns = new ManagedList<>();
    NodeList childNodes = element.getChildNodes();
    for (int i = 0; i < childNodes.getLength(); i++) {
        Node node = childNodes.item(i);
        if (node instanceof Element) {
            Element includeElement = (Element) node;
            TypedStringValue valueHolder = new TypedStringValue(includeElement.getAttribute("name"));
            valueHolder.setSource(parserContext.extractSource(includeElement));
            includePatterns.add(valueHolder);
        }
    }
    if (!includePatterns.isEmpty()) {
        includePatterns.setSource(parserContext.extractSource(element));
        beanDef.getPropertyValues().add("includePatterns", includePatterns);
    }
}

那麼到這裡<aop:aspectj-autoproxy/>標籤的解析工作也就完成了。

4.總結

本節主要分析了<aop:aspectj-autoproxy/>標籤的解析，而該標籤也是Spring的自定義標籤，所以，如果大家有自己的自定義標籤時，可以參考借鑑Spring的原始碼，寫出自己的標籤解析過程。通過繼承NamespaceHandler實現自己的名稱空間解析器即可。

在解析<aop:aspectj-autoproxy/>的過程中，除了對標籤的解析工作之外，還註冊了AnnotationAwareAspectJAutoProxyCreator，該類的作用是什麼呢，我們留在下節分析。

相關推薦

29--aspectj-autoproxy解析及Spring解析自定義標籤

前兩個小節已經介紹了AOP的一些基礎知識回顧並對靜態代理、JDK動態代理、CGLIB動態代理做了一些簡單的介紹，本節介紹AOP標籤的解析過程。 1.aspectj-autoproxy標籤簡介 使用註解方式應用aop需要在配置檔案中配置<aop:aspect

32--aspectj-autoproxy解析及Spring解析自定義標籤

前面的章節已經介紹了AOP的相關概念和一些知識點，接下來我們就要開始分析SpringAOP的原始碼了，接下來的分析都基於@AspectJ註解。雖然@AspectJ是基於註解的方式實現AOP，但還是要在配置檔案中配置<aop:aspectj-autoprox

Java資料結構-陣列解析及類封裝自定義陣列實現

概念： 陣列是Java資料結構中最基本的資料，是儲存 一組長度固定的 同資料型別的集合。 優點： 插入快：對於無序陣列，只需要在陣列末尾增加資料即可。但對於有序陣列，需要查詢到固定的位置，再插入資料，相對無序陣列 結構簡單 缺點： 根據元素值查

Spring原始碼解析之三（自定義標籤的解析）

自定義標籤的解析 1、概述：通過前面的文章我們分析了預設標籤的解析，我們先回顧下自定義標籤解析所使用的方法 /** * Parse the elements at the root level in the document: * "import", "alias", "bean".

【Spring】- 自定義標籤及工作原理

浪費了“黃金五年”的Java程式設計師，還有救嗎？ >>>   

spring原始碼-自定義標籤-4

　　一、自定義標籤，自定義標籤在使用上面相對來說非常常見了，這個也算是spring對於容器的拓展。通過自定義標籤的方式可以創造出很多新的配置方式，並且交給容器直接管理，不需要人工太多的關注。這也是spring對於配置拓展的一個很重要的方式。 　　二、自定義標籤的幾個步驟：1、建立可掃描的標籤和對應的解析類

如何在Spring中自定義標籤

標籤定義檔案 <?xml version="1.0" encoding="UTF-8" standalone="no"?> <!--matrix.xsd--> <xsd:schema xmlns="http://zhangyuy

spring boot 自定義引數解析器實現form表單型別請求或位址列請求引數下劃線轉駝峰屬性

一、定義引數解析註解 @Target(value = ElementType.PARAMETER) @Retention(RetentionPolicy.RUNTIME) public @interface ParameterModel { } 二、定義抽象類AbstractCustomiz

Spring自定義標籤的解析

一：專案demo Spring提供了可擴充套件的支援，利用如下的程式碼來一步步實現spring自定義解析。 專案結構如下，引入spring4.0 1.建立一個user物件 public class User { private String user

Spring boot 自定義註解 簡單版本解析引數

背景：其實就是想用一個註解，來統一處理獲取userid的解析過程。 嗯，但是我覺得自己對註解也沒有那麼瞭解，所以再記錄下。spring boot 中自定義註解的方案：STEP1. 定義註解STEP2. 註解解析1. 定義註解import java.lang.annotatio

spring原始碼（9）自定義標籤與自定義標籤的解析

一、自定義標籤 建立model package com.demo3; /** * * @author dqf * @since 5.0 */ public class User {

spring boot 自定義請求引數解析註解

介紹 一些請求引數, 需要解析成某個自定義的類, 而spring boot中並沒有提供這樣自動轉換的註解, 但是,spring boot 預留了擴充套件介面,所以,我們可以自定義實現一個註解.

spring原始碼深度解析— IOC 之 自定義標籤解析

概述 之前我們已經介紹了spring中預設標籤的解析，解析來我們將分析自定義標籤的解析，我們先回顧下自定義標籤解析所使用的方法，如下圖所示：  我們看到自定義標籤的解析是通過BeanDefinitionParserDelegate.parseCustomElement(ele)進行的，解析來

spring5 原始碼深度解析----- AOP的使用及AOP自定義標籤

我們知道在面向物件OOP程式設計存在一些弊端，當需要為多個不具有繼承關係的物件引入同一個公共行為時，例如日誌，安全檢測等，我們只有在每個物件裡引入公共行為，這樣程式中就產生了大量的重複程式碼，所以有了面向物件程式設計的補充，面向切面程式設計（AOP），AOP所關注的方向是橫向的，不同於OOP的縱向。接下來我們

死磕Spring之IoC篇 - 解析自定義標籤（XML 檔案）

> 該系列文章是本人在學習 Spring 的過程中總結下來的，裡面涉及到相關原始碼，可能對讀者不太友好，請結合我的原始碼註釋 [Spring 原始碼分析 GitHub 地址](https://github.com/liu844869663/spring-framework) 進行閱讀 > > Spring 版

spring實戰-Spring-security自定義登入登出、防csrf攻擊及檢視保護

第十篇：Spring-security自定義登入登出、防csrf攻擊及檢視保護 這是Spring及SpringMVC的最後一篇，本次主要演示SpringSecurity更使用的示例，如自定義的登入頁面，系統登出，防止CSRF跨站攻擊，以及檢視保護檢視保護可以定義到按鈕級別的許可權 先看自

ByteBuf 一個用於在通訊中的資料解析傳輸組裝的自定義容器類

在做和硬體通訊的專案的時候，通訊的內容一般都是最基本的byte陣列,比如BLE，UART等等方式，傳遞的都是byte陣列。 移動端在接收的時候，就需要去解析byte陣列，然後從中通過拼接和或（|）以及位移等運算來得到想要的資料型別，比如說，unsignedByte,short,int,float

Spring自定義標籤實現及踩過的坑（親測）

專案結構 先來一張專案結構圖，因為LZ是用的IDEAL，網上的大部分都是用的eclipse來實現： 這裡也大致說一下專案的新建，考慮到有的讀者會想LZ一樣對IDEAL的使用不是很熟練。 新建一個spring專案（不會的話網上搜索一下，很簡單的），建好之後，再新建這些資料夾，點選File—>Pr

hbase 原始碼解析（21） 自定義過濾器

filter 需要實現Filter 或者繼承FilterBase @[email protected] abstract class Filter{//返回碼 public enum Re

JAVA DOM4j解析XML資料到自定義javabean

我們獲取xml中的資料，一般以面向物件的思想去處理這些資料。因此，我們需要自定義類來封裝解析出來的資料，以方便我們操作這些資料。 自定義的java類，稱為javabean。 自定義Contact類程式碼如下：這個類是用來封裝解析出來的資料的。 package gz.itc