静态代理 VS 动态代理

God约 2570 字大约 9 分钟

1. 代理模式

代理模式是一种比较好理解的设计模式！

简单来说就是，我们使用代理对象来代替对原有对象的访问，这样就可以在不修改原对象的前提下，提供额外的功能操作，扩展原有对象的功能。

代理模式有静态代理和动态代理两种实现方式！

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

举个例子：你找了小红来帮你问话，小红就可以看作是你的代理对象，代理的行为是问话：

2. 静态代理

静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常不灵活（比如接口一旦新增加方法，目标对象和代理对象都要进行修改），且麻烦(需要对每个目标类都单独写一个代理类)。实际应用场景非常非常少，日常开发几乎看不到使用静态代理的场景。

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

2.1 静态代理实现步骤

定义一个接口及其实现类
创建一个代理类同样实现这个接口
将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法，这样，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情

2.2 演示代码

定义发送短信的接口：

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

实现发送短信的接口：

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

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

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;
    }
}

实际使用：

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

控制台打印出：

before method send()
send message:java
after method send()

从输出结果可以看出，我们已经增强了 SmsServiceImpl 的send()方法！

3. 动态代理

相比于静态代理来说，动态代理更加灵活，我们不需要针对每个目标类都单独创建一个代理类，也不需要我们必须实现接口，我们可以直接代理实现类( CGLIB 动态代理机制)。

从 JVM 角度来说，动态代理是在运行时动态生成类字节码，并加载到 JVM 中的！

说到动态代理，Spring AOP、RPC 框架应该是两个不得不提的，它们的实现都依赖了动态代理！

动态代理在我们日常开发中使用的相对较少，但是在框架中的几乎是必用的一门技术。学会了动态代理，对于我们理解和学习各种框架的原理非常有帮助！

就 Java 来说，动态代理的实现方式有很多种，比如 JDK 动态代理、CGLIB 动态代理。

3.1. JDK 动态代理机制

3.1.1 介绍

在 Java 动态代理机制中 InvocationHandler 接口和 Proxy 类是核心。

Proxy 类中使用频率最高的方法是：newProxyInstance() ，这个方法主要用来生成一个代理对象。

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

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

loader：类加载器，用于加载代理对象

interfaces ：被代理类实现的一些接口

h : 实现了 InvocationHandler 接口的对象

要实现动态代理，还必须实现InvocationHandler 接口来自定义代理逻辑。当我们调用代理对象的某个方法时，对这个方法的调用实际会被转发到InvocationHandler 接口的实现类中的 invoke 方法中，在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() 方法中自定义处理逻辑，比如在方法执行前后做什么事情，以此达到增强被代理对象的功能！

3.1.2. JDK 动态代理类使用步骤

定义一个接口及其实现类
实现 InvocationHandler 接口并实现invoke方法，在 invoke 方法中调用被代理类的方法，并自定义一些增强逻辑
通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象

3.1.3. 演示代码

定义发送短信的接口：

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

实现发送短信的接口：

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

定义一个 JDK 动态代理类：

public class DebugInvocationHandler implements InvocationHandler {
    /**
     * 代理类中的真实对象
     */
    private final Object target;

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

    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;
    }
}

代理对象的获取工厂：

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

实际使用：

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

控制台打印出：

before method send
send message:java
after method send

3.2. CGLIB 动态代理机制

3.2.1. 介绍

为了解决这个问题，我们可以用 CGLIB 动态代理！

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

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

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

使用CGLIB代理，需要实现 MethodInterceptor 接口并实现 intercept 方法，intercept 用于拦截并增强被代理类的方法：

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

obj：被代理的对象（需要增强的对象）

method：被拦截的方法（需要增强的方法）

args：方法入参

proxy：用于触发原始方法调用

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

3.2.2. CGLIB 动态代理类使用步骤

定义一个类
实现 MethodInterceptor 接口并实现 intercept 方法，intercept 用于拦截并增强被代理类的方法
通过 Enhancer 类的 create()创建代理类

3.2.3. 代码示例

CGLIB(Code Generation Library) 实际是属于一个开源项目，使用它需要手动添加相关依赖：

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

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

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

自定义 MethodInterceptor(方法拦截器)：

public class DebugMethodInterceptor implements MethodInterceptor {
    /**
     * @param o           代理对象（增强的对象）
     * @param method      被拦截的方法（需要增强的方法）
     * @param args        方法入参
     * @param methodProxy 触发原始方法调用
     */
    @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;
    }

}

代理对象的获取工厂：

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();
    }
}

实际使用：

AliSmsService aliSmsService = (AliSmsService) CglibProxyFactory.getProxy(AliSmsService.class);
aliSmsService.send("java");

控制台打印出：

before method send
send message:java
after method send

3.3. JDK 动态代理 CGLIB 动态代理

JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类！
CGLIB 动态代理是通过生成一个被代理类的子类来实现代理功能，因此不能代理声明 final 类型的类和方法（final类无法被继承，final方法无法被重写）！
就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显！

4. 静态代理动态代理

灵活性 ：静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，非常麻烦！动态代理更加灵活，不需要针对每个目标类都创建一个代理类！
JVM 层面 ：静态代理在编译时就将接口、实现类、代理类都变成了一个个实际的 class 文件，而动态代理是在运行时动态生成类字节码并加载到 JVM 中呀！