“阁下有什么问题可以和我的代理律师谈即可”，为什么会有律师这个职业呢？随着法律法规的逐步完善，日益复杂，导致大部分的普通民众掌握的法律知识明显不足，进而无法在合适的时间点进行维权、规避风险。可见，律师的作用就是利用自身的专业知识帮助案件当事人处理其无法处理的事情。不仅只有律师，生活中处处可见这种代理模式的存在，比如婚庆公司、各种中介(房产、婚姻)等等。这些职业、公司等都是起到了帮助当事人处理一些比较专业的事情，而当事人只需要在合适的时间点做出其应该做的动作即可。因此，读者在需要委托代理他人做事情时，一定要问清楚，需要代理做什么？自身要做什么？哈哈，话题扯远了。那么在代码世界中有没有类似的代理需求呢？答案是肯定是有的。比如说打印日志、事务、流量统计、限流、鉴权等。这些事情均不应该由目标对象（如接口、服务）负责，但是在一些场景下，又和目标对象行为密切相关，那这时我们就需要引入代理对象来负责完成目标对象所不能完成的事情。实现这种代理行为的代码组织解决方案就是代理模式。在JAVA语言中，代理模式根据编译期是否已声明代理类信息可分为两种：静态代理或动态代理。
一、静态代理
为保证概念清晰，这里提前将下文一些指代名词解释如下：
- 被代理的类称之为被代理类；其实例化的对象称之为被代理对象。
- 用于实现代理被代理类的类称之为代理类；其实例化的对象称之为代理对象。
静态代理是指在编译期就已经定义了代理类信息。代理类信息应该包括哪些呢？
① 既然能够代理，就意味着代理类拥有被代理类所有的可执行方法（或行为）
② 为达到代理的目的，代理类执行被代理可执行方法时，会在合适时机（之前或之后）执行其特有的代理行为。
我们能够很自然地想到，在面向对象语言中，代理类使用组合或继承（被代理类）的方式能够十分容易满足这两点。
1.1 静态代理-组合
我们先来看通过“组合”的方式如何实现静态代理。组合模式一般是指整体和部分之间的关系，用于表示1(整体)-N(部分)的关系。具体应用到代理模式上，1即为代理类(对象)，而N=1即为被代理类(对象)。那么，组合的方式如何满足前面提到的代理类信息的两点要求：
① 代理类拥有被代理类所有的可执行方法
使用组合的方式，我们必须手动给代理类添加所有被代理类的可执行方法。但是，这种没有设计层面的约束，很容易出现问题。如被代理类新增方法时，代理类很容易忽略而没有新增该方法，破坏了代理模式。
因此，使用组合的方式一般强制要求代理类实现接口，接口用于表示需要被代理的方法。被代理类也需要实现该接口即可满足要求。【ps：JDK动态代理要求被代理类必须实现接口】
② 代理类执行被代理可执行方法时，会在合适时机（之前或之后）执行其特有的代理行为
为了实现代理功能，代理类在执行任何代理方法时，必须显示调用(执行)被代理类(对象)的对应被代理方法。
根据以上分析，我们下面给出简单的使用组合方式实现静态代理模式的代码&类图：
代理接口：
public interface ProxyInterface {
void proxyMethod1();
void proxyMethod2();
void proxyMethodX();
}
被代理类：
public class CustomClass implements ProxyInterface{
@Override
public void proxyMethod1() {
System.out.println("执行被代理方法，methodName=proxyMethod1");
}
@Override
public void proxyMethod2() {
System.out.println("执行被代理方法，methodName=proxyMethod2");
}
@Override
public void proxyMethodX() {
System.out.println("执行被代理方法，methodName=proxyMethodX");
}
}
代理类：
public class Proxy implements ProxyInterface{
private final ProxyInterface obj;
public Proxy(ProxyInterface obj) {
// 通过构造函数约束，创建代理对象传入被代理对象
this.obj = obj;
}
@Override
public void proxyMethod1() {
System.out.println("代理前置逻辑...");
obj.proxyMethod1(); // 调用被代理对象的代理方法
System.out.println("代理后置逻辑...");
}
@Override
public void proxyMethod2() {
System.out.println("代理前置逻辑...");
obj.proxyMethod1();
System.out.println("代理后置逻辑...");
}
@Override
public void proxyMethodX() {
System.out.println("代理前置逻辑...");
obj.proxyMethod1();
System.out.println("代理后置逻辑...");
}
}
使用组合方式实现静态代理模式的优点：
- 可以通过接口来指明需要代理的方法。
- 从对象代理角度上来看，组合方式更加符合代理定义，因为被代理的是存在的对象。
缺点：
- 如果需要被代理类很多，需要定义很多代理接口及代理类，引起类数量的剧增。
1.1 静态代理-继承
在面向对象语言中可以通过继承目标类，进而重写目标方法来实现代理（实际上，这种代理更准确的说是增强）。继承的方式要求代理类重写代理方法并通过调用父类方法来执行实际逻辑，而在调用父类方法之前或之后会执行代理行为。
① 代理类拥有被代理类所有可执行方法
继承机制保证了这一点，代理类一定会存在被代理类所有可执行方法。默认情况下代理类行为与被代理类行为含义一致。
② 代理类执行被代理可执行方法时，会在合适时机（之前或之后）执行其特有的代理行为
为了实现代理功能，代理类(子类)需在执行代理方法时执行被代理类(父类)的被代理方法。
根据以上分析，我们下面给出简单的使用继承方式实现静态代理模式的代码&类图：
被代理类：
public class CustomClass{
public void proxyMethod1() {
System.out.println("执行被代理方法，methodName=proxyMethod1");
}
public void proxyMethod2() {
System.out.println("执行被代理方法，methodName=proxyMethod2");
}
public void proxyMethodX() {
System.out.println("执行被代理方法，methodName=proxyMethodX");
}
}
代理类：
public class Proxy extends CustomClass{
@Override
public void proxyMethod1() {
System.out.println("代理前置逻辑...");
super.proxyMethod1();
System.out.println("代理后置逻辑...");
}
@Override
public void proxyMethod2() {
System.out.println("代理前置逻辑...");
super.proxyMethod2();
System.out.println("代理后置逻辑...");
}
@Override
public void proxyMethodX() {
System.out.println("代理前置逻辑...");
super.proxyMethodX();
System.out.println("代理后置逻辑...");
}
}
使用继承方式实现静态代理模式的优点：
- 不要求被代理类必须实现所有接口，通过继承机制，存在默认代理逻辑。
- 继承方式更像是类增强，不需存在被代理对象。
缺点：
- 如果需要被代理类很多，需要定义很多代理类，引起类数量的剧增。
二、动态代理
从前面可知，静态代理的最大的缺点就是当需要被代理类很多时，就需要定义许多代理类，逐渐引起类数量的剧增。那有没有可能存在一种方式能够自动生成代理类并实现代理功能呢？答案就是动态代理。
在JAVA中，动态代理是一种机制，通过动态代理机制实现在运行时根据需要动态生成代理类，从而达到在不修改源代码的情况下，为指定类提供额外的代理功能。这种动态代理机制主要有两种：JDK动态代理、CGLIB生成代理。
2.1 JDK动态代理
我们先来回顾下JDK动态代理的基本使用：
// 实例化自定义调用处理器实例
InvocationHandler handler = new MyInvocationHandler(...);
// 获取代理对象方式一
Class<?> proxyClass = Proxy.getProxyClass(ProxyInterface.class.getClassLoader(), ProxyInterface.class);
ProxyInterface proxyV1 = (ProxyInterface) proxyClass.getConstructor(InvocationHandler.class).
newInstance(handler);
// 获取代理对象方式二
ProxyInterface proxyV2 = (ProxyInterface) Proxy.newProxyInstance(ProxyInterface.class.getClassLoader(),
new Class<?>[] { ProxyInterface.class },
handler);
如上所示，JDK动态代理主要通过java.lang.reflect包中的Proxy类和InvocationHandler接口实现。具体的来说，代理类信息(即Class对象)可通过Proxy类的静态方法getProxyClass创建并获取。代理对象既可以通过代理类的构造方法创建也可以通过Proxy类的静态方法newProxyInstance直接获取。
代理类信息的创建需要传入代理接口类加载器及代理接口，其中，不同类加载器生成的代理类均唯一，代理接口指定了代理类需要代理的方法。代理对象的创建需要传入InvocationHandler对象，InvocationHandler接口仅有一个invoke方法，该方法内部就是代理执行的动作。
为了弄清楚JDK动态代理具体实现逻辑，通过设置“sun.misc.ProxyGenerator.saveGeneratedFiles”属性为True生成代理类文件。
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
生成的代理类信息如下：
public final class $Proxy0 extends Proxy implements Person {
private static Method m1;
private static Method m2;
private static Method m3;
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 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 void ageNum() throws {
try {
super.h.invoke(this, m3, (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"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.design.代理模式.jdkDynamic.Person").getMethod("ageNum");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
通过代理类信息，我们可以看到代理类会实现Object类的equals、toString、hashCode以及代理接口所有方法。代理对象执行代理方法内部实际上会调用InvocationHandler对象的invoke方法来执行实际逻辑。因此，具体代理对象的方法执行逻辑都有invoke方法来控制，invoke方法有三个参数：① 当前代理对象 ② 当前执行方法Method对象 ③ 方法参数列表。
为了实现代理，InvocationHandler对象的invoke方法中我们会调用被代理对象的Method方法。注意，这里不能调用代理对象的Method方法，否则会出现循环调用。因此，我们在创建InvocationHandler对象时，会通过构造方法或Setter方法传入代理对象。
实际上，从代理模式含义上来说，代理对象直接代理的是InvocationHandler对象，而InvocationHandler对象又直接代理被代理对象，并且两部代理均为组合方法的代理。
如上图所示，JDK动态代理实际上是通过两层组合方式的代理最终实现代理对象(DynamicProxy)与被代理对象(CustomClass)之间的代理关系。
JDK动态代理的优点：
- 通过动态生成代理类，减少了代理代码的重复性，提高代码可读性
- 使得代理部分代码和业务代码解耦，增加代码可维护性
- JDK动态代理具有很好的可扩展性
JDK动态代理的缺点：
- 所有方法的被代理均有一个InvocationHandler对象实现，无法针对不同方法实现不同代理逻辑。
- JDK动态代理，如同组合方式的代理一样，被代理类要求必须继承接口。【实际创建代理类时也必须传入接口Class】
有关于JDK动态代理实现的底层原理，如动态代理类的类信息定义过程、类缓存机制可参考JDK动态代理原理。
2.2 CGLIB生成代理
CGLIB(Code Generation Library)实际上是第三方提供强大、高性能的代码生成库。在该库中提供了可用于类增强的工具类-Enhancer类。我们通常就会使用Enhancer类来实现动态代理的功能，相比于JDK动态代理，基于Enhancer类实现的动态代理的对象不局限于接口类。下面我们先回顾下CGLIB动态代理的基本使用：
// 自定义方法拦截器
MethodInterceptor myMethodInterceptor = new MyMethodInterceptor();
// 使用Enhancer创建代理类
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Student.class);
enhancer.setCallback(myMethodInterceptor);
Student stu = (Student) enhancer.create();
stu.outStudentName();
如上所示，CGLIB动态生成代理主要是通过第三方包(net.sf.cglib)中的Enhancer类和MethodInterceptor 接口实现。使用Enhancer生成代理对象之前，需要将被代理类Class、执行方法回调的方法拦截器传入Enhancer对象中。我们可以看到，被代理类Class信息实际上是作为父类信息，反映到内部也就是代理类的父类。方法拦截器实际上就是回调方法，即代理类执行方法时会通过MethodInterceptor回调对象的intercept方法进行调用方法逻辑。
Ehancer对象提供了很多类似的setXXX方法，用于对动态生成的代理类实现不同功能。这里值得一提的是，方法拦截器(MethodInterceptor)对象可以设置多个，用于针对不同的方法执行不同的拦截逻辑。对于多个方法拦截器，你还需要指定一个CallbackFilter对象，该对象用于自定义哪些方法使用哪个方法拦截器。
与JDK动态代理类似，你也可以通过设置系统属性来获取动态生成的代理类信息。
// 代理类class文件存入本地磁盘方便我们反编译查看源码
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "E:\\project\\java\\mavenTest");
CGLIB动态代理类比较长，这里就不做赘述了，关于CGLIB代理类信息详细可参考CGLIB原理简析-前篇。下图给出了代理类执行代理方法的逻辑：
逻辑也十分简单，和之前说的一样，就是通过调用回调对象-也是方法拦截器对象的intecept方法执行实际方法逻辑。因此，具体代理对象的方法执行逻辑都由intecept方法来控制，intecept方法有四个参数：① 代理对象 ② 当前拦截的方法 ③ 方法参数值列表 ④ 代理类的方法代理MethodProxy。
为了实现代理，intecept方法中我们一般都会调用MethodProxy的invokeSuper方法，并将代理对象以及方法参数传入来执行代理对象实际业务逻辑。注意这里不能调用MethodProxy的invoke方法，这个方法时调用代理对象的代理方法，会出现循环调用。从invokeSuper的方法名也可以看出来，这实际上是调用父类的方法。因此，从代理模式含义上来说，动态生成的代理类实际上是通过继承的方式来实现的代理。
如上图所示，CGLIB动态代理实际上是通过继承的方式实现了代理模式。
CGLIB动态代理的优点：
- 通过动态生成代理类，减少了代理代码的重复性，提高代码可读性
- 使得代理部分代码和业务代码解耦，增加代码可维护性
- JDK动态代理具有很好的可扩展性
- 可以对几乎任何类实现代理，不局限于接口
CGLIB动态代理的缺点：
- 需要引入第三方依赖包
- 由于是使用继承方式来实现的代理类，因此无法代理final的类和方法
- 使用字节码操作的方式创建代理类，可能第一次创建的过程可能会很慢，性能较差。
有关于CGLIB动态代理实现的底层原理，如动态代理类的类信息定义过程、类缓存机制可参考CGLIB原理简析-前篇、CGLIB原理简析-后篇。
三、总结
通过本文可以了解到，面向对象语言中代理模式的实现从实现方式可分为两种方式：组合和继承。从是否编译器确定代理类角度上看分为静态代理和动态代理。而其中动态代理的实现机制不同可分为JDK动态代理和CGLIB动态代理。在实际使用场景中，我们必须清楚的知道在什么场景下应该选用什么样的代理模式。
3.1 静态代理vs动态代理
什么时候考虑使用静态代理？
静态代理适用于特殊场景，比如仅针对某一个特殊业务功能类来实现代理，建议使用静态代理。比如业务系统存在某本地缓存类，后续技术优化打算加上监控，为了增加每分钟上报本地缓存监控的能力，就可以使用静态代理，而不适合使用动态代理。
实际上，在面向对象语言中，使用组合和继承时，本身就有代理的含义在其中，这也是为什么cglib中Enhancer类能作为一种代理模式机制的原因。从这个角度看，静态代理的实际应用场景实际上要比动态代理更广，更直接。
什么时候考虑使用动态代理：
动态代理适用于普遍场景，即当系统中存在大面积的代理功能需要，如果使用静态代理就会导致类激增问题，并且如一些第三方工具包无法预先知道被代理类Class信息，这时就需要使用动态代理。因此，动态代理在第三方包中更加常见，第三方包需要使用动态代理在其未知业务类信息上进行代理或增强，添加其支持的额外功能。
3.2 组合vs继承
既然要使用代理，那选择组合的方式实现代理，还是选择继承的方式实现代理呢？这个问题同样也能回答JDK动态代理和CGLIB动态代理的选择。
- 首先使用继承的方式，由于JAVA语言继承机制的限制，本身就无法对使用final修饰的类进行代理。
- 使用继承的方式就无需创建被代理类的对象
- 在具体机制上，JDK动态代理仅能对接口进行代理
- 在具体机制上，CGLIB动态代理性能可能更差些。
还有个说法是，JDK动态代理使用反射机制，CGLIB代理使用字节码处理ASM。因此JDK动态代理的创建代理类效率高，但是执行代理方法效率低。CGLIB代理创建效率较低，执行效率因为FastClass机制效率高。但是近些年JDK动态代理的执行效率也不弱，因此很多时候应首选JDK动态代理。
