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教程