帶你深入了解java-代理機制

更新時間：2021年08月20日 17:09:42 作者：haijiao12138

Java 有兩種代理方式，一種是靜態(tài)代理，另一種是動態(tài)代理。如果我們在代碼編譯時就確定了被代理的類是哪一個，那么就可以直接使用靜態(tài)代理；如果不能確定，那么可以使用類的動態(tài)加載機制，在代碼運行期間加載被代理的類這就是動態(tài)代理

1-代理模式

代理（Proxy）是一種設(shè)計模式。提供了對目標對象另外的訪問方式，即通過代理對象訪問目標對象，這樣的優(yōu)點是：可以在目標對象實現(xiàn)的基礎(chǔ)上，增強額外的功能操作，即擴展目標對象的功能。

編程思想：不隨意去修改別人已經(jīng)寫好的代碼或者方法，如果需要修改，通過代理的方式來拓展該方法。

例子：比如邀請一位明星，那么并不是直接連線邀請明星，而是聯(lián)系明星的經(jīng)紀人來達到同樣的目的，明星就是一個目標對象，他只要負責活動中的節(jié)目，而其他瑣碎的事情就交給他的代理人（經(jīng)紀人）來解決，這就是生活中的一個代理的例子；

圖例如下：

1.1靜態(tài)代理

使用靜態(tài)代理時，需要定義接口或者父類，被代理對象與代理對象一起實現(xiàn)相同的接口或者是繼承相同的父類。

代碼實例：

接口：TargetInteface.java

/**
*  接口類
*/
public interface TargetInteface {
    void method1();
    void method2();
    int method3(Integer i);
}

目標對象類：Target.java，用來實現(xiàn)接口，實現(xiàn)接口，實現(xiàn)接口中的方法

public class Target implements TargetInteface {
    @Override
    public void method1() {
        System.out.println("method1 running ...");
    }

    @Override
    public void method2() {
        System.out.println("method2 running ...");
    }

    @Override
    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

代理對象類：TargetProxy.java

public class TargetProxy implements TargetInteface {

    @Override
    public void method1() {
        System.out.println("執(zhí)行方法前...");//在此處填寫自己的業(yè)務需求
        new Target().method1();
        System.out.println("執(zhí)行方法后...");
    }

    @Override
    public void method2() {
        System.out.println("執(zhí)行方法前...");
        new Target().method2();
        System.out.println("執(zhí)行方法后...");
    }

    @Override
    public int method3(Integer i) {
        System.out.println("執(zhí)行方法前...");
        int method3 = new Target().method3(i);
        System.out.println("執(zhí)行方法后...");
        return method3;
    }
}

測試類：TargetUser.java

public static void main(String[] args) {
    TargetInteface target = new TargetProxy();
    target.method1();
    System.out.println("-----------------------------");
    target.method2();
    System.out.println("-----------------------------");
    System.out.println(target.method3(3));
}

運行結(jié)果如下：

靜態(tài)代理總結(jié)：

1-在不修改目標對象的前提下，對功能目標進行拓展

2-缺點：因為代理對象需要和目標對象實現(xiàn)一樣的接口，所以會有很多代理類，導致類太多；同時一旦接口增加方法，目標對象與代理對象都需要增加維護，使用動態(tài)代理解決此缺點；

1.2 動態(tài)代理

特點：

1-代理對象，不需要實現(xiàn)接口；

2-代理對象的生成是利用JDK的API，動態(tài)的在內(nèi)存中構(gòu)建代理對象（需要我們指定創(chuàng)建代理對象/目標對象實現(xiàn)的接口的類型）

3-動態(tài)代理也叫作JDK代理，接口代理；

JDK中生成代理對象的API

代理對象坐在的包:java.lang.reflect.Proxy

JDK實現(xiàn)代理只需要使用newProxyInstance方法,但是該方法需要接收三個參數(shù),完整的寫法是:

static Object newProxyInstance(
 ClassLoader loader,//指定當前目標對象使用類加載器,獲取加載器的方法是固定的
 Class<?>[] interfaces,//目標對象實現(xiàn)的接口的類型,使用泛型方式確認類型
 InvocationHandler h )//事件處理,執(zhí)行目標對象的方法時,會觸發(fā)事件處理器的方法,會把當前執(zhí)行目標對象的方法作為參數(shù)傳入

代碼示例：

接口類：TargetInteface.java

public interface TargetInteface {
    void method1();
    void method2();
    int method3(Integer i);
}

接口實現(xiàn)類：Target.java

public class Target implements TargetInteface {
    @Override
    public void method1() {
        System.out.println("method1 running ...");
    }

    @Override
    public void method2() {
        System.out.println("method2 running ...");
    }

    @Override
    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

代理工廠類：TargetProxy.java

public class TargetProxy {
    public static  <T> Object getTarget(T t) {
        return Proxy.newProxyInstance(t.getClass().getClassLoader(),
                t.getClass().getInterfaces(),
                new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // proxy就是目標對象t，method就是調(diào)用目標對象中方法，args就是調(diào)用目標對象中方法的參數(shù)。
                //比如說：代理對象.method1(),這時proxy就是目標類，method1就是method,args就是method1方法參數(shù)。
                System.out.println("執(zhí)行方法前...");
                Object invoke = method.invoke(t, args);//執(zhí)行目標對象方法
                System.out.println("執(zhí)行方法后...");
                return invoke;
            }
        });
    }
}

測試類：TargetUser.java

    public static void main(String[] args) {
        TargetInteface target = (TargetInteface) TargetProxy.getTarget(new Target());
        target.method1();
        System.out.println("-----------------------------");
        target.method2();
        System.out.println("-----------------------------");
        System.out.println(target.method3(3));
    }

運行結(jié)果：

總結(jié)：代理對象不需要實現(xiàn)接口，但是目標對象一定要實現(xiàn)接口，否則不能用動態(tài)代理

1.2 Cglib代理

前面說的靜態(tài)代理和動態(tài)代理模式都是要求目標對象是實現(xiàn)一個接口的目標對象，但是有時候目標對象只是一個單獨的對象，并沒有實現(xiàn)任何的接口，這個時候就可以使用以目標對象子類的方式類實現(xiàn)代理，成為Cglib代理；

Cglib代理,也叫作子類代理,它是在內(nèi)存中構(gòu)建一個子類對象從而實現(xiàn)對目標對象功能的擴展.

JDK的動態(tài)代理有一個限制,就是使用動態(tài)代理的對象必須實現(xiàn)一個或多個接口,如果想代理沒有實現(xiàn)接口的類,就可以使用Cglib實現(xiàn).
Cglib是一個強大的高性能的代碼生成包,它可以在運行期擴展java類與實現(xiàn)java接口.它廣泛的被許多AOP的框架使用,例如Spring AOP和synaop,為他們提供方法的interception(攔截)
Cglib包的底層是通過使用一個小而塊的字節(jié)碼處理框架ASM來轉(zhuǎn)換字節(jié)碼并生成新的類.不鼓勵直接使用ASM,因為它要求你必須對JVM內(nèi)部結(jié)構(gòu)包括class文件的格式和指令集都很熟悉.

Cglib子類代理實現(xiàn)方法:

1.需要引入cglib的jar文件,但是Spring的核心包中已經(jīng)包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.

2.引入功能包后,就可以在內(nèi)存中動態(tài)構(gòu)建子類

3.代理的類不能為final,否則報錯

4.目標對象的方法如果為final/static,那么就不會被攔截,即不會執(zhí)行目標對象額外的業(yè)務方法.

代碼示例：

目標對象類：Target.java

public class Target {
    public void method1() {
        System.out.println("method1 running ...");
    }

    public void method2() {
        System.out.println("method2 running ...");
    }

    public int method3(Integer i) {
        System.out.println("method3 running ...");
        return i;
    }
}

Cglib代理工廠:TargetProxy.java

public class TargetProxy {

    static <T> Object getProxy(T t) {
        Enhancer en = new Enhancer(); //幫我們生成代理對象
        en.setSuperclass(t.getClass());//設(shè)置要代理的目標類
        en.setCallback(new MethodInterceptor() {//代理要做什么
            @Override
            public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("執(zhí)行方法前。。。");
                //調(diào)用原有方法  
                Object invoke = methodProxy.invokeSuper(object, args);
                // Object invoke = method.invoke(t, args);// 作用等同與上面。
                System.out.println("執(zhí)行方法后。。。");
                return invoke;
            }
        });
        return en.create();
    }
}

測試類：TargetUser.java

public class TargetUser {

    public static void main(String[] args) {
        Target target = (Target) TargetProxy.getProxy(new Target());
        target.method1();
    }

}

運行結(jié)果：