java設計模式之代理模式

時間  2020-11-15
標籤 java spring 設計模式 緩存 框架 ide 工具 測試 this spa 欄目 Java 简体版
原文   原文鏈接

代理模式的定義：

　　代理模式指爲其餘對象提供一種代理，以控制對這個對象的訪問，屬於結構型設計模式。java

在某種狀況下，一個對象不適合或者不能直接引用另外一個對象，而代理對象能夠在客戶端和目標對象之間起到中介的做用。spring

代理模式的應用場景：

  • 生活中的租房中介、婚姻介紹、經紀人、快遞、事物代理、日誌監聽等，都是代理模式的實際體現。
  • 當沒法或不想直接引用某個對象或訪問某個對象存在困難時，能夠經過代理對象來間接訪問。使用代理模式主要有兩個目的：一是保護目標對象，二是加強目標對象。

代理模式的UML類圖：

由上圖能夠看到，代理模式通常包含3個角色。設計模式

  • 抽象主體角色（ISubject）：抽象主題類的主要職責是聲明真實主題和代理的共同接口方法，例如途中的dosomething()方法，該類能夠是接口，也能夠是方法。
  • 真實主題角色（RealSubject）：該類也被稱爲被代理類，該類定義了代理所表示的真實對象，是負責執行系統的真正的業務邏輯對象。
  • 代理主題角色（Proxy）：也被稱爲代理類，其內部持有RealSubject的引用，所以具有徹底對RealSubjct的代理權。客戶端調用代理對象的方法，也調用被代理對象的方法，可是會在

代理對象先後增長一些處理代理。緩存

　　在代碼中，通常代理會被理解爲代碼加強，實際上就是在源代碼的邏輯先後增長一些代碼邏輯，而使調用在無感。代理模式分爲靜態代理和動態代理。框架

從靜態代理到動態代理：

　　舉個例子，有些人到了適婚年齡，會被父母催婚。因而父母就開始處處爲子女相親，比子女本身還着急。下面來看代碼實現。ide

建立頂層接口IPerson的代碼以下：工具

package com.liuyi.designmode.structure.proxy.statics;

/* *
 * @Author liuyi
 * @Description //TODO
 * @Date 2020/11/13 0:09
 **/
public interface IPerson {
    //尋找伴侶抽象方法
    public void findLove();
}

張三要找對象，實現Zhangsan類。測試

package com.liuyi.designmode.structure.proxy.statics;

/**
 * @ClassName Zhangsan
 * @description：
 * @author：liuyi
 * @Date：2020/11/13 0:11
 */
public class Zhangsan implements IPerson{
    @Override
    public void findLove() {
        System.out.println("兒子張三提出找對象要求");
    }
}

父親張老師幫兒子找對象，實現ZhangLaoSan類：this

package com.liuyi.designmode.structure.proxy.statics;

/**
 * @ClassName ZhangLaoSan
 * @description：
 * @author：liuyi
 * @Date：2020/11/13 0:13
 */
public class ZhangLaoSan implements IPerson{

    private Zhangsan zhangsan;

    public ZhangLaoSan(Zhangsan zhangsan){
        this.zhangsan = zhangsan;
    }

    @Override
    public void findLove() {
        System.out.println("父親張老三開始幫兒子物色對象");
        zhangsan.findLove();
        System.out.println("開始交往");
    }
}

來看客戶端測試代碼：spa

　　 這樣咱們就實現了父親幫助兒子去物色對象的目的（代理），雖然在沒有對代理類進行修改的前提下就對代理類實現了功能加強的目的。可是若是如今須要母親去幫住兒子物色對象，咱們又須要建立一個代理類，還有七大姑八大姨，這光是

建立代理類就夠嗆的，因此這個時候咱們就動態代理就閃亮登場了，下面咱們來看看使用JDK自帶的動態代理在本例中是如如何運用的：

首選建立媒婆類JdkMeipo：

package com.liuyi.designmode.structure.proxy.dynamic;

import com.liuyi.designmode.structure.proxy.statics.IPerson;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @ClassName JdkMeipo
 * @description：jdk自帶的動態代理實現
 * @author：liuyi
 * @Date：2020/11/13 23:36
 */
public class JdkMeipo implements InvocationHandler{

    private IPerson target;

    //獲取處理後的被代理對象
    public IPerson getInstance(IPerson iPerson){
        this.target = iPerson;
        Class<? extends IPerson> aClass = iPerson.getClass();
        IPerson iPersonProxy = (IPerson)Proxy.newProxyInstance(aClass.getClassLoader(), aClass.getInterfaces(), (InvocationHandler) this);
        return iPersonProxy;
    }


    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object invoke = method.invoke(this.target, args);
        after();
        return invoke;
    }

    private void before(){
        System.out.println("我是媒婆，以及收集到你的需求，開始物色");
    }

    private void after(){
        System.out.println("雙方贊成，開始交往");
    }

}

而後建立一個類ZhaoLiu：

package com.liuyi.designmode.structure.proxy.dynamic;

import com.liuyi.designmode.structure.proxy.statics.IPerson;

/**
 * @ClassName Zhaoliu
 * @description：
 * @author：liuyi
 * @Date：2020/11/13 23:47
 */
public class Zhaoliu implements IPerson {
    @Override
    public void findLove() {
        System.out.println("符合趙六要求");
    }

}

測試結果以下：

 

 

 代碼這樣寫咱們能夠發現，只要實現了IPerson接口的單身人士，媒婆（代理類）均可覺得其物色對象。

JDK動態代理原理分析：

　　不只知其然，還要知其因此然。既然JDK動態代理的功能如此強大，那麼它是如何實現的呢？如今咱們來研究一下原理，並模仿JDK動態代理手寫一個屬於本身的動態代理。

咱們知道JDK動態代理採用字節重組，從新生成對象來替代原始對象，以達到動態代理的目的。JDK動態代理生成對象的步驟以下：

  1. 獲取被代理對象的引用，而且經過反射獲取它的全部接口。
  2. JDK動態代理從新生成一個新的類，而且新的類要實現被代理類實現的全部接口。
  3. 動態生成java代碼，新加的業務邏輯方法由必定的邏輯代碼調用。
  4. 編譯生成新的java代碼.class文件。
  5. 從新加載到JVM中運行。

以上過程就叫作字節碼重組。JDK中有一個規範，在ClassPath下主要以$開頭的.class文件，通常都是自動生成的。那麼咱們有沒有辦法看到替代後的對象的"真容呢"？固然能夠，

咱們在測試類的main方法最前面加上這句話System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");就會在當前工做空間目錄的com.sun.proxy下生成

$Proxy0的class文件。經過反編譯以下圖所示：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.sun.proxy;

import com.liuyi.designmode.structure.proxy.statics.IPerson;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements IPerson {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void findLove() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.liuyi.designmode.structure.proxy.statics.IPerson").getMethod("findLove");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

　　咱們發現，$Proxy0繼承了Proxy類，同時實現了IPerson接口，並且重寫了findLove()等方法。在靜態塊中用反射查找到了目標對象的全部方法，並且保存了全部方法的引用，重寫

的方法用反射調用目標對象的方法。咱們來分析一下執行過程，咱們在測試類中調用findLove()方法，實際上是調用的JDK自動生成的代理類（$Proxy0）中的findLove()方法。從上面的

$Proxy0類能夠查看該方法的內容以下super.h.invoke(this, m3, (Object[])null)，此時它就會去調用JdkMeipo的invoke對象。而且你會發現$Proxy0中的每一個重寫代理對象的方法都是這樣

的寫法。這樣若是咱們想對整個類全部的方法進行加強，好比統計各個方法的執行時長，只須要在代理類的invoke方法上下功夫便可。

使用CGLib實現動態代理：

　　這裏咱們使用spring CGlib來實現，首先建立CglibMeipo代理類：

package com.liuyi.designmode.structure.proxy.dynamic.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @ClassName CGlibMeipo
 * @description：
 * @author：liuyi
 * @Date：2020/11/14 18:06
 */
public class CGlibMeipo implements MethodInterceptor {

    //獲取代理類方法
    public Object getInstance(Class<?> clazz) throws Exception{
        //至關於JDK中的Proxy類，是完成代理的工具類
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object objcet = methodProxy.invokeSuper(o, objects);
        after();
        return objcet;
    }

    private void before(){
        System.out.println("我是媒婆，已經收集到你的需求，開始物色");
    }

    private void after(){
        System.out.println("雙方贊成，開始交往");
    }

}

建立單身客戶類：

package com.liuyi.designmode.structure.proxy.dynamic.cglib;

/**
 * @ClassName Custmoer
 * @description：
 * @author：liuyi
 * @Date：2020/11/14 18:13
 */
public class Custmoer {
    public void findLove(){
        System.out.println("符合要求");
    }
}

測試類和結果：

 

 

 CGlib動態代理原理分析：

　　咱們先來修改一下測試類，生成CGlib生成的代理類class。代碼以下：

package com.liuyi.designmode.structure.proxy.dynamic.cglib;

import org.springframework.cglib.core.DebuggingClassWriter;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;

/**
 * @ClassName Test
 * @description：
 * @author：liuyi
 * @Date：2020/11/14 18:14
 */
public class Test {
    public static void main(String[] args) throws Exception {
        String property = System.getProperty("user.dir")+"\\src\\main\\java";
        System.out.println(property);
        String debugLocationProperty = DebuggingClassWriter.DEBUG_LOCATION_PROPERTY;
        System.setProperty(debugLocationProperty, property);
        CGlibMeipo cGlibMeipo = new CGlibMeipo();
        Custmoer custmoer = (Custmoer)cGlibMeipo.getInstance(Custmoer.class);
        custmoer.findLove();
    }
}

會在當前包下生成三個class文件，如圖：

 

 

 經過調試發現，Custmoer$$EnhancerByCGLIB$$6d34774c.class就是CGlib動態生成的代理類，繼承了Customer類。Custmoer$$EnhancerByCGLIB$$6d34774c$$FastClassByCGLIB$$85b603b1.class

和Custmoer$$FastClassByCGLIB$$64367e13分別是代理類和被代理類的fastClass，稍後會講解fastClass是什麼。咱們先來看看代理類的源碼：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.liuyi.designmode.structure.proxy.dynamic.cglib;

import java.lang.reflect.Method;
import org.springframework.cglib.core.ReflectUtils;
import org.springframework.cglib.core.Signature;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Factory;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class Custmoer$$EnhancerByCGLIB$$6d34774c extends Custmoer implements Factory {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$findLove$0$Method;
    private static final MethodProxy CGLIB$findLove$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$equals$1$Method;
    private static final MethodProxy CGLIB$equals$1$Proxy;
    private static final Method CGLIB$toString$2$Method;
    private static final MethodProxy CGLIB$toString$2$Proxy;
    private static final Method CGLIB$hashCode$3$Method;
    private static final MethodProxy CGLIB$hashCode$3$Proxy;
    private static final Method CGLIB$clone$4$Method;
    private static final MethodProxy CGLIB$clone$4$Proxy;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("com.liuyi.designmode.structure.proxy.dynamic.cglib.Custmoer$$EnhancerByCGLIB$$6d34774c");
        Class var1;
        CGLIB$findLove$0$Method = ReflectUtils.findMethods(new String[]{"findLove", "()V"}, (var1 = Class.forName("com.liuyi.designmode.structure.proxy.dynamic.cglib.Custmoer")).getDeclaredMethods())[0];
        CGLIB$findLove$0$Proxy = MethodProxy.create(var1, var0, "()V", "findLove", "CGLIB$findLove$0");
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$1$Method = var10000[0];
        CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
        CGLIB$toString$2$Method = var10000[1];
        CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
        CGLIB$hashCode$3$Method = var10000[2];
        CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
        CGLIB$clone$4$Method = var10000[3];
        CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
    }

    final void CGLIB$findLove$0() {
        super.findLove();
    }

    public final void findLove() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$findLove$0$Method, CGLIB$emptyArgs, CGLIB$findLove$0$Proxy);
        } else {
            super.findLove();
        }
    }

    final boolean CGLIB$equals$1(Object var1) {
        return super.equals(var1);
    }

    public final boolean equals(Object var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy);
            return var2 == null ? false : (Boolean)var2;
        } else {
            return super.equals(var1);
        }
    }

    final String CGLIB$toString$2() {
        return super.toString();
    }

    public final String toString() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy) : super.toString();
    }

    final int CGLIB$hashCode$3() {
        return super.hashCode();
    }

    public final int hashCode() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy);
            return var1 == null ? 0 : ((Number)var1).intValue();
        } else {
            return super.hashCode();
        }
    }

    final Object CGLIB$clone$4() throws CloneNotSupportedException {
        return super.clone();
    }

    protected final Object clone() throws CloneNotSupportedException {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy) : super.clone();
    }

    public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch(var10000.hashCode()) {
        case -508378822:
            if (var10000.equals("clone()Ljava/lang/Object;")) {
                return CGLIB$clone$4$Proxy;
            }
            break;
        case 1192015562:
            if (var10000.equals("findLove()V")) {
                return CGLIB$findLove$0$Proxy;
            }
            break;
        case 1826985398:
            if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                return CGLIB$equals$1$Proxy;
            }
            break;
        case 1913648695:
            if (var10000.equals("toString()Ljava/lang/String;")) {
                return CGLIB$toString$2$Proxy;
            }
            break;
        case 1984935277:
            if (var10000.equals("hashCode()I")) {
                return CGLIB$hashCode$3$Proxy;
            }
        }

        return null;
    }

    public Custmoer$$EnhancerByCGLIB$$6d34774c() {
        CGLIB$BIND_CALLBACKS(this);
    }

    public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }

    public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
        CGLIB$STATIC_CALLBACKS = var0;
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        Custmoer$$EnhancerByCGLIB$$6d34774c var1 = (Custmoer$$EnhancerByCGLIB$$6d34774c)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (var10000 == null) {
                    return;
                }
            }

            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }

    }

    public Object newInstance(Callback[] var1) {
        CGLIB$SET_THREAD_CALLBACKS(var1);
        Custmoer$$EnhancerByCGLIB$$6d34774c var10000 = new Custmoer$$EnhancerByCGLIB$$6d34774c();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Callback var1) {
        CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
        Custmoer$$EnhancerByCGLIB$$6d34774c var10000 = new Custmoer$$EnhancerByCGLIB$$6d34774c();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        Custmoer$$EnhancerByCGLIB$$6d34774c var10000 = new Custmoer$$EnhancerByCGLIB$$6d34774c;
        switch(var1.length) {
        case 0:
            var10000.<init>();
            CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
            return var10000;
        default:
            throw new IllegalArgumentException("Constructor not found");
        }
    }

    public Callback getCallback(int var1) {
        CGLIB$BIND_CALLBACKS(this);
        MethodInterceptor var10000;
        switch(var1) {
        case 0:
            var10000 = this.CGLIB$CALLBACK_0;
            break;
        default:
            var10000 = null;
        }

        return var10000;
    }

    public void setCallback(int var1, Callback var2) {
        switch(var1) {
        case 0:
            this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
        default:
        }
    }

    public Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[]{this.CGLIB$CALLBACK_0};
    }

    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
    }

    static {
        CGLIB$STATICHOOK1();
    }
}

能夠看到，代理類重寫了Customer的全部方法，而且每一個方法都有一個代理自動生成的方法與之對應，好比findLove()方法對應的就是CGLIB$findLove$0方法。

 

 

 咱們來分析下調用流程，當咱們在測試類中調用findLove方法，進入代理類的findLove()方法，代碼以下：

public final void findLove() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$findLove$0$Method, CGLIB$emptyArgs, CGLIB$findLove$0$Proxy);
        } else {
            super.findLove();
        }
    }

這裏會調用父類的intercept()方法，至於爲何說是調用父類的intercept()方法，經過查看var10000變量的來源，能夠發現就是Callback對象，咱們再來看CGlibMeipo類：

 

 Callback就是CGlibMeipo，因此var10000對應的就是代理的對象，那這裏調用intercept()天然就來到了代理類的intercept()方法，代碼以下：

 

查看invokeSuper方法

 

　　 上面的代碼調用獲取代理類對應的FastClass，並執行代理方法。CGLib動態代理執行代理方法的效率之因此被JDK高，就是由於CGLib採用了FastClass機制，它的原理簡單來講就是：

爲代理類和被代理類各生成一個類，這個類會爲代理類或被代理類的方法分配一個index；而後調用對應的方法時，只須要傳入對應的index，就能夠快速執行該方法，而不是須要根據

反射去調用。所以調用效率要比JDK動態代理高。FastClass並非跟代理類一塊兒生成的，而是在調用具體方法的時候生成的，並被放到緩衝中。

　　因此再回到咱們的調用流程，這裏會生成兩個對應的FastClass，並最終會經過被代理類的FastClass調用被代理類的findLove()方法，而後再執行after()方法，整個調用流程結束。

至此，咱們基本清楚了CGLib動態代理的原理，對代碼細節感興趣的小夥伴能夠自行深刻研究。

CGLib和JDK動態代理的對比分析：

  • JDK動態代理實現了被代理對象的接口，CGLib動態代理繼承了被代理對象，也就是說要實現JDK動態代理，被代理的對象必需要有接口，而CGLib不須要。
  • JDK動態代理和CGLib動態代理都在運行時生成字節碼，JDK動態代理直接寫Class字節碼，CGLib動態代理使用ASM框架寫Class字節碼。CGLib動態代理實現更復雜，生成代理類比JDK動態代理效率低。
  • JDK動態代理調用代理方法是經過反射機制調用的，而CGLib動態代理是經過FastClass機制直接調用方法的，並自帶緩存機制，因此CGLib的執行效率要高。

靜態代理和動態代理的區別：

  • 靜態代理只能經過手動完成代理操做，若是被代理類增長了方法，則代理類也須要同步增長，違背開閉原則。
  • 動態代理採用在運行時動態生成代碼的方法，取消了對被代理類的擴展限制，遵循開閉原則。
  • 若動態代理要對目標類的加強邏輯進行擴展，結合策略模式，只須要新增策略即可完成，無須修改代理類的代碼。

代理模式的優勢：

  • 代理模式能將代理對象與真實被調用目標對象分離。
  • 在必定程度上下降了系統的耦合性，擴展性好。
  • 能夠起到保護目標對象的做用。
  • 能夠加強目標對象的功能。

代理模式的缺點：

  • 代理模式會形成系統設計中類的數量增長。
  • 在客戶端和目標對象中增長一個代理對象，會致使處理請求的速度變慢。
  • 增長了系統的複雜度。
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程