Spring之靜態/動態代理模式
阿新 • • 發佈：2020-10-20
代理模式
為什麼要學習代理模式，因為AOP的底層機制就是動態代理！
代理模式：
- 靜態代理
- 動態代理
學習aop之前 , 我們要先了解一下代理模式！
靜態代理
靜態代理角色分析
- 抽象角色 : 一般使用介面或者抽象類來實現
- 真實角色 : 被代理的角色
- 代理角色 : 代理真實角色 ; 代理真實角色後 , 一般會做一些附屬的操作 .
- 客戶 : 使用代理角色來進行一些操作 .
程式碼實現
Rent . java 即抽象角色
//抽象角色：租房
public interface Rent {
public void rent();
}
Host . java 即真實角色
//真實角色: 房東，房東要出租房子 public class Host implements Rent{ public void rent() { System.out.println("房屋出租"); } }
Proxy . java 即代理角色
//代理角色：中介 public class Proxy implements Rent { private Host host; public Proxy() { } public Proxy(Host host) { this.host = host; } //租房 public void rent(){ seeHouse(); host.rent(); fare(); } //看房 public void seeHouse(){ System.out.println("帶房客看房"); } //收中介費 public void fare(){ System.out.println("收中介費"); } }
Client . java 即客戶
//客戶類，一般客戶都會去找代理！
public class Client {
public static void main(String[] args) {
//房東要租房
Host host = new Host();
//中介幫助房東
Proxy proxy = new Proxy(host);
//你去找中介！
proxy.rent();
}
}
分析：在這個過程中，你直接接觸的就是中介，就如同現實生活中的樣子，你看不到房東，但是你依舊租到了房東的房子通過代理，這就是所謂的代理模式，程式源自於生活，所以學程式設計的人，一般能夠更加抽象的看待生活中發生的事情。
靜態代理的好處:
- 可以使得我們的真實角色更加純粹 . 不再去關注一些公共的事情 .
- 公共的業務由代理來完成 . 實現了業務的分工 ,
- 公共業務發生擴充套件時變得更加集中和方便 .
缺點 :
- 類多了 , 多了代理類 , 工作量變大了 . 開發效率降低 .
我們想要靜態代理的好處，又不想要靜態代理的缺點，所以 , 就有了動態代理 !
靜態代理再理解
同學們練習完畢後，我們再來舉一個例子，鞏固大家的學習！
練習步驟：
1、建立一個抽象角色，比如咋們平時做的使用者業務，抽象起來就是增刪改查！
//抽象角色：增刪改查業務
public interface UserService {
void add();
void delete();
void update();
void query();
}
2、我們需要一個真實物件來完成這些增刪改查操作
//真實物件，完成增刪改查操作的人
public class UserServiceImpl implements UserService {
public void add() {
System.out.println("增加了一個使用者");
}
public void delete() {
System.out.println("刪除了一個使用者");
}
public void update() {
System.out.println("更新了一個使用者");
}
public void query() {
System.out.println("查詢了一個使用者");
}
}
3、需求來了，現在我們需要增加一個日誌功能，怎麼實現！
- 思路1 ：在實現類上增加程式碼 【麻煩！】
- 思路2：使用代理來做，能夠不改變原來的業務情況下，實現此功能就是最好的了！
4、設定一個代理類來處理日誌！代理角色
//代理角色，在這裡面增加日誌的實現
public class UserServiceProxy implements UserService {
private UserServiceImpl userService;
public void setUserService(UserServiceImpl userService) {
this.userService = userService;
}
public void add() {
log("add");
userService.add();
}
public void delete() {
log("delete");
userService.delete();
}
public void update() {
log("update");
userService.update();
}
public void query() {
log("query");
userService.query();
}
public void log(String msg){
System.out.println("執行了"+msg+"方法");
}
}
5、測試訪問類：
public class Client {
public static void main(String[] args) {
//真實業務
UserServiceImpl userService = new UserServiceImpl();
//代理類
UserServiceProxy proxy = new UserServiceProxy();
//使用代理類實現日誌功能！
proxy.setUserService(userService);
proxy.add();
}
}
OK，到了現在代理模式大家應該都沒有什麼問題了，重點大家需要理解其中的思想；
我們在不改變原來的程式碼的情況下，實現了對原有功能的增強，這是AOP中最核心的思想
聊聊AOP：縱向開發，橫向開發
動態代理
- 動態代理的角色和靜態代理的一樣 .
- 動態代理的代理類是動態生成的 . 靜態代理的代理類是我們提前寫好的
- 動態代理分為兩類 : 一類是基於介面動態代理 , 一類是基於類的動態代理
- 基於介面的動態代理----JDK動態代理
- 基於類的動態代理--cglib
- 現在用的比較多的是 javasist 來生成動態代理 . 百度一下javasist
- 我們這裡使用JDK的原生程式碼來實現，其餘的道理都是一樣的！、
JDK的動態代理需要了解兩個類
核心 : InvocationHandler 和 Proxy ， 開啟JDK幫助文件看看
【InvocationHandler：呼叫處理程式】
Object invoke(Object proxy, 方法 method, Object[] args)；
//引數
//proxy - 呼叫該方法的代理例項
//method -所述方法對應於呼叫代理例項上的介面方法的例項。方法物件的宣告類將是該方法宣告的介面，它可以是代理類繼承該方法的代理介面的超級介面。
//args -包含的方法呼叫傳遞代理例項的引數值的物件的陣列，或null如果介面方法沒有引數。原始型別的引數包含在適當的原始包裝器類的例項中，例如java.lang.Integer或java.lang.Boolean 。
【Proxy : 代理】
//生成代理類
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
rent.getClass().getInterfaces(),this);
}
程式碼實現
抽象角色和真實角色和之前的一樣！
Rent . java 即抽象角色
//抽象角色：租房
public interface Rent {
public void rent();
}
Host . java 即真實角色
//真實角色: 房東，房東要出租房子
public class Host implements Rent{
public void rent() {
System.out.println("房屋出租");
}
}
ProxyInvocationHandler. java 即代理角色
public class ProxyInvocationHandler implements InvocationHandler {
private Rent rent;
public void setRent(Rent rent) {
this.rent = rent;
}
//生成代理類，重點是第二個引數，獲取要代理的抽象角色！之前都是一個角色，現在可以代理一類角色
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
rent.getClass().getInterfaces(),this);
}
// proxy : 代理類 method : 代理類的呼叫處理程式的方法物件.
// 處理代理例項上的方法呼叫並返回結果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
seeHouse();
//核心：本質利用反射實現！
Object result = method.invoke(rent, args);
fare();
return result;
}
//看房
public void seeHouse(){
System.out.println("帶房客看房");
}
//收中介費
public void fare(){
System.out.println("收中介費");
}
}
Client . java
//租客
public class Client {
public static void main(String[] args) {
//真實角色
Host host = new Host();
//代理例項的呼叫處理程式
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih.setRent(host); //將真實角色放置進去！
Rent proxy = (Rent)pih.getProxy(); //動態生成對應的代理類！
proxy.rent();
}
}
核心：一個動態代理 , 一般代理某一類業務 , 一個動態代理可以代理多個類，代理的是介面！、
深化理解
我們來使用動態代理實現代理我們後面寫的UserService！
我們也可以編寫一個通用的動態代理實現的類！所有的代理物件設定為Object即可！
public class ProxyInvocationHandler implements InvocationHandler {
private Object target;
public void setTarget(Object target) {
this.target = target;
}
//生成代理類
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}
// proxy : 代理類
// method : 代理類的呼叫處理程式的方法物件.
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log(method.getName());
Object result = method.invoke(target, args);
return result;
}
public void log(String methodName){
System.out.println("執行了"+methodName+"方法");
}
}
測試！
public class Test {
public static void main(String[] args) {
//真實物件
UserServiceImpl userService = new UserServiceImpl();
//代理物件的呼叫處理程式
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih.setTarget(userService); //設定要代理的物件
UserService proxy = (UserService)pih.getProxy(); //動態生成代理類！
proxy.delete();
}
}
測試，增刪改查，檢視結果！
動態代理的好處
靜態代理有的它都有，靜態代理沒有的，它也有！
- 可以使得我們的真實角色更加純粹 . 不再去關注一些公共的事情 .
- 公共的業務由代理來完成 . 實現了業務的分工 ,
- 公共業務發生擴充套件時變得更加集中和方便 .
- 一個動態代理 , 一般代理某一類業務
- 一個動態代理可以代理多個類，代理的是介面！