学习纪录篇—代理模式与Java动态代理

设计模式系列文章

对于代理模式，相信很多初学者可能跟我一样，无论是在手动编码还是学习的过程中，好像感觉并没有碰到过，也没有写过类似的代码，但其实，代理模式是大部分框架都在使用的一种设计模式。例如Spring中的AOP就是基于动态代理实现的，类似的还有Mybatis中生成代理对象来拦截Mapper接口中的方法然后在对应的XML文件中去执行对应的MapperStatement。

代理模式简单的说就是用代理对象代替真实对象去完成某些操作，这样就可以在不修改原目标对象的前提下，拓展目标对象的功能。

目录

设计模式系列文章

前言

一、静态代理

代码实现

二、动态代理

JDK动态代理机制

使用步骤

代码示例

CGLIB动态代理机制

代码实例

总结

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

静态代理和动态代理对比

概况

---

前言

了解完代理模式的目的后，我们开始正式学习代理模式的实现方式。代理模式有两种实现方式，分别是静态代理和动态代理。

本文参考GitHub作者 Java Guide 以下为作者本人链接 更加详细美观，推荐大家阅读

代理详解！静态代理+JDK/CGLIB 动态代理实战 | JavaGuide

---

一、静态代理

在静态代理模式下，我们对目标对象每个方法的增强都是通过手动编码来完成的，需要对每一个代理对象手动写一个单独的代理类，接口一旦增添了新的方法，代理对象和目标对象都要进行手动修改增加方法。由于步骤和繁琐的操作太多，现实开发中，很少用到静态代理的模式。

从JVM类加载的层面来说，静态代理就是在编译的时候，就把接口，接口的实现类，实现类的代理类全部都加载，变成一个个class文件。

静态代理的步骤

1.定义一个接口及实现类

2.创建一个代理类，同样实现这个接口

3.将目标对象注入代理类，然后在代理类中的方法调用目标对象的方法，这样就可以通过代理类屏蔽目标对象的访问，还可以在目标方法执行前后做我们自己的操作。

代码实现

首先定义发送短信的接口

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

然后实现发送短信接口的实现类

public class SmsServiceImpl implements SmsService{
    @Override
    public String send(String message){
        System.out.println("发送短信中:"+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()

发送短信中:java

after method send()

 

二、动态代理

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

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

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

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

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

在我的另一系列 ”手动实现一个RPC框架“ 文章中，就是使用的JDK动态代理来实现远程调用的，

可以阅读手动实现RPC框架_种一棵橙子树的博客-CSDN博客​​​​​​

本专栏的内容具体实现，来自于GitHub作者Java Guide，大家要可以直接去阅读Guide哥的文章

Snailclimb/guide-rpc-framework: A custom RPC framework implemented by Netty+Kyro+Zookeeper.（一款基于 Netty+Kyro+Zookeeper 实现的自定义 RPC 框架-附详细实现过程和相关教程。） (github.com)

JDK动态代理机制

在JDK的动态代理机制中的核心是 InvocationHandler接口和 Porxy 类，而Proxy类中使用最多的方法就是 newProxyInstance()方法，这个方法就是用来生成代理对象的。

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

 方法中的三个参数

loader：类加载器，加载代理对象。

interfaces：代理类实现的接口

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()方法创建的代理对象，在调用方法的时候，实际上调用了 invoke()方法，然后我们在invoke()方法中可以自定义处理逻辑。

使用步骤

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

代码示例

短信发送接口

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动态代理类

 

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

/**
 * @author shuang.kou
 * @createTime 2020年05月11日 11:23:00
 */
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;
    }
}

这里重点就是invoke()方法，我们代理的对象在调用原对象的方法的时候，实际上用的是invoke()方法，invoke()方法里面会执行我们自定义的操作，也会执行原对象的方法。 

获取代理对象的工厂类

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方法生成代理对象并且获取。 

实际使用

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

输出结果

before method send

send message:java

after method send

CGLIB动态代理机制

 从上述的代码和介绍中我们发现，JDK动态代理有个问题，那就是，它只能代理实现了接口的类

如果我们想实现没有接口的代理类，我们可以使用CGLIB动态代理的方式。

CGLIBopen in new window(Code Generation Library)是一个基于ASMopen in new window的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB 通过继承方式实现代理。很多知名的开源框架都使用到了CGLIBopen in new window， 例如 Spring 中的 AOP 模块中：如果目标对象实现了接口，则默认采用 JDK 动态代理，否则采用 CGLIB 动态代理。

CGLIB动态代理的核心是 MethodIntercepteor 接口和 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;
}

参数解释

obj：被代理的对象

method：拦截的方法

args：被拦截的方法的参数

proxy：用于调用被代理类的原始方法

我们可以通过 Enhancer类来生产被代理类的代理对象，当代理对象调用方法的时候，实际调用的是MethodInterceptor接口中的intercept方法。

使用步骤

定义一个类；

自定义 MethodInterceptor 并重写 intercept 方法，intercept 用于拦截增强被代理类的方法，和 JDK 动态代理中的 invoke 方法类似；

通过 Enhancer 类的 create()创建代理类；

代码实例

CGLIB动态代理需要引入依赖

<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（方法拦截器）

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

import java.lang.reflect.Method;

/**
 * 自定义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

---

 

总结

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

JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。 另外， CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。

就二者的效率来说，大部分情况都是 JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

静态代理和动态代理对比

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

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

概况

代理模式是各框架中都经常使用的一种模式，而代理模式又分为静态代理和动态代理，静态代理用的比较少，主要用的还是动态代理。代理模式的优势在于用代理对象代替真实对象进行处理，这样我们可以在不修改被代理对象的情况下，再增加我们自己想要的操作。动态代理又分为JDK（proxy）动态代理和CGLIB动态代理。