Spring 对事务管理的支持

编程语言 2018-11-02 07:17:04 阅读次数: 0

Spring AOP @AspectJ进阶
@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" ?>


<aop:aspectj-autoproxy proxy-target-class=“true”/>


复制代码 1、切点符合运算 使用切点符合运算符，我们将拥有强大而灵活的切点表达能力。 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!–

2、命名切点
切点直接声明在增强方法处被称为匿名切点，匿名切点只能在声明处使用。如果希望在其他地方重用一个切点，我们可以通过@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、增强织入的顺序
一个连接点可以同时匹配多个切点，切点对应的增强在连接点上的织入顺序的安排主要有以下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
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—

5、绑定连接点方法入参
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…

6、绑定代理对象
使用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 E n h a n c e r B y C G L I B EnhancerByCGLIB fefafe52
—bindProxyObj—
NaiveWaiter：greet to Yang…

7、绑定类注解对象
@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…

8、绑定返回值
在后置增强中，我们可以通过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—

9、绑定抛出的异常
和通过切点函数绑定连接点信息不同，连接点抛出的异常必须使用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

上面文章转载为[https://www.cnblogs.com/yangyquin/p/5582911.html]Spring AOP @AspectJ进阶
@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" ?>


<aop:aspectj-autoproxy proxy-target-class=“true”/>


复制代码 1、切点符合运算 使用切点符合运算符，我们将拥有强大而灵活的切点表达能力。 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!–

2、命名切点
切点直接声明在增强方法处被称为匿名切点，匿名切点只能在声明处使用。如果希望在其他地方重用一个切点，我们可以通过@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、增强织入的顺序
一个连接点可以同时匹配多个切点，切点对应的增强在连接点上的织入顺序的安排主要有以下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
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—

5、绑定连接点方法入参
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…

6、绑定代理对象
使用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 E n h a n c e r B y C G L I B EnhancerByCGLIB fefafe52
—bindProxyObj—
NaiveWaiter：greet to Yang…

7、绑定类注解对象
@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…

8、绑定返回值
在后置增强中，我们可以通过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—

9、绑定抛出的异常
和通过切点函数绑定连接点信息不同，连接点抛出的异常必须使用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 ExceptionSpring AOP @AspectJ进阶
@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" ?>


<aop:aspectj-autoproxy proxy-target-class=“true”/>


复制代码 1、切点符合运算 使用切点符合运算符，我们将拥有强大而灵活的切点表达能力。 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!–

2、命名切点
切点直接声明在增强方法处被称为匿名切点，匿名切点只能在声明处使用。如果希望在其他地方重用一个切点，我们可以通过@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、增强织入的顺序
一个连接点可以同时匹配多个切点，切点对应的增强在连接点上的织入顺序的安排主要有以下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
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—

5、绑定连接点方法入参
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…

6、绑定代理对象
使用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 E n h a n c e r B y C G L I B EnhancerByCGLIB fefafe52
—bindProxyObj—
NaiveWaiter：greet to Yang…

7、绑定类注解对象
@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…

8、绑定返回值
在后置增强中，我们可以通过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—

9、绑定抛出的异常
和通过切点函数绑定连接点信息不同，连接点抛出的异常必须使用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 ExceptionSpring AOP @AspectJ进阶
@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" ?>


<aop:aspectj-autoproxy proxy-target-class=“true”/>


复制代码 1、切点符合运算 使用切点符合运算符，我们将拥有强大而灵活的切点表达能力。 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!–

2、命名切点
切点直接声明在增强方法处被称为匿名切点，匿名切点只能在声明处使用。如果希望在其他地方重用一个切点，我们可以通过@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、增强织入的顺序
一个连接点可以同时匹配多个切点，切点对应的增强在连接点上的织入顺序的安排主要有以下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
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—

5、绑定连接点方法入参
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…

6、绑定代理对象
使用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 E n h a n c e r B y C G L I B EnhancerByCGLIB fefafe52
—bindProxyObj—
NaiveWaiter：greet to Yang…

7、绑定类注解对象
@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…

8、绑定返回值
在后置增强中，我们可以通过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—

9、绑定抛出的异常
和通过切点函数绑定连接点信息不同，连接点抛出的异常必须使用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 ExceptionSpring AOP @AspectJ进阶
@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" ?>


<aop:aspectj-autoproxy proxy-target-class=“true”/>


复制代码 1、切点符合运算 使用切点符合运算符，我们将拥有强大而灵活的切点表达能力。 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!–

2、命名切点
切点直接声明在增强方法处被称为匿名切点，匿名切点只能在声明处使用。如果希望在其他地方重用一个切点，我们可以通过@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、增强织入的顺序
一个连接点可以同时匹配多个切点，切点对应的增强在连接点上的织入顺序的安排主要有以下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
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—

5、绑定连接点方法入参
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…

6、绑定代理对象
使用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 E n h a n c e r B y C G L I B EnhancerByCGLIB fefafe52
—bindProxyObj—
NaiveWaiter：greet to Yang…

7、绑定类注解对象
@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…

8、绑定返回值
在后置增强中，我们可以通过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—

9、绑定抛出的异常
和通过切点函数绑定连接点信息不同，连接点抛出的异常必须使用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 ExceptionSpring AOP @AspectJ进阶
@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" ?>


<aop:aspectj-autoproxy proxy-target-class=“true”/>


复制代码 1、切点符合运算 使用切点符合运算符，我们将拥有强大而灵活的切点表达能力。 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!–

2、命名切点
切点直接声明在增强方法处被称为匿名切点，匿名切点只能在声明处使用。如果希望在其他地方重用一个切点，我们可以通过@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、增强织入的顺序
一个连接点可以同时匹配多个切点，切点对应的增强在连接点上的织入顺序的安排主要有以下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
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—

5、绑定连接点方法入参
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…

6、绑定代理对象
使用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 E n h a n c e r B y C G L I B EnhancerByCGLIB fefafe52
—bindProxyObj—
NaiveWaiter：greet to Yang…

7、绑定类注解对象
@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…

8、绑定返回值
在后置增强中，我们可以通过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—

9、绑定抛出的异常
和通过切点函数绑定连接点信息不同，连接点抛出的异常必须使用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

上面代码转载为 [https://www.cnblogs.com/yangyquin/p/5582911.html]

猜你喜欢

转载自blog.csdn.net/anhldd/article/details/83579509
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
周排行
浏览器对同一域名进行请求的最大并发连接数
React Hook之自定义Hook
【转】MyBatis缓存机制
-Java-泛型
自动化测试常用脚本-发送邮件
LeetCode#859: Buddy Strings
java、Python处理字符串
第二篇の博客
Hadoop伪分布式环境安装
SQL Server进阶（十一）临时表、表变量
每日归档
更多
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022