基于Spring AOP @AspectJ进阶说明

2023-07-06 13:48:36 76

@AspectJ可以使用切点函数定义切点，我们还可以使用逻辑运算符对切点进行复核运算得到复合的切点，为了在切面中重用切点，我们还可以对切点进行命名，以便在其他的地方引用定义过的切点。

当一个连接点匹配多个切点时，需要考虑织入顺序的问题，此外一个重要的问题是如何再增强中访问连接点上下文的信息。

Waiter接口：

packagecom.yyq.aspectJAdvanced;
publicinterfaceWaiter{
voidgreetTo(Stringname);
voidserveTo(Stringname);
}

NaiveWaiter实现类：

packagecom.yyq.aspectJAdvanced;
publicclassNaiveWaiterimplementsWaiter{
@Override
publicvoidgreetTo(Stringname){
System.out.println("NaiveWaiter：greetto"+name+"...");
}
@Override
publicvoidserveTo(Stringname){
System.out.println("NaiveWaiter：servingto"+name+"...");
}
publicvoidsmile(StringclientName,inttimes){
System.out.println("NaiveWaiter:smileto"+clientName+times+"times...");
}
}

NaughtyWaiter实现类：

packagecom.yyq.aspectJAdvanced;
publicclassNaughtyWaiterimplementsWaiter{
publicvoidgreetTo(StringclientName){
System.out.println("NaughtyWaiter:greetto"+clientName+"...");
}
publicvoidserveTo(StringclientName){
System.out.println("NaughtyWaiter:serving"+clientName+"...");
}
publicvoidjoke(StringclientName,inttimes){
System.out.println("NaughtyWaiter:play"+times+"jokesto"+clientName+"...");
}
}

Seller接口：

packagecom.yyq.aspectJAdvanced;
publicinterfaceSeller{
intsell(Stringgoods,StringclientName);
}

SmallSeller实现类：

packagecom.yyq.aspectJAdvanced;
publicclassSmartSellerimplementsSeller{
publicintsell(Stringgoods,StringclientName){
System.out.println("SmartSeller:sell"+goods+"to"+clientName+"...");
return100;
}

publicvoidcheckBill(intbillId){
if(billId==1)thrownewIllegalArgumentException("iaeException");
elsethrownewRuntimeException("reException");
}
}

beans.xml配置文件：

1、切点符合运算

使用切点符合运算符，我们将拥有强大而灵活的切点表达能力。

TestAspect：切点符合运算定义切面

packagecom.yyq.aspectJAdvanced;
importorg.aspectj.lang.annotation.After;
importorg.aspectj.lang.annotation.AfterReturning;
importorg.aspectj.lang.annotation.Aspect;
importorg.aspectj.lang.annotation.Before;
@Aspect
publicclassTestAspect{
//与非运算
@Before("!target(com.yyq.aspectJAdvanced.NaiveWaiter)&&execution(*serveTo(..))")
publicvoidnotServeInNaiveWaiter(){
System.out.println("--notServeInNaiveWaiter()executed!--");
}
//与运算
@After("within(com.yyq.aspectJAdvanced.*)&&execution(*greetTo(..))")
publicvoidgreetToFun(){
System.out.println("--greetToFun()executed!--");
}
//或运算
@AfterReturning("target(com.yyq.aspectJAdvanced.Waiter)||target(com.yyq.aspectJAdvanced.Seller)")
publicvoidwaiterOrSeller(){
System.out.println("--waiterOrSeller()executed!--");
}
}

测试方法：

@Test
publicvoidpointAspectJTest(){
StringconfigPath="com\\yyq\\aspectJAdvanced\\beans.xml";
ApplicationContextctx=newClassPathXmlApplicationContext(configPath);
WaiternaiveWaiter=(Waiter)ctx.getBean("naiveWaiter");
WaiternaughtyWaiter=(Waiter)ctx.getBean("naughtyWaiter");
naiveWaiter.greetTo("John");
naiveWaiter.serveTo("John");
naughtyWaiter.greetTo("Tom");
naughtyWaiter.serveTo("Tom");
}

输出结果：

NaiveWaiter：greettoJohn...
--greetToFun()executed!--
--waiterOrSeller()executed!--
NaiveWaiter：servingtoJohn...
--waiterOrSeller()executed!--
NaughtyWaiter:greettoTom...
--greetToFun()executed!--
--waiterOrSeller()executed!--
--notServeInNaiveWaiter()executed!--
NaughtyWaiter:servingTom...
--waiterOrSeller()executed!--

2、命名切点

切点直接声明在增强方法处被称为匿名切点，匿名切点只能在声明处使用。如果希望在其他地方重用一个切点，我们可以通过@Pointcut注解以及切面类方法对切点进行命名。

TestNamePointcut：命名切点类

packagecom.yyq.aspectJAdvanced;
importorg.aspectj.lang.annotation.Pointcut;
publicclassTestNamePointcut{
//通过注解方法inPackage()对该切点进行命名，方法可视域修饰符为private，表明该命名切点只能在本切面类中使用
@Pointcut("within(com.yyq.aspectJAdvaned.*)")
privatevoidinPackage(){}
@Pointcut("execution(*greetTo(..))")
protectedvoidgreetTo(){}
@Pointcut("inPackage()andgreetTo()")
publicvoidinPkgGreetTo(){}
}

TestAspect2：切面实现类

packagecom.yyq.aspectJAdvanced;
importorg.aspectj.lang.annotation.Aspect;
importorg.aspectj.lang.annotation.Before;
@Aspect
publicclassTestAspect2{
@Before("TestNamePointcut.inPkgGreetTo()")
publicvoidpkgGreetTo(){
System.out.println("--pkgGreetTo()executed!--");
}
@Before("target(com.yyq.aspectJAdvanced.NaiveWaiter)||TestNamePointcut.inPkgGreetTo()")
publicvoidpkgGreetToNotnaiveWaiter(){
System.out.println("--pkgGreetToNotnaiveWaiter()executed!--");
}
}

测试方法：

@Test
publicvoidpointAspectJTest2(){
StringconfigPath="com\\yyq\\aspectJAdvanced\\beans.xml";
ApplicationContextctx=newClassPathXmlApplicationContext(configPath);
NaiveWaiternaiveWaiter=(NaiveWaiter)ctx.getBean("naiveWaiter");
naiveWaiter.smile("Andy",2);
}

输出结果：

--pkgGreetToNotnaiveWaiter()executed!--
NaiveWaiter:smiletoAndy2times...

3、增强织入的顺序

一个连接点可以同时匹配多个切点，切点对应的增强在连接点上的织入顺序的安排主要有以下3种情况：

1）如果增强在同一个切面类中声明，则依照增强在切面类中定义的顺序进行织入；

2）如何增强位于不同的切面类中，且这些切面类都实现了org.springframework.core.Order接口，则由接口方法的顺序号决定（顺序号小的先织入）；

3）如果增强位于不同的切面类中，且这些切面类没有实现org.springframework.core.Order接口，织入的顺序是不确定的。

4、访问连接点信息

AspectJ使用org.aspectj.lang.JoinPoint接口表示目标类连接点对象，如果是环绕增强时，使用org.aspectj.lang.ProceedingJoinPoint表示连接点对象，该类是JoinPoint的子接口，任何一个增强方法都可以通过将第一个入参声明为JoinPoint访问到连接点上下文的信息。

TestAspect3：切面实现类

@Aspect
publicclassTestAspect3{
@Around("execution(*greetTo(..))&&target(com.yyq.aspectJAdvanced.NaiveWaiter)")
publicvoidjoinPointAccess(ProceedingJoinPointpjp)throwsThrowable{
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---");
}
}

测试方法：

@Test
publicvoidpointAspectJTest3(){
StringconfigPath="com\\yyq\\aspectJAdvanced\\beans.xml";
ApplicationContextctx=newClassPathXmlApplicationContext(configPath);
WaiternaiveWaiter=(Waiter)ctx.getBean("naiveWaiter");
naiveWaiter.greetTo("Andy");
}

输出结果：

---joinPointAccess---
args[0]:Andy
signature:classcom.yyq.aspectJAdvanced.NaiveWaiter
NaiveWaiter：greettoAndy...
---joinPointAccess---

5、绑定连接点方法入参

args()用于绑定连接点方法的入参；@annotation()用于绑定连接点方法的注解对象；而@args()用于绑定连接点方法入参的注解。

TestAspect4：切面实现类

@Aspect
publicclassTestAspect4{
@Before("target(com.yyq.aspectJAdvanced.NaiveWaiter)&&args(name,num,..)")
publicvoidbindJoinPointParams(intnum,Stringname){
System.out.println("---bindJoinPointParams---");
System.out.println("name:"+name);
System.out.println("num:"+num);
System.out.println("---bindJoinPointParams---");
}
}

测试方法：

@Test
publicvoidpointAspectJTest4(){
StringconfigPath="com\\yyq\\aspectJAdvanced\\beans.xml";
ApplicationContextctx=newClassPathXmlApplicationContext(configPath);
NaiveWaiternaiveWaiter=(NaiveWaiter)ctx.getBean("naiveWaiter");
naiveWaiter.smile("Andy",3);
}

输出结果：

---bindJoinPointParams---
name:Andy
num:3
---bindJoinPointParams---
NaiveWaiter:smiletoAndy3times...

6、绑定代理对象

使用this()或target()可绑定被代理对象实例，在通过类实例名绑定对象时，还依然具有原来连接点匹配的功能，只不过类名是通过增强方法中同名入参的类型间接决定罢了。

TestAspect5：切面实现类

@Aspect
publicclassTestAspect5{
@Before("this(waiter)")
publicvoidbindProxyObj(Waiterwaiter){
System.out.println("---bindProxyObj---");
System.out.println(waiter.getClass().getName());
System.out.println("---bindProxyObj---");
}
}

测试方法：

@Test
publicvoidpointAspectJTest5(){
StringconfigPath="com\\yyq\\aspectJAdvanced\\beans.xml";
ApplicationContextctx=newClassPathXmlApplicationContext(configPath);
Waiterwaiter=(Waiter)ctx.getBean("naiveWaiter");
waiter.greetTo("Yang");
}

输出结果：

---bindProxyObj---
com.yyq.aspectJAdvanced.NaiveWaiter$$EnhancerByCGLIB$$fefafe52
---bindProxyObj---
NaiveWaiter：greettoYang...

7、绑定类注解对象

@within()和@target()函数可以将目标类的注解对象绑定到增强方法中，我们通过@within()演示注解绑定的操作。

TestAspect6：切面测试类

@Aspect
publicclassTestAspect6{
@Before("@within(m)")
publicvoidbindTypeAnnoObject(Monitorablem){
System.out.println("---bindTypeAnnoObject---");
System.out.println(m.getClass().getName());
System.out.println("---bindTypeAnnoObject---");
}
}

测试方法：

@Test
publicvoidpointAspectJTest6(){
StringconfigPath="com\\yyq\\aspectJAdvanced\\beans.xml";
ApplicationContextctx=newClassPathXmlApplicationContext(configPath);
Waiterwaiter=(Waiter)ctx.getBean("naiveWaiter2");
((NaiveWaiter2)waiter).greetTo("Yang");
}

输出结果：

---bindTypeAnnoObject---
$Proxy4
---bindTypeAnnoObject---
NaiveWaiter：greettoYang...

8、绑定返回值

在后置增强中，我们可以通过returning绑定连接点方法的返回值。

TestAspect7：切面实现类

@Aspect
publicclassTestAspect7{
@AfterReturning(value="target(com.yyq.aspectJAdvanced.SmartSeller)",returning="retVal")
publicvoidbindReturnValue(intretVal){
System.out.println("---bindReturnValue---");
System.out.println("returnValue:"+retVal);
System.out.println("---bindReturnValue---");
}
}

测试方法：

@Test
publicvoidpointAspectJTest7(){
StringconfigPath="com\\yyq\\aspectJAdvanced\\beans.xml";
ApplicationContextctx=newClassPathXmlApplicationContext(configPath);
SmartSellerseller=(SmartSeller)ctx.getBean("seller");
seller.sell("Beer","John");
}

输出结果：

SmartSeller:sellBeertoJohn...
---bindReturnValue---
returnValue:100
---bindReturnValue---

9、绑定抛出的异常

和通过切点函数绑定连接点信息不同，连接点抛出的异常必须使用AfterThrowing注解的throwing成员进行绑定。

TestAspect8：切面实现类

@Aspect
publicclassTestAspect8{
@AfterThrowing(value="target(com.yyq.aspectJAdvanced.SmartSeller)",throwing="iae")
publicvoidbindException(IllegalArgumentExceptioniae){
System.out.println("---bindException---");
System.out.println("exception:"+iae.getMessage());
System.out.println("---bindException---");
}
}

测试方法：

@Test
publicvoidpointAspectJTest8(){
StringconfigPath="com\\yyq\\aspectJAdvanced\\beans.xml";
ApplicationContextctx=newClassPathXmlApplicationContext(configPath);
SmartSellerseller=(SmartSeller)ctx.getBean("seller");
seller.checkBill(1);
}

输出结果：

---bindException---
exception:iaeException
---bindException---

以上为个人经验，希望能给大家一个参考，也希望大家多多支持毛票票。如有错误或未考虑完全的地方，望不吝赐教。

基于Spring AOP @AspectJ进阶说明

1、切点符合运算

2、命名切点

3、增强织入的顺序

4、访问连接点信息

5、绑定连接点方法入参

6、绑定代理对象

7、绑定类注解对象

8、绑定返回值

9、绑定抛出的异常

热门推荐

随机推荐