什么是代理模式？

代理模式是一种常见的设计模式，它为其他对象提供了一种代理，以控制对这个对象的访问。

我们可以将代理模式看作是一个中介，它允许客户端通过代理对象与目标对象进行交互，而不是直接与目标对象交互。

代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。

代理模式有静态代理和动态代理两种实现方式，我们先来看一下静态代理模式的实现。

Tips: 在看接下来的文章时，前面的概念也许会让你看得云里雾里，摸不着头脑，强烈建议：先简单看一下即可，然后自己根据提供的代码去实现一遍，注意是自己敲一遍哈，直接复制的话效果可能会大打折扣，而梳理一遍后反过来再去理解，甚至像我一样写一篇博客，理解那就会大大滴深刻！！

静态代理

静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常不灵活比如接口一旦新增加方法，目标对象和代理对象都要进行修改，需要对每个目标类都单独写一个代理类。

从 JVM 层面来说， 静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。

静态代理实现步骤:

1. 定义一个接口及其实现类；
2. 创建一个代理类同样实现这个接口
3. 将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。

这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

理论会很枯燥 通过代码展示更加形象：

1. 定义发送短信的接口

public interface SmsService {
    String send(String message);
}

2. 实现发送短信的接口

public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

3. 创建代理类并同样实现发送短信的接口

public class SmsProxy implements SmsService {

    private final SmsService smsService;

    public SmsProxy(SmsService smsService) {
        this.smsService = smsService;
    }

    @Override
    public String send(String message) {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method send()");
        smsService.send(message);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method send()");
        return null;
    }
}

注意这里的 final 关键字，这里它的作用是确保 smsService 成员变量一旦被初始化后其值就不能被改变。因为代理类的目的是控制对真实对象的访问，如果允许 smsService 被更改，那么代理类就无法保证对真实对象的访问总是通过代理来控制，这可能会破坏代理模式的设计。

4. 测试类

public class Main {
    public static void main(String[] args) {
        SmsService smsService = new SmsServiceImpl();
        SmsProxy smsProxy = new SmsProxy(smsService);
        smsProxy.send("java");
    }
}

控制台输出：

可以看到，我们通过 代理类 SmsProxy 重写目标对象接口 SmsService 的 send() 方法的方式，扩展了目标对象的接口的功能(before 和 after)实现了静态代理

静态代理模式在不改变目标对象的前提下，实现了对目标对象的功能扩展。

静态代理的问题

静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，且需要对每个目标类都单独写一个代理类

比如我们对 SmsService 新增一个方法

public interface SmsService {
    String send(String message);
    String recive();
}

此时，我们就不得不在目标对象和代理对象中都进行 recive 方法的重写

动态代理

相比于静态代理，动态代理展现出更高的灵活性。我们无需为每个目标类分别创建代理类，也无需强制实现接口，可以直接对实现类进行代理（例如使用CGLIB动态代理机制）。

从Java虚拟机（JVM）的角度来看，动态代理是在运行时动态生成类字节码，并将其加载到JVM中。

提及动态代理，Spring AOP和RPC（远程过程调用）框架是两个典型的应用案例，它们的实现都依赖于动态代理技术。

虽然在日常开发中，我们可能不会频繁直接使用动态代理，但在各种框架中，它几乎成为了一项不可或缺的技术。

掌握动态代理对于理解和学习各类框架的内部原理具有重要意义。在Java生态中，动态代理的实现方式多种多样，包括JDK动态代理和CGLIB动态代理等。

JDK动态代理

在 Java 动态代理机制中 InvocationHandler 接口和 Proxy 类是核心。Proxy 类中使用频率最高的方法是：newProxyInstance() ，这个方法主要用来生成一个代理对象。

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
        throws IllegalArgumentException
    {
        ......
    }

这个方法一共有 3 个参数：

1. loader :类加载器，用于加载代理对象。
2. interfaces : 被代理类实现的一些接口；
3. h : 实现了 InvocationHandler 接口的对象；’

要实现动态代理的话，还必须需要实现 InvocationHandler 来自定义处理逻辑。 当我们的动态代理对象调用一个方法时，这个方法的调用就会被转发到实现 InvocationHandler 接口类的 invoke 方法来调用。

public interface InvocationHandler {

    /**
     * 当你使用代理对象调用方法的时候实际会调用到这个方法
     */
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

invoke() 方法有下面三个参数：

• proxy: 动态生成的代理类
• method: 与代理类对象调用的方法相对应
• args: 当前 method 方法的参数

也就是说：你通过 Proxy 类的 newProxyInstance() 创建的代理对象在调用方法的时候，实际会调用到实现 InvocationHandler 接口的类的 invoke() 方法。你可以在 invoke() 方法中自定义处理逻辑，比如在方法执行前后做什么事情。

JDK 代理的使用步骤：

1. 定义一个接口及其实现类；
2. 自定义 InvocationHandler 并重写 invoke 方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；
3. 通过 Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 方法创建代理对象。

代码示例：

1. 定义发送短信的接口

public interface SmsService {
    String send(String message);
}

2. 实现发送短信的接口

public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}

3. 定义一个 JDK 动态代理类

package Proxy.Trends_state;

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

/**
 * @Author:wjy
 */
public class DebugInvocationHandler implements InvocationHandler {
    private final Object target;

    public DebugInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
        // 调用方法前，添加自己的操作
        System.out.println("before method "+ method.getName());
        Object result = method.invoke(target,args);
        // 调用方法后，添加自己的操作
        System.out.println("after method "+ method.getName());
        return result;
    }
}

invoke() 方法: 当我们的动态代理对象调用原生方法的时候，最终实际上调用到的是 invoke() 方法，然后 invoke() 方法代替我们去调用了被代理对象的原生方法。

4. 获取代理对象的工厂类

public class JdkProxyFactory {
    public static Object getProxy(Object target) {
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 目标类的类加载器
                target.getClass().getInterfaces(),  // 代理需要实现的接口，可指定多个
                new DebugInvocationHandler(target)   // 代理对象对应的自定义 InvocationHandler
        );
    }
}

getProxy()：主要通过 Proxy.newProxyInstance() 方法获取某个类的代理对象。

5. 测试类

SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());
smsService.send("java");

结果：

代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用动态代理。

动态代理的方式中，所有的函数调用最终都会经过 invoke 函数的转发，因此我们就可以在这里做一些自己想做的操作，比如日志系统、事务、拦截器、权限控制等。

JDK 动态代理的问题

JDK 动态代理有一个最致命的问题是它只能代理实现了某个接口的实现类，并且代理类也只能代理接口中实现的方法，要是实现类中有自己私有的方法，而接口中没有的话，该方法不能进行代理调用。

怎么解决这个问题呢？我们可以用 CGLIB 动态代理机制。

CGLIB 动态代理

静态代理和JDK代理都需要某个对象实现一个接口，有时候代理对象只是一个单独对象，此时可以使用Cglib代理。

CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。

很多知名的开源框架都使用到了CGLIB， 例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。

CGLIB 代理可以称为子类代理，是在内存中构建一个子类对象，从而实现对目标对象功能的扩展。

在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类是核心。

你需要自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法。

public interface MethodInterceptor
extends Callback{
    // 拦截被代理类中的方法
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,MethodProxy proxy) throws Throwable;
}

1. obj: 被代理的对象（需要增强的对象）
2. method: 被拦截的方法（需要增强的方法）
3. args: 方法入参
4. proxy: 用于调用原始方法

你可以通过 Enhancer 类来动态获取被代理类，当代理类调用方法的时候，实际调用的是 MethodInterceptor 中的 intercept 方法。

CGLIB 动态代理类使用步骤：

1. 定义一个类；
2. 自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；
3. 通过 Enhancer 类的 create() 创建代理类；

不同于 JDK 动态代理不需要额外的依赖。CGLIB实际是属于一个开源项目，如果你要使用它的话，需要手动添加相关依赖。

<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.3.0</version>
</dependency>

1. 实现一个使用阿里云发送短信的类

package Proxy.cglib;

/**
 * @Author:wjy
 */
public class AliSmsService {
    public String send(String message){
        System.out.println("send message: "+ message);
        return message;
    }
}

2. 自定义 MethodInterceptor（方法拦截器）

package Proxy.cglib;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @Author:wjy
 */
public class DebugMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        // 调用方法前，添加自己的操作
        System.out.println("before method "+ method.getName());
        Object object = methodProxy.invokeSuper(o,args);
        // 调用方法后，添加自己的操作
        System.out.println("after method "+ method.getName());
        return object;
    }
}

3. 获取代理类

package Proxy.cglib;

import net.sf.cglib.proxy.Enhancer;

/**
 * @Author:wjy
 */
public class CglibProxyFactory {
    public static Object getProxy(Class<?> clazz){
        // 创建动态代理增强类
        Enhancer enhancer = new Enhancer();
        // 设置类加载器
        enhancer.setClassLoader(clazz.getClassLoader());
        // 设置被代理类
        enhancer.setSuperclass(clazz);
        // 设置方法拦截器
        enhancer.setCallback(new DebugMethodInterceptor());
        // 创建代理类
        return enhancer.create();
    }
}

4. 测试类

package Proxy.cglib;

/**
 * @Author:wjy
 */
public class Main {
    public static void main(String[] args) {
        AliSmsService aliSmsService = (AliSmsService) CglibProxyFactory.getProxy(AliSmsService.class);
        aliSmsService.send("java");
    }
}

结果：

Spring中 AOP 使用代理

Spring中 AOP 的实现有 JDK 和CGLIB 两种，如下图：

如果目标对象需要实现接口，则使用 JDK 代理。

如果目标对象不需要实现接口，则使用 CGLIB 代理。

JDK 动态代理和 CGLIB 动态代理对比

JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。

另外，CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。

就二者的效率来说，CGLIB 是基于字节码的，而 JDK 动态代理则是通过反射，所以性能上 CGLIB 更好

静态代理和动态代理的对比

灵活性：动态代理更加灵活，不需要必须实现接口，可以直接代理实现类，并且可以不需要针对每个目标类都创建一个代理类。另外，静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，这是非常麻烦的！

JVM 层面：静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。而动态代理是在运行时动态生成类字节码，并加载到 JVM 中的。

总结

静态代理：需要代理类和目标类都实现接口的方法，从而达到代理增强其功能。

JDK 动态代理：需要代理类实现某个接口，使用 Proxy.newProxyInstance 方法生成代理类，并实现 InvocationHandler 中的 invoke 方法，实现增强功能。

CGLIB 动态代理：无需代理类实现接口，使用 CGLIB 中的 Enhancer 来生成代理对象子类，并实现 MethodInterceptor 中的 intercept 方法，在此方法中可以实现增强功能。

参考文章：
Java 代理模式详解

单例模式超详解：
一文带你彻底搞懂设计模式之单例模式！！由浅入深，图文并茂，超超超详细的单例模式讲解！！