day09-AOP-02
2023-01-25 06:00:30
AOP-02
4.問題提出
在上一篇的MyProxyProvider類中，我們的輸出語句功能比較弱，在實際開發中，我們希望是以一個方法的形式，嵌入到真正執行的目標方法前，怎麼辦？
1.使用土方法解決
需求分析：使用土方法解決前面的問題，後面使用spring的aop元件完成
改進MyProxyProvider：
主要是對前置/返回/異常/最終通知的程式碼進行封裝，封裝到不同的方法中進行呼叫。
package com.li.aop.proxy3;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
/**
* @author 李
* @version 1.0
* 返回一個動態代理物件，可以執行被代理的物件的方法
*/
public class MyProxyProvider {
//定義要執行的目標物件，該物件需要實現 SmartAnimal介面
private SmartAnimal target_animal;
//構造器
public MyProxyProvider(SmartAnimal target_animal) {
this.target_animal = target_animal;
}
//定義一個方法，在目標物件執行前執行
public void before(Method method, Object[] args) {
System.out.println("before-方法執行開始-紀錄檔-方法名-" + method.getName() +
"-引數 " + Arrays.toString(args));//AOP的角度看，是一個橫切關注點-前置通知
}
//定義一個方法，在目標物件執行後行
public void after(Method method, Object result) {
System.out.println("after-方法執行正常結束-紀錄檔-方法名-" + method.getName()
+ "-結果 result = " + result);//也是一個橫切關注點-返回通知
}
//定義方法返回代理物件，該代理物件可以執行目標物件
public SmartAnimal getProxy() {
//(1)先得到類載入器物件
ClassLoader classLoader = target_animal.getClass().getClassLoader();
//(2)得到要執行的目標物件的介面資訊
Class<?>[] interfaces = target_animal.getClass().getInterfaces();
//(3)使用匿名內部類 建立 InvocationHandler物件
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
try {
before(method, args);
//使用反射真正呼叫方法
result = method.invoke(target_animal, args);
after(method, result);
} catch (Exception e) {
//如果反射出現異常，就會進入到catch塊
System.out.println("方法執行異常-紀錄檔-方法名" + method.getName()
+ "-異常型別=" + e.getClass().getName());//橫切關注點-異常通知
e.printStackTrace();
} finally {//無論是否出現異常，最終都會執行到 finally{}
//也是一個橫切關注點-最終通知
System.out.println("方法最終結束-紀錄檔-方法名-" + method.getName());
}
return result;
}
};
//建立代理物件
SmartAnimal proxy = (SmartAnimal) Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
return proxy;
}
}
2.對土方法進行解耦-開發簡易的AOP類
上面的程式碼因為前後置等處理方法都寫在同一個類中，造成程式碼耦合度高的問題。因此，更好的解決方法是新建一個類MyAOP，在該類中進行處理方法的編寫，然後在MyProxyProvider類中呼叫該類的方法。
MyAOP類：
package com.li.aop.proxy3;
import java.lang.reflect.Method;
import java.util.Arrays;
/**
* @author 李
* @version 1.0
* 自己寫的一個極簡AOP類
*/
public class MyAOP {
//定義一個方法，在目標物件執行前執行
public static void before(Method method, Object[] args) {
System.out.println("MyAOP-方法執行開始-紀錄檔-方法名-" + method.getName() +
"-引數 " + Arrays.toString(args));//前置通知
}
//定義一個方法，在目標物件執行後行
public static void after(Method method, Object result) {
System.out.println("MyAOP-方法執行正常結束-紀錄檔-方法名-" + method.getName()
+ "-結果 result = " + result);//返回通知
}
}
3.再次分析-提出Spring AOP
使用上面的辦法仍存在一些問題：
- 不夠靈活：假設被代理物件有很多方法，而我們只想僅對其中一個方法進行處理，當前的程式碼還不能實現這個需求
- 複用性差：假如有一個新的介面USBInterface，Phone類實現了這個介面，現在我們想要Phone類去呼叫之前MyAOP中的方法。但MyAOP類的方法是根據之前的SmartAnimal介面的方法寫的，因此不能很好的適用於新的介面及其實現類
- 寫死：沒有註解和反射的支撐
5.AOP的基本介紹
1.什麼是AOP?
官方檔案：核心技術 (spring.io)
AOP全稱：aspect oriented programming，即面向切面程式設計。
AOP 是一種程式設計思想，是物件導向程式設計（OOP）的一種補充。物件導向程式設計將程式抽象成各個層次的物件，而面向切面程式設計是將程式抽象成各個切面。
2.AOP和OOP的區別：
OOP 針對業務處理過程的實體及其屬性和行為進行抽象封裝，以獲得更加清晰高效的邏輯單元劃分。
而 AOP 則是針對業務處理過程中的切面進行提取，它所面對的是處理過程中的某個步驟或階段，以獲得邏輯過程中各部分之間低耦合性的隔離效果。
這兩種設計思想在目標上有著本質的差異：
面向目標不同：簡單來說 OOP 是面向名詞領域，AOP 面向動詞領域。
思想結構不同：OOP 是縱向結構，AOP 是橫向結構。
注重方面不同：OOP 注重業務邏輯單元的劃分，AOP 偏重業務處理過程中的某個步驟或階段。
aop通過動態代理+反射的方式，對被代理物件的方法進行呼叫。
這個被代理物件的方法的呼叫過程，會拆分成幾個橫切關注點：
- 方法呼叫前
- 方法呼叫
- 方法呼叫後
- 異常位置（catch塊）
- 方法最終呼叫位置（finally塊）
如下，切面類C的不同方法f1……fn可以在不同類A,B......的方法m1,m2......執行的過程中，在方法的不同橫切關注點任意切入/呼叫。
即切面類的任意方法可以在任意類的任意方法執行的過程中，在該方法的不同橫切關注點任意切入。
3.AOP的實現方式
- 基於動態代理的方式[內建AOP實現]
- 使用框架aspectj來實現
6.AOP程式設計快速入門
6.1基本說明
這裡使用框架aspectj來實現：
-
引入核心的aspect包
-
在切面類中宣告通知方法
- 前置通知：@Before
- 返回通知：@AfterReturning
- 異常通知：@AfterThrowing
- 後置通知：@After
- 環繞通知：@Around
-
五種通知和前面寫的動態代理類方法的對應關係：
6.2快速入門範例
使用aop程式設計的方式，來實現手寫的動態代理案例的效果。以上一篇的3.1為例子：
需求說明：有一個SmartAnimal介面，可以完成簡單的加減法，要求在執行getSum()和getSub()時，輸出執行前、執行過程、執行後的紀錄檔輸出，請思考如何實現
1.匯入AOP程式設計需要的包
2.程式碼實現
2.1SmartAnimal介面：
package com.li.aop.aspectj;
/**
* @author 李
* @version 1.0
*/
public interface SmartAnimal {
//求和
float getSum(float a, float b);
//求差
float getSub(float a, float b);
}
2.2SmartDog實現類：
package com.li.aop.aspectj;
import org.springframework.stereotype.Component;
/**
* @author 李
* @version 1.0
*/
//使用component註解，當spring容器啟動時，將SmartDog注入容器
@Component
public class SmartDog implements SmartAnimal {
@Override
public float getSum(float a, float b) {
float result = a + b;
System.out.println("方法內部列印 result = " + result);
return result;
}
@Override
public float getSub(float a, float b) {
float result = a - b;
System.out.println("方法內部列印 result = " + result);
return result;
}
}
2.3SmartAnimalAspect切面類：
package com.li.aop.aspectj;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
/**
* @author 李
* @version 1.0
* 切面類，類似之前寫的 MyProxyProvider，但是功能比它強大得多
*/
@Aspect //表示一個切面類[底層自動注入切面程式設計的支撐(動態代理+反射+動態繫結)]
@Component //注入切面類到ioc容器
public class SmartAnimalAspect {
/**
* 前置通知
* 1.@Before表示前置通知，即在我們的目標物件執行方法前執行
* 2.value = "execution(public float com.li.aop.aspectj.SmartDog.getSum(float, float))"
* 指定切入到哪個類的哪個方法 形式為：execution(存取修飾符 返回型別 全類名.方法名(形參列表))
* 3.f1方法就是一個切入方法，方法名隨意
* 4.JoinPoint joinPoint 在底層執行時，由AspectJ切面框架，給切入方法傳入joinPoint連線點物件
* 通過切面方法，可以獲取你想要的資訊
*
* @param joinPoint
*/
@Before(value = "execution(public float com.li.aop.aspectj.SmartDog.getSum(float, float))")
public void f1(JoinPoint joinPoint) {
//通過連線點物件joinPoint 拿到方法簽名
Signature signature = joinPoint.getSignature();
System.out.println("切面類f1()-方法執行開始-紀錄檔-方法名-" + signature.getName() +
"-引數 " + Arrays.toString(joinPoint.getArgs()));
}
//返回通知：把 f2方法切入到目標物件方法正常執行完畢後的位置
@AfterReturning(value = "execution(public float com.li.aop.aspectj.SmartDog.getSum(float, float))")
public void f2(JoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
System.out.println("切面類f2()-方法執行正常結束-紀錄檔-方法名-" + signature.getName());
}
//異常通知：把 f3方法切入到目標物件方法出現異常後的catch塊位置
@AfterThrowing(value = "execution(public float com.li.aop.aspectj.SmartDog.getSum(float, float))")
public void f3(JoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
System.out.println("切面類f3()-方法執行異常-紀錄檔-方法名-" + signature.getName());
}
//最終通知：把 f4方法切入到目標物件方法執行後的位置，無論有無出現異常都會執行
@After(value = "execution(public float com.li.aop.aspectj.SmartDog.getSum(float, float))")
public void f4(JoinPoint joinPoint) {
Signature signature = joinPoint.getSignature();
System.out.println("切面類f4()-方法最終執行完畢-紀錄檔-方法名-" + signature.getName());
}
}
2.4設定容器檔案beans07.xml：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--設定自動掃描的包-->
<context:component-scan base-package="com.li.aop.aspectj"/>
<!--一定要開啟基於註解的 AOP 功能-->
<aop:aspectj-autoproxy/>
</beans>
2.5測試類：
package com.li.aop.aspectj;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;
/**
* @author 李
* @version 1.0
* 測試類
*/
public class AopAspectjTest {
@Test
public void smartDogTestByAspectj() {
//得到Spring容器
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans07.xml");
//通過介面型別來獲得注入的SmartDog物件（實際上是代理物件proxy）
SmartAnimal smartAnimal = ioc.getBean(SmartAnimal.class);
//class com.sun.proxy.$Proxy15
//System.out.println("smartAnimal的執行型別=" + smartAnimal.getClass());
smartAnimal.getSum(100, 48);
}
}
測試結果：
6.3細節說明
-
關於切面類方法命名可以自己規範一下
-
切入表示式的更多設定，比如使用模糊設定
形式為：execution(存取修飾符 返回型別 全類名.方法名(形參列表))
@Before(value = "execution(* com.li.aop.aspect.SmartDog.*(..))") -
下面表示所有存取許可權，所有包下所有類的所有方法（前提是基於動態代理的類），都會被執行前置通知方法
@Before(value = "execution(* *.*(..))") -
spring容器開啟了基於註解的AOP功能
<aop:aspectj-autoproxy/>，獲取注入的物件則需要以介面的型別來獲取，因為你注入的物件.getClass()已經是代理型別了！ -
spring容器開啟了基於註解的AOP功能，也可以通過id來獲取注入的物件，但也要轉成介面型別來獲取。
6.4練習
- 有一個介面USBInterface，該介面有一個方法work
- 寫出實現子類Phone和Camera
- 寫一個切面類，在該切面類中寫一個方法（可輸出紀錄檔資訊）等作為前置通知，在Phone和Camera物件執行work方法前呼叫
- 其他通知，如返回通知，異常通知，後置通知，也可以加入