本篇文章给大家分享的是有关@AspectJ怎么在Spring AOP 中使用，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。
@AspectJ可以使用切点函数定义切点，我们还可以使用逻辑运算符对切点进行复核运算得到复合的切点，为了在切面中重用切点，我们还可以对切点进行命名，以便在其他的地方引用定义过的切点。
当一个连接点匹配多个切点时，需要考虑织入顺序的问题，此外一个重要的问题是如何再增强中访问连接点上下文的信息。
Waiter接口：
package com.yyq.aspectJAdvanced;
public interface Waiter {
void greetTo(String name);
void serveTo(String name);
}NaiveWaiter实现类：
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实现类：
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配置文件：
<?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!--");
}
}测试方法：
@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!--");
}
}测试方法：
@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---");
}
}测试方法：
@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---
以上就是@AspectJ怎么在Spring AOP 中使用，小编相信有部分知识点可能是我们日常工作会见到或用到的。希望你能通过这篇文章学到更多知识。更多详情敬请关注亿速云行业资讯频道。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
