Spring AOP @AspectJ進階

時間 2019-11-06

原文原文鏈接

@AspectJ可使用切點函數定義切點，咱們還可使用邏輯運算符對切點進行復核運算獲得複合的切點，爲了在切面中重用切點，咱們還能夠對切點進行命名，以便在其餘的地方引用定義過的切點。當一個鏈接點匹配多個切點時，須要考慮織入順序的問題，此外一個重要的問題是如何再加強中訪問鏈接點上下文的信息。java

Waiter接口：

package com.yyq.aspectJAdvanced;
public interface Waiter {
    void greetTo(String name);
    void serveTo(String name);
}

NaiveWaiter實現類：spring

package com.yyq.aspectJAdvanced;
public class NaiveWaiter implements Waiter {
    @Override
    public void greetTo(String name) {
        System.out.println("NaiveWaiter：greet to " + name + "...");
    }
    @Override
    public void serveTo(String name) {
        System.out.println("NaiveWaiter：serving to " + name + "...");
    }
    public void smile(String clientName,int times){
        System.out.println("NaiveWaiter:smile to  "+clientName+ times+"times...");
    }
}

NaughtyWaiter實現類：ide

package com.yyq.aspectJAdvanced;
public class NaughtyWaiter implements Waiter {
    public void greetTo(String clientName) {
        System.out.println("NaughtyWaiter:greet to " + clientName + "...");
    }
    public void serveTo(String clientName) {
        System.out.println("NaughtyWaiter:serving " + clientName + "...");
    }
    public void joke(String clientName, int times) {
        System.out.println("NaughtyWaiter:play " + times + " jokes to " + clientName + "...");
    }
}

Seller接口：函數

package com.yyq.aspectJAdvanced;
public interface Seller {
  int sell(String goods, String clientName);
}

SmallSeller實現類：測試

package com.yyq.aspectJAdvanced;
public class SmartSeller implements Seller {
    public int sell(String goods,String clientName) {
        System.out.println("SmartSeller: sell "+goods +" to "+clientName+"...");
        return 100;
    }
    
    public void checkBill(int billId){
        if(billId == 1) throw new IllegalArgumentException("iae Exception");
        else throw new RuntimeException("re Exception");
    }
}

beans.xml配置文件：this

<?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-3.0.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    <bean id="naiveWaiter" class="com.yyq.aspectJAdvanced.NaiveWaiter"/>
    <bean id="naughtyWaiter" class="com.yyq.aspectJAdvanced.NaughtyWaiter"/>
    <bean id="seller" class="com.yyq.aspectJAdvanced.SmartSeller"/>
 <!--
    <bean class="com.yyq.aspectJAdvanced.TestAspect"/>
   
    <bean class="com.yyq.aspectJAdvanced.TestAspect2"/>
    <bean class="com.yyq.aspectJAdvanced.TestAspect3"/>
    <bean class="com.yyq.aspectJAdvanced.TestAspect4"/>
    <bean class="com.yyq.aspectJAdvanced.TestAspect5"/>
    <bean id="naiveWaiter2" class="com.yyq.aspectJAdvanced.NaiveWaiter2"/>
    <bean class="com.yyq.aspectJAdvanced.TestAspect6"/>
    <bean class="com.yyq.aspectJAdvanced.TestAspect7"/>
    <bean class="com.yyq.aspectJAdvanced.TestAspect8"/>
-->
</beans>

一、切點符合運算

使用切點符合運算符，咱們將擁有強大而靈活的切點表達能力。

TestAspect：切點符合運算定義切面

package com.yyq.aspectJAdvanced;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class TestAspect {
    //與非運算
    @Before("!target(com.yyq.aspectJAdvanced.NaiveWaiter) && execution(* serveTo(..))")
    public void notServeInNaiveWaiter(){
        System.out.println("--notServeInNaiveWaiter() executed!--");
    }
    //與運算
    @After("within(com.yyq.aspectJAdvanced.*) && execution(* greetTo(..))")
    public void greetToFun(){
        System.out.println("--greetToFun() executed!--");
    }
    //或運算
    @AfterReturning("target(com.yyq.aspectJAdvanced.Waiter) || target(com.yyq.aspectJAdvanced.Seller)")
    public void waiterOrSeller(){
        System.out.println("--waiterOrSeller() executed!--");
    }
}

測試方法：spa

 @Test
    public void pointAspectJTest() {
        String configPath = "com\\yyq\\aspectJAdvanced\\beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
        Waiter naiveWaiter = (Waiter) ctx.getBean("naiveWaiter");
        Waiter naughtyWaiter = (Waiter) ctx.getBean("naughtyWaiter");
        naiveWaiter.greetTo("John");
        naiveWaiter.serveTo("John");
        naughtyWaiter.greetTo("Tom");
        naughtyWaiter.serveTo("Tom");
    }

輸出結果：

NaiveWaiter：greet to John...

--greetToFun() executed!--

--waiterOrSeller() executed!--

NaiveWaiter：serving to John...

--waiterOrSeller() executed!--

NaughtyWaiter:greet to Tom...

--greetToFun() executed!--

--waiterOrSeller() executed!--

--notServeInNaiveWaiter() executed!--

NaughtyWaiter:serving Tom...

--waiterOrSeller() executed!--

二、命名切點

切點直接聲明在加強方法處被稱爲匿名切點，匿名切點只能在聲明處使用。若是但願在其餘地方重用一個切點，咱們能夠經過@Pointcut註解以及切面類方法對切點進行命名。

TestNamePointcut：命名切點類

package com.yyq.aspectJAdvanced;
import org.aspectj.lang.annotation.Pointcut;
public class TestNamePointcut {
    //經過註解方法inPackage()對該切點進行命名，方法可視域修飾符爲private，代表該命名切點只能在本切面類中使用
    @Pointcut("within(com.yyq.aspectJAdvaned.*)")
    private void inPackage(){}
    @Pointcut("execution(* greetTo(..))")
    protected void greetTo(){}
    @Pointcut("inPackage() and greetTo()")
    public void inPkgGreetTo(){}
}

TestAspect2：切面實現類代理

package com.yyq.aspectJAdvanced;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class TestAspect2 {
    @Before("TestNamePointcut.inPkgGreetTo()")
    public void pkgGreetTo(){
        System.out.println("--pkgGreetTo() executed!--");
    }
    @Before("target(com.yyq.aspectJAdvanced.NaiveWaiter) || TestNamePointcut.inPkgGreetTo()")
    public void pkgGreetToNotnaiveWaiter(){
        System.out.println("--pkgGreetToNotnaiveWaiter() executed!--");
    }
}

測試方法：code

@Test
    public void pointAspectJTest2() {
        String configPath = "com\\yyq\\aspectJAdvanced\\beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
        NaiveWaiter naiveWaiter = (NaiveWaiter) ctx.getBean("naiveWaiter");
        naiveWaiter.smile("Andy", 2);
    }

輸出結果：

--pkgGreetToNotnaiveWaiter() executed!--

NaiveWaiter:smile to Andy2times...

三、加強織入的順序

一個鏈接點能夠同時匹配多個切點，切點對應的加強在鏈接點上的織入順序的安排主要有如下3種狀況：

1）若是加強在同一個切面類中聲明，則依照加強在切面類中定義的順序進行織入；

2）如何加強位於不一樣的切面類中，且這些切面類都實現了org.springframework.core.Order接口，則由接口方法的順序號決定（順序號小的先織入）；

3）若是加強位於不一樣的切面類中，且這些切面類沒有實現org.springframework.core.Order接口，織入的順序是不肯定的。

四、訪問鏈接點信息

AspectJ使用org.aspectj.lang.JoinPoint接口表示目標類鏈接點對象，若是是環繞加強時，使用org.aspectj.lang.ProceedingJoinPoint表示鏈接點對象，該類是JoinPoint的子接口，任何一個加強方法均可以經過將第一個入參聲明爲JoinPoint訪問到鏈接點上下文的信息。

TestAspect3：切面實現類

@Aspect
public class TestAspect3 {
    @Around("execution(* greetTo(..)) && target(com.yyq.aspectJAdvanced.NaiveWaiter)")
    public void joinPointAccess(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("---joinPointAccess---");
        System.out.println("args[0]:" + pjp.getArgs()[0]);
        System.out.println("signature:" + pjp.getTarget().getClass());
        pjp.proceed();
        System.out.println("---joinPointAccess---");
    }
}

測試方法：xml

 @Test
    public void pointAspectJTest3() {
        String configPath = "com\\yyq\\aspectJAdvanced\\beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
        Waiter naiveWaiter = (Waiter) ctx.getBean("naiveWaiter");
        naiveWaiter.greetTo("Andy");
    }

輸出結果：

---joinPointAccess---

args[0]:Andy

signature:class com.yyq.aspectJAdvanced.NaiveWaiter

NaiveWaiter：greet to Andy...

---joinPointAccess---

五、綁定鏈接點方法入參

args()用於綁定鏈接點方法的入參；@annotation()用於綁定鏈接點方法的註解對象；而@args()用於綁定鏈接點方法入參的註解。

TestAspect4：切面實現類

@Aspect
public class TestAspect4 {
    @Before("target(com.yyq.aspectJAdvanced.NaiveWaiter) && args(name,num,..)")
    public void bindJoinPointParams(int num, String name) {
        System.out.println("---bindJoinPointParams---");
        System.out.println("name:" + name);
        System.out.println("num:" + num);
        System.out.println("---bindJoinPointParams---");
    }
}

測試方法：

@Test
    public void pointAspectJTest4() {
        String configPath = "com\\yyq\\aspectJAdvanced\\beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
        NaiveWaiter naiveWaiter = (NaiveWaiter) ctx.getBean("naiveWaiter");
        naiveWaiter.smile("Andy", 3);
    }

輸出結果：

---bindJoinPointParams---

name:Andy

num:3

---bindJoinPointParams---

NaiveWaiter:smile to Andy 3 times...

六、綁定代理對象

使用this()或target()可綁定被代理對象實例，在經過類實例名綁定對象時，還依然具備原來鏈接點匹配的功能，只不過類名是經過加強方法中同名入參的類型間接決定罷了。

TestAspect5：切面實現類

@Aspect
public class TestAspect5 {
    @Before("this(waiter)")
    public void bindProxyObj(Waiter waiter){
        System.out.println("---bindProxyObj---");
        System.out.println(waiter.getClass().getName());
        System.out.println("---bindProxyObj---");
    }
}

測試方法：

@Test
    public void pointAspectJTest5() {
        String configPath = "com\\yyq\\aspectJAdvanced\\beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
        Waiter waiter = (Waiter) ctx.getBean("naiveWaiter");
        waiter.greetTo("Yang");
    }

輸出結果：

---bindProxyObj---

com.yyq.aspectJAdvanced.NaiveWaiter$$EnhancerByCGLIB$$fefafe52

---bindProxyObj---

NaiveWaiter：greet to Yang...

七、綁定類註解對象

@within()和@target()函數能夠將目標類的註解對象綁定到加強方法中，咱們經過@within()演示註解綁定的操做。

TestAspect6：切面測試類

@Aspect
public class TestAspect6 {
    @Before("@within(m)")
    public void bindTypeAnnoObject(Monitorable m) {
        System.out.println("---bindTypeAnnoObject---");
        System.out.println(m.getClass().getName());
        System.out.println("---bindTypeAnnoObject---");
    }
}

測試方法：

@Test
    public void pointAspectJTest6() {
        String configPath = "com\\yyq\\aspectJAdvanced\\beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
        Waiter waiter = (Waiter) ctx.getBean("naiveWaiter2");
        ((NaiveWaiter2)waiter).greetTo("Yang");
    }

輸出結果：

---bindTypeAnnoObject---

$Proxy4

---bindTypeAnnoObject---

NaiveWaiter：greet to Yang...

八、綁定返回值

在後置加強中，咱們能夠經過returning綁定鏈接點方法的返回值。

TestAspect7：切面實現類

@Aspect
public class TestAspect7 {
    @AfterReturning(value = "target(com.yyq.aspectJAdvanced.SmartSeller)", returning = "retVal")
    public void bindReturnValue(int retVal) {
        System.out.println("---bindReturnValue---");
        System.out.println("returnValue:" + retVal);
        System.out.println("---bindReturnValue---");
    }
}

測試方法：

 @Test
    public void pointAspectJTest7() {
        String configPath = "com\\yyq\\aspectJAdvanced\\beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
        SmartSeller seller = (SmartSeller) ctx.getBean("seller");
        seller.sell("Beer", "John");
    }

輸出結果：

SmartSeller: sell Beer to John...

---bindReturnValue---

returnValue:100

---bindReturnValue---

九、綁定拋出的異常

和經過切點函數綁定鏈接點信息不一樣，鏈接點拋出的異常必須使用AfterThrowing註解的throwing成員進行綁定。

TestAspect8：切面實現類

@Aspect
public class TestAspect8 {
    @AfterThrowing(value = "target(com.yyq.aspectJAdvanced.SmartSeller)", throwing = "iae")
    public void bindException(IllegalArgumentException iae) {
        System.out.println("---bindException---");
        System.out.println("exception:" + iae.getMessage());
        System.out.println("---bindException---");
    }
}

測試方法：

 @Test
    public void pointAspectJTest8() {
        String configPath = "com\\yyq\\aspectJAdvanced\\beans.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(configPath);
        SmartSeller seller = (SmartSeller) ctx.getBean("seller");
        seller.checkBill(1);
    }

輸出結果：

---bindException---

exception:iae Exception

---bindException---

java.lang.IllegalArgumentException: iae Exception