本文共 17420 字，大约阅读时间需要 58 分钟。

一　概述

代理模式其实很常见，比如买火车票这件小事：黄牛相当于是我们本人的的代理，我们可以通过黄牛买票。通过黄牛买票，我们可以避免与火车站的直接交互，可以省很多事，并且还能享受到黄牛更好的服务(如果钱给够的话)。在软件开发中，代理也具有类似的作用，并且一般可以分为静态代理和动态代理两种，上述的这个黄牛买票的例子就是静态代理。

那么，静态代理与动态代理的区别是什么呢？所谓静态代理，其实质是自己手写(或者用工具生成)代理类，也就是在程序运行前就已经存在的编译好的代理类。但是，如果我们需要很多的代理，每一个都这么去创建实属浪费时间，而且会有大量的重复代码，此时我们就可以采用动态代理，动态代理可以在程序运行期间根据需要动态的创建代理类及其实例来完成具体的功能。总的来说，根据代理类的创建时机和创建方式的不同，我们可以将代理分为静态代理和动态代理两种形式。

就像我们也可以自己直接去买票一样，在软件开发中，方法直接调用就可以完成功能，为什么非要通过代理呢？原因是采用代理模式可以有效的将具体的实现 (买票过程) 与调用方 (买票者) 进行解耦，通过面向接口进行编码完全将具体的实现 (买票过程) 隐藏在内部 (黄牛)。此外，代理类不仅仅是一个隔离客户端和目标类的中介，我们还可以借助代理来在增加一些功能，而不需要修改原有代码，是开闭原则的典型应用。代理类主要负责为目标类预处理消息、过滤消息、把消息转发给目标类，以及事后处理消息等。代理类与目标类之间通常会存在关联关系，一个代理类的对象与一个目标类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用目标类的对象的相关方法，来提供特定的服务。总的来说：

• 代理对象存在的价值主要用于拦截对真实业务对象的访问 (我们不需要直接与火车站打交道，而是把这个任务委托给黄牛)
• 代理对象应该具有和目标对象 (真实业务对象) 相同的方法，即实现共同的接口或继承于同一个类
• 代理对象应该是目标对象的增强，否则我们就没有必要使用代理了

事实上，真正的业务功能还是由目标类来实现，代理类只是用于扩展、增强目标类的行为。例如，在项目开发中我们没有加入缓冲、日志这些功能而后期需要加入，我们就可以使用代理来实现，而没有必要去直接修改已经封装好的目标类。

代理模式用图简单表示如下:

代理模式的关键点是：代理对象与目标对象。代理对象是对目标对象的扩展，并会调用目标对象

二　代理模式

代理模式是较常见的设计模式之一，代理模式就是为其他对象提供一种代理，以控制对这个对象的访问。代理对象起到中介作用，可去掉功能服务或增加额外的服务。代理模式的 UML 示意图如下：

代理模式包含如下几个角色：

• 客户端：客户端面向接口编程，使用代理角色完成某项功能
• 抽象主题：一般实现为接口，是对 (被代理对象的) 行为的抽象
• 被代理角色(目标类)：直接实现上述接口，是抽象主题的具体实现
• 代理角色(代理类)：实现上述接口，是对被代理角色的增强

代理模式的使用本质上是对开闭原则 (Open for Extension, Close for Modification) 的直接支持。

三　静态代理

静态代理在使用时，需要定义接口或者父类，被代理对象与代理对象一起实现相同的接口或者是继承相同父类。

下面举个案例来解释：

模拟保存动作，定义一个保存动作的接口：IUserDao.java，然后目标对象实现这个接口的方法 UserDao.java，此时如果使用静态代理方式，就需要在代理对象 (UserDaoProxy.java) 中也实现 IUserDao 接口。调用的时候通过调用代理对象的方法来调用目标对象。

需要注意的是，代理对象与目标对象要实现相同的接口，然后通过调用相同的方法来调用目标对象的方法。

代码示例：

接口：IUserDao.java

/** * 接口 */public interface IUserDao {       void save();}

目标对象：UserDao.java

/** * 接口实现 目标对象 */public class UserDao implements IUserDao {       public void save() {           System.out.println("----已经保存数据!----");    }}

代理对象：UserDaoProxy.java

/** * 代理对象,静态代理 */public class UserDaoProxy implements IUserDao{       //接收保存目标对象    private IUserDao target;    public UserDaoProxy(IUserDao target){           this.target=target;    }    public void save() {           System.out.println("开始事务...");        target.save();//执行目标对象的方法        System.out.println("提交事务...");    }}

测试类：App.java

/** * 测试类 */public class App {       public static void main(String[] args) {           //目标对象        UserDao target = new UserDao();        //代理对象,把目标对象传给代理对象,建立代理关系        UserDaoProxy proxy = new UserDaoProxy(target);        proxy.save();//执行的是代理的方法    }}

静态代理实现的两种方式：使用继承或聚合方式实现

• 继承：代理对象继承目标对象，重写需要增强的方法。缺点：代理类过多，产生类爆炸
• 聚合：目标对象和代理对象实现同一个接口，代理对象当中要包含目标对象

静态代理总结：

• 优点：良好的扩展性，可以做到在不修改目标对象功能的前提下，对目标功能进行扩展。
• 缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类，类太多；同时，一旦接口增加方法，目标对象与代理对象都要同步维护

如何解决静态代理中的缺点呢？答案是可以使用动态代理方式

四　动态代理

代理类在程序运行时创建的代理方式被成为动态代理。也就是说，这种情况下，代理类并不是在 Java 代码中定义的，而是在运行时根据我们在 Java 代码中的 “指示” 动态生成的。

4.1 JDK动态代理

JDK 动态代理相关类位于 java.lang.reflect 包下，一般主要涉及到以下两个类：

1.Interface InvocationHandler：该接口中仅定义了一个方法

public object invoke(Object obj,Method method, Object[] args)

在实际使用时，第一个参数 obj 一般是指代理类，method 是被代理的方法，args 为该方法的参数数组。这个抽象方法在代理类中动态实现。

2.Proxy：该类即为动态代理类，其中主要包含以下内容：

• protected Proxy(InvocationHandler h)：构造函数，用于给内部的 h 赋值
• static Class getProxyClass (ClassLoaderloader, Class[] interfaces)：获得一个代理类，其中 loader 是类装载器，interfaces 是真实类所拥有的全部接口的数组
• static Object newProxyInstance (ClassLoaderloader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类实例可以当作被代理类使用 (可使用被代理类在 Subject 接口中声明过的方法)

所谓 DynamicProxy 是这样一种 class：它是在运行时生成的 class，在生成它时你必须提供一组 interface 给它，然后该 class 就宣称它实现了这些 interface。你当然可以把该 class 的实例当作这些 interface 中的任何一个来用。当然，这个 DynamicProxy 其实就是一个 Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个 handler，由它接管实际的工作。

在使用动态代理类时，我们必须实现 InvocationHandler 接口

通过这种方式，被代理的对象 (RealSubject) 可以在运行时动态改变，需要控制的接口 (Subject接口) 可以在运行时改变，控制的方式 (DynamicSubject 类) 也可以动态改变，从而实现了非常灵活的动态代理关系。

4.1.1 JDK动态代理使用

声明接口

/** * 需要动态代理的接口 */public interface Subject{       /**     * @param name     * @return     */    public String SayHello(String name);     /**     * @return     */    public String SayGoodBye();}

需要代理的实际对象

/** * 实际对象 */public class RealSubject implements Subject{        public String SayHello(String name)    {           return "hello " + name;    }     public String SayGoodBye()    {           return " good bye ";    }}

调用处理器实现类

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method; /** * 调用处理器实现类 * 每次生成动态代理类对象时都需要指定一个实现了该接口的调用处理器对象 */public class InvocationHandlerImpl implements InvocationHandler{        private Object subject;//这个就是我们要代理的真实对象    /**     * 构造方法，给我们要代理的真实对象赋初值     * @param subject     */    public InvocationHandlerImpl(Object subject)    {           this.subject = subject;    }     /**     * 该方法负责集中处理动态代理类上的所有方法调用。     * 调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行     * @param proxy  代理类实例     * @param method 被调用的方法对象     * @param args   调用参数     * @return     * @throws Throwable     */    public Object invoke(Object proxy, Method method, Object[] args)             throws Throwable    {           //在代理真实对象前我们可以添加一些自己的操作        System.out.println("在调用之前，我要干点啥呢？");         System.out.println("Method:" + method);         //当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联        //的handler对象的invoke方法来进行调用        Object returnValue = method.invoke(subject, args);         //在代理真实对象后我们也可以添加一些自己的操作        System.out.println("在调用之后，我要干点啥呢？");         return returnValue;    }}

测试

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Proxy;/** * 动态代理演示 */public class DynamicProxyDemonstration{       public static void main(String[] args)    {           //代理的真实对象        Subject realSubject = new RealSubject();                /**         * InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发         * 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用.         * 即：要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法         */        InvocationHandler handler = new InvocationHandlerImpl(realSubject);         ClassLoader loader = realSubject.getClass().getClassLoader();        Class[] interfaces = realSubject.getClass().getInterfaces();        // 该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例        Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);         System.out.println("动态代理对象的类型："+subject.getClass().getName());         String hello = subject.SayHello("jiankunking");        System.out.println(hello);//        String goodbye = subject.SayGoodBye();//        System.out.println(goodbye);    } }

结果

4.1.2 JDK动态代理原理

先说JDK源代码实现的步骤：

• 为接口创建代理类的字节码文件
• 使用 ClassLoader 将字节码文件加载到 JVM
• 创建代理类实例对象，执行对象的目标方法

动态代理涉及到的主要类：

java.lang.reflect.Proxyjava.lang.reflect.InvocationHandlerjava.lang.reflect.WeakCachesun.misc.ProxyGenerator

既然生成代理对象是用的 Proxy 类的静态方法 newProxyInstance，那么我们就先分析这个方法

@CallerSensitive public static Object newProxyInstance(ClassLoader loader,                                          Class<?>[] interfaces,                                          InvocationHandler h)        throws IllegalArgumentException    {   		//检查h不为空，否则抛异常        Objects.requireNonNull(h);         final Class<?>[] intfs = interfaces.clone();        final SecurityManager sm = System.getSecurityManager();        if (sm != null) {               checkProxyAccess(Reflection.getCallerClass(), loader, intfs);        }        //生成接口的代理类的字节码文件        Class<?> cl = getProxyClass0(loader, intfs);//使用自定义的InvocationHandler作为参数，通过反射获取构造函数对象并生成代理类实例        try {               if (sm != null) {                   checkNewProxyPermission(Reflection.getCallerClass(), cl);            }			//获取代理对象的构造方法（也就是$Proxy0(InvocationHandler h)）             final Constructor<?> cons = cl.getConstructor(constructorParams);            final InvocationHandler ih = h;            if (!Modifier.isPublic(cl.getModifiers())) {                   AccessController.doPrivileged(new PrivilegedAction<Void>() {                       public Void run() {                           cons.setAccessible(true);                        return null;                    }                });            }			//生成代理类的实例并把InvocationHandlerImpl的实例传给它的构造方法            return cons.newInstance(new Object[]{   h});        } catch (IllegalAccessException|InstantiationException e) {               ......        } catch (InvocationTargetException e) {               ......        } catch (NoSuchMethodException e) {               throw new InternalError(e.toString(), e);        }    }

调用 getProxyClass0 方法生成代理类的字节码文件

private static Class<?> getProxyClass0(ClassLoader loader,                                           Class<?>... interfaces) {           // 限定代理的接口不能超过65535个        if (interfaces.length > 65535) {               throw new IllegalArgumentException("interface limit exceeded");        }//如果缓存中已经存在相应接口的代理类，直接返回；否则，使用ProxyClassFactory创建代理类        return proxyClassCache.get(loader, interfaces);    }

proxyClassCache 的定义：

    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

其中缓存使用的是 WeakCache 实现的，此处主要关注使用 ProxyClassFactory 创建代理的情况。ProxyClassFactory 是 Proxy 类的静态内部类，实现了 BiFunction 接口，实现了 BiFunction 接口中的 apply 方法。

当 WeakCache 中没有缓存相应接口的代理类，则会调用 ProxyClassFactory 类的 apply 方法来创建代理类。

private static final class ProxyClassFactory            implements BiFunction<ClassLoader, Class<?>[], Class<?>>    {           //代理类前缀        private static final String proxyClassNamePrefix = "$Proxy";        //生成代理类名称的计数器        private static final AtomicLong nextUniqueNumber = new AtomicLong();        @Override        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {               Map<Class<?>, Boolean> interfaceSet =                     new IdentityHashMap<>(interfaces.length);            for (Class<?> intf : interfaces) {                   //校验类加载器是否能通过接口名称加载该类                Class<?> interfaceClass = null;                try {                       interfaceClass = Class.forName(intf.getName(), false, loader);                } catch (ClassNotFoundException e) {                   }                if (interfaceClass != intf) {                       throw new IllegalArgumentException(                            intf + " is not visible from class loader");                }                // 校验该类是否是接口类型                if (!interfaceClass.isInterface()) {                       throw new IllegalArgumentException(                            interfaceClass.getName() + " is not an interface");                }                //校验接口是否重复                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {                       throw new IllegalArgumentException(                            "repeated interface: " + interfaceClass.getName());                }            }            String proxyPkg = null;// 代理类包名            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;            //非public接口，代理类的包名与接口的包名相同            for (Class<?> intf : interfaces) {                   int flags = intf.getModifiers();                if (!Modifier.isPublic(flags)) {                       accessFlags = Modifier.FINAL;                    String name = intf.getName();                    int n = name.lastIndexOf('.');                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));                    if (proxyPkg == null) {                           proxyPkg = pkg;                    } else if (!pkg.equals(proxyPkg)) {                           throw new IllegalArgumentException(                                "non-public interfaces from different packages");                    }                }            }            if (proxyPkg == null) {                   // public代理接口，使用com.sun.proxy包名                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";            }            //为代理类生成名字            long num = nextUniqueNumber.getAndIncrement();            String proxyName = proxyPkg + proxyClassNamePrefix + num;            //真正生成代理类的字节码文件的地方            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(                    proxyName, interfaces, accessFlags);            try {                   //使用类加载器将代理类的字节码文件加载到JVM中                return defineClass0(loader, proxyName,                        proxyClassFile, 0, proxyClassFile.length);            } catch (ClassFormatError e) {                   throw new IllegalArgumentException(e.toString());            }        }    }public static byte[] generateProxyClass(final String var0,        Class<?>[] var1, int var2) {           ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);        final byte[] var4 = var3.generateClassFile();        // 是否要将生成代理类的字节码文件保存到磁盘中        if (saveGeneratedFiles) {               // ....        }        return var4;    }

在 ProxyClassFactory 类的 apply 方法中可看出真正生成代理类字节码的地方是 ProxyGenerator 类中的 generateProxyClass，该类未开源，但是可以使用IDEA、或者反编译工具 jd-gui 来查看。

我们用 jd-jui 工具将生成的字节码反编译 $Proxy0.class文件如下：

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException;import jiankunking.Subject; public final class $Proxy0 extends Proxy implements Subject{     private static Method m1;  private static Method m3;  private static Method m4;  private static Method m2;  private static Method m0;    public $Proxy0(InvocationHandler paramInvocationHandler)  {       super(paramInvocationHandler);  }    public final boolean equals(Object paramObject)  {       try    {         return ((Boolean)this.h.invoke(this, m1, new Object[] {             paramObject })).booleanValue();    }    catch (Error|RuntimeException localError)    {         throw localError;    }    catch (Throwable localThrowable)    {         throw new UndeclaredThrowableException(localThrowable);    }  }    public final String SayGoodBye()  {       try    {         return (String)this.h.invoke(this, m3, null);    }    catch (Error|RuntimeException localError)    {         throw localError;    }    catch (Throwable localThrowable)    {         throw new UndeclaredThrowableException(localThrowable);    }  }    public final String SayHello(String paramString)  {       try    {         return (String)this.h.invoke(this, m4, new Object[] {    paramString });    }    catch (Error|RuntimeException localError)    {         throw localError;    }    catch (Throwable localThrowable)    {         throw new UndeclaredThrowableException(localThrowable);    }  }    public final String toString()  {       try    {         return (String)this.h.invoke(this, m2, null);    }    catch (Error|RuntimeException localError)    {         throw localError;    }    catch (Throwable localThrowable)    {         throw new UndeclaredThrowableException(localThrowable);    }  }    public final int hashCode()  {       try    {         return ((Integer)this.h.invoke(this, m0, null)).intValue();    }    catch (Error|RuntimeException localError)    {         throw localError;    }    catch (Throwable localThrowable)    {         throw new UndeclaredThrowableException(localThrowable);    }  }    static  {       try    {         m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {              Class.forName("java.lang.Object")      });      m3 = Class.forName("jiankunking.Subject").getMethod("SayGoodBye", new Class[0]);      m4 = Class.forName("jiankunking.Subject").getMethod("SayHello", new Class[] {             Class.forName("java.lang.String")       });      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);      return;    }    catch (NoSuchMethodException localNoSuchMethodException)    {         throw new NoSuchMethodError(localNoSuchMethodException.getMessage());    }    catch (ClassNotFoundException localClassNotFoundException)    {         throw new NoClassDefFoundError(localClassNotFoundException.getMessage());    }  }}

这就是最终真正的代理类，它继承自 Proxy 并实现了我们定义的 Subject 接口，也就是说：

Subject subject = (Subject) Proxy.newProxyInstance(loader, interfaces, handler);

这里的 subject 实际是这个类的一个实例，那么我们调用它的：

public final String SayHello(String paramString)

就是调用我们定义的 InvocationHandlerImpl 的 invoke 方法。

到了这里我们应该知道调用 subject.SayHello(“jiankunking”) 这句代码时，为什么会自动调用 InvocationHandlerImpl 的 invoke 方法，因为 JDK 生成的最终真正的代理类，它继承自 Proxy 并实现了我们定义的 Subject 接口，在实现 Subject 接口方法的内部，通过反射调用了 InvocationHandlerImpl 的 invoke 方法。

通过分析代码可以看出 Java 动态代理，具体有如下四步骤：

• 通过实现 InvocationHandler 接口创建自己的调用处理器
• 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类
• 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型
• 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入

4.2 CGLib动态代理

上面的静态代理和动态代理模式都是要求目标对象是实现一个接口的目标对象，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候就可以使用以目标对象子类的方式实现代理，这种方法就叫做：CGLib (Code Generation Library) 代理，CGLib 是一个基于 ASM 的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理，在子类中采用方法拦截的技术拦截所有父类方法的调用并顺势织入横切逻辑。

CGLib 代理，也叫作子类代理，它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。

• JDK 的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口，如果想代理没有实现接口的类，就可以使用 CGLib
• CGLib 是一个强大的高性能的代码生成包，它可以在运行期扩展 java 类与实现 java 接口。它广泛的被许多 AOP 的框架使用，例如 Spring AOP 和 synaop，为他们提供方法的 interception (拦截)
• CGLib 包的底层是通过使用一个小而快的字节码处理框架 ASM 来转换字节码并生成新的类。不鼓励直接使用 ASM，因为它要求你必须对 JVM 内部结构包括 class 文件的格式和指令集都很熟悉

Cglib 子类代理实现方法：

1.需要引入 CGLib 的 jar 文件，但是 Spring 的核心包中已经包括了 Cglib 功能，所以直接引入 pring-core-3.2.5.jar 即可
2.引入功能包后，就可以在内存中动态构建子类
3.代理的类不能为 final，否则报错
4.目标对象的方法如果为 final/static，那么就不会被拦截，即不会执行目标对象额外的业务方法

4.3 JDK与CGLib区别

• 相同的原理：
  JDK 代理和 CGLIB 代理的原理相似，都是通过编写代理的 class 文件，并将拦截的方法写入到代理的 class 中，在原有方法调用前，存在拦截器，则先调用拦截器的方法
• JDK 原生动态代理是 Java 原生支持的，不需要任何外部依赖，但是它只能基于接口进行代理；CGLIB 通过继承的方式进行代理，无论目标对象有没有实现接口都可以代理，但是无法处理 final 的情况。