2. 程式人生 > >Spring 對事務管理的支援

Spring 對事務管理的支援

阿新 • • 發佈：2018-11-02

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：切面實

相關推薦

Spring 對事務管理的支援

Spring AOP @AspectJ進階 @AspectJ可以使用切點函式定義切點，我們還可以使用邏輯運算子對切點進行復核運算得到複合的切點，為了在切面中重用切點，我們還可以對切點進行命名，以便在其他的地方引用定義過的切點。當一個連線點匹配多個切點時，需要考慮織入順序的問題，此外一個重要的

Spring對事務管理的支援

Spring為事務管理提供了一致的程式設計模版，在高層次建立了統一的事務抽象，不管使用者選擇Spring JDBC、Hibernate、JPA還是選擇MyBatis，Spring都可以讓使用者用統一的

chapter05 Spring對事務的支援

chapter05 Spring對事務的支援 一．Spring對事物支援所採用的策略 1.spring統一各種事物的程式設計方式 AOP事務的含義： 事務當作一個切面，動態地織入到目標物件，形成一個代理物件。 二、Spring的事務機制 Spring支援宣告式事務。 Spr

第十講：10.spring對事物的支援-程式設計式事務管理

轉賬業務 1，複製spring403-03 改名spring403：建立表結構，資料庫的引擎一定是InnoDB Create Table CREATE TABLE `t_account` (   

Spring的事務管理

spring、事務一、事務的基礎知識數據庫事務：復雜的事務要分步執行，要麽整體生效、要麽整體失效。必須滿足：原子性、一致性、隔離性、持久性。數據並發問題：臟讀：A讀取了B未提交的更改數據。 不可重復讀：A兩次讀，第二次讀到了B已經提交的數據。（行級鎖） 幻讀(虛讀)：A讀取B新

spring的事務管理註解

clas lap 謝謝 closed 異常類 ctx ash upd ttr 軟件152班楊錦宏 spring的事務管理，本文的例子是：比如你需要網購一本書，賣書的那一方有庫存量以及書的價格，你有賬戶余額。回想我們在編程中要實現買書這樣的功能，由於你的賬戶表和書的庫存量表肯

spring,mybatis事務管理配置與@Transactional註解使用[轉]

exception true throws r.java 存在 隔離 enc prot 底層 spring,mybatis事務管理配置與@Transactional註解使用 概述事務管理對於企業應用來說是至關重要的，即使出現異常情況，它也可以保證數據的一致性。Sprin

spring進行事務管理

rop 一次 exceptio ext per spring 常見 service服務 pri 一：spring使用註解的方式進行事務聲明 1.spring的聲明式事務： 用jdbc的事務管理器：DataSourceTransactionManager 首先在applica

Spring對事務的支持

bsp ddt nag 支持 切點 requires comm 特定 eas 1、ThreadLocal 　　在寫Spring對事務的支持之前要先了解一下ThreadLocal，當多個線程訪問同一個成員變量時，如果這個變量不做處理，那肯定會造成線程不安全的問題啊。使用Thr

Spring之事務管理的好處

nbsp 功能 集成 clas 回滾 代碼 不同 soft class 　　在以往的JDBCTemplate中事務提交成功，異常處理都是通過Try/Catch 來完成，而在Spring中。Spring容器集成了TransactionTemplate，封裝了所有對事務處理的功

spring,mybatis事務管理配置與@Transactional註解使用

抽象 classname 初始 for batis 時間限制 自動提交 data second spring,mybatis事務管理配置與@Transactional註解使用 概述事務管理對於企業應用來說是至關重要的，即使出現異常情況，它也可以保證數據的一致性。Spring

Mybatis整合Spring實現事務管理的源碼分析

utils tab cti oca def bean ssi connect ger 一：前言 　　沒有完整看完，但是看到了一些關鍵的地方，這裏做個記錄，過程會有點亂，以後逐漸補充最終歸檔為完整流程；相信看過框架源碼的都知道過程中無法完全確定是怎樣的流程，畢竟不可能全部都

二十 Spring的事務管理及其API

action spring事務 data 常用 mtr bsp nsa UNC 回顧 Spring提供兩種事務方式：編程式和聲明式（重點） 事務的回顧: 事務：邏輯上的一組操作，組成這組事務的各個單元，要麽全部成功，要麽全部失敗 事務的特性： 原子性：事務不可分割 一

深入理解spring的事務管理機制及程式碼實現

Spring的事務管理機制 Spring事務管理高層抽象主要包括3個介面，Spring的事務主要是由他們共同完成的： PlatformTransactionManager：事務管理器—主要用於平臺相關事務的管理 TransactionDefinition： 事務定義資訊(隔

spring配置事務管理為什麼用aop:advisor

1　　事務配置有aop:aspect和aop:advisor兩種方式,但是在spring的事務管理的配置中會用aop:advisor配置,而不是aop:aspect   2　　aop:aspect可以有多個pointcut,只能以類和方法作為引數.而aop:advisor只能有一個pointcu

Spring4（7）——對 事務 的支援

1.事務 滿足一下四個條件： 1. 原子性； 2. 一致性； 3. 隔離性； 4. 永續性； 場景：轉賬 （ 成功從A轉出，但未成功轉入B ，出現業務的不一致性，需要事務回滾） 2.程式設計式事務管理（用的少） Spring 提供的事務模版類

Day3-Spring的事務管理、Spring框架的JDBC模板

今天內容 1. Spring框架的AOP之註解的方式2. Spring框架的JDBC模板3. Spring框架的事務管理 案例一：使用Spring框架的AOP技術對DAO層的功能進行增強 案例一：使用Spring框架的AOP技術對DAO層的功能進行增強 1. 使用Spring框架的

spring - 淺談spring的事務管理(程式設計式,宣告式(XML版和註解版))

事務管理的目的:               將若干sql語句作為一個整體 , 要麼全部成功 , 要麼全部失敗! 事務套路:  &nb

Spring boot事務管理(單體架構下)

一些概念 宣告式的事務管理是基於AOP的，在springboot中可以通過@Transactional註解的方式獲得支援，這種方式的優點是： 1）非侵入式，業務邏輯不受事務管理程式碼的汙染。 2）方法級別的事務回滾，合理劃分方法的粒度可以做到符合各種業務場景的事務管理。 本文使用目前

深入Spring資料庫事務管理

一、Spring資料庫事務管理器的設計 在Spring中資料庫事務是通過PlatformTransactionManager進行管理的，而真正能夠支援事務的是org.springframework.transaction.support.TransactionTemplate模版，其核心