Java的動態代理和靜態代理詳解

Posted on by

0、代理模式

為什麼要學習代理模式？這是SpringAOP的底層【SpringAOP和SpringMVC】

代理模式的分類：

  • 靜態代理
  • 動態代理

1、靜態代理

靜態代理中，我們對目標對象的每個方法的增強都是手動完成的（後面會具體演示代碼_），非常不靈活（比如接口一旦新增加方法，目標對象和代理對象都要進行修改）且麻煩(_需要對每個目標類都單獨寫一個代理類)。 實際應用場景非常非常少，日常開發幾乎看不到使用靜態代理的場景。

角色分析：

  • 抽象角色：一般會使用接口或者抽象類來解決
  • 真實角色：被代理的角色
  • 代理角色：代理真實角色，代理真實角色後，我們一般會做一些附屬操作
  • 客戶：訪問代理對象的人！

代碼步驟：

1、接口

public interface Rent {
    public void rent();
}

2、真實角色

//房東
public class Host implements Rent {
    public void rent() {
        System.out.println("房東要租房子");
    }
}

3、代理角色

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("中介收費");
    }
}

4、客服端訪問代理角色

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        //代理，代理角色一般會有附屬操作！
        Proxy proxy = new Proxy(host);
        proxy.rent();
    }
}

代理模式的好處：

  • 可以使真實角色的操作更加純粹！不用去關註一些公共的業務
  • 公共也就交給代理角色！實現業務的分工！
  • 公共業務發生擴展的時候，方便集中管理！

缺點：

一個真實角色會產生一個代理角色；從JVM角度來看，靜態代理在編譯時就將接口、實現類、代理類這些都變成瞭一個個實際的class文件。

2、 加深理解

AOP，的底層代理模式

在這裡插入圖片描述

3、動態代理

  • 動態代理和靜態代理角色一樣
  • 動態代理的代理類是動態生成的，不是我們直接寫好的！
  • 動態代理分為兩大類：基於接口的動態代理，基於類的動態代理
    • 基於接口——JDK動態代理
    • 基於類：cglib動態代理
    • java字節碼實現：javasist

需要瞭解兩個類：Proxy: 代理類，InvocationHandler ： 調用處理程序

從 JVM 角度來說，動態代理是在運行時動態生成類字節碼，並加載到 JVM 中的。

//Proxy是生成動態代理類，提供瞭創建動態代理類和實例的靜態方法，它也是由這些方法創建的所有動態代理類的超類。
//InvocationHandler-- invoke 調用處理程序並返回接口， 是由代理實例的調用處理程序實現的接口 。

動態代理的好處：

  • 可以使真實角色的操作更加純粹！不用去關系一些公共的業務
  • 公共也就交給代理角色！實現
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h){
}

1.loader :類加載器，用於加載代理對象。

2.interfaces : 被代理類實現的一些接口；

3.h : 實現瞭 InvocationHandler 接口的對象；

要實現動態代理的話，還必須需要實現InvocationHandler 來自定義處理邏輯。 當我們的動態代理對象調用一個方法時，這個方法的調用就會被轉發到實現InvocationHandler 接口類的 invoke 方法來調用。

public interface InvocationHandler {
    Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}

1.proxy :動態生成的代理類

2.method : 與代理類對象調用的方法相對應

3.args : 當前 method 方法的參數

動態代理的例子

1、定義接口

public interface Rent {
    public void rent();
}

2、實現租房的接口

public class Host implements Rent {
    @Override
    public void rent() {
        System.out.println("房東要租房");
    }
}

3、定義一個JDK動態代理類

public class DebugInvocationHandler implements InvocationHandler {
    /**
     * 代理類中的真實對象
     */
    private final Object target;
    public DebugInvocationHandler(Object target){
        this.target = target;
    }
    /**
     * 當你使用代理對象調用方法的時候實際會調用到這個方法
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //調用方法前
        System.out.println("before method" + method.getName());
        Object res = method.invoke(target, args);
        //調用方法後
        System.out.println("after method" + method.getName());
        return res;
    }
}

invoke() 方法: 當我們的動態代理對象調用原生方法的時候，最終實際上調用到的是 invoke() 方法，然後 invoke() 方法代替我們去調用瞭被代理對象的原生方法。

4、獲取代理對象的工廠類

public class JdkProxyFactory {
    public static Object getProxy(Object target){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new DebugInvocationHandler(target)
        );
    }
}

getProxy() ：主要通過Proxy.newProxyInstance（）方法獲取某個類的代理對象

5、實際使用

public static void main(String[] args) {
        //Rent rent = new Host();
        //Rent rentProxy= (Rent) Proxy.newProxyInstance(rent.getClass().getClassLoader(), rent.getClass().getInterfaces(),new DebugInvocationHandler(rent));
        Rent rentProxy = (Rent)JdkProxyFactory.getProxy(new Host());
        rentProxy.rent();
    }

運行上述代理的輸出

before methodrent
房東要租房
after methodrent

總結

本篇文章就到這裡瞭，希望能夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容!    

推薦閱讀：