无标签
Java

代理模式

代理模式是一种比较好理解的设计模式。简单来说就是我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。代理模式有静态代理和动态代理两种实现方式，我们先来看一下静态代理模式的实现。

静态代理

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

4. 实际使用

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()方法。

动态代理

相比于静态代理来说，动态代理更加灵活。我们不需要针对每个目标类都单独创建一个代理类，并且也不需要我们必须实现接口，我们可以直接代理实现类(CGLIB动态代理机制)。从JVM角度来说，动态代理是在运行时动态生成类字节码，并加载到JVM中的。说到动态代理，Spring AOP、RPC框架应该是两个不得不提的，它们的实现都依赖了动态代理。动态代理在我们日常开发中使用的相对较少，但是在框架中的几乎是必用的一门技术。学会了动态代理之后，对于我们理解和学习各种框架的原理也非常有帮助。就Java来说，动态代理的实现方式有很多种，比如JDK动态代理、CGLIB动态代理等等。

guide-rpc-framework使用的是JDK动态代理，我们先来看看JDK动态代理的使用。另外，虽然guide-rpc-framework没有用到CGLIB动态代理，我们这里还是简单介绍一下其使用以及和JDK动态代理的对比。

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()方法有下面三个参数：

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

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

JDK动态代理类使用步骤
  1. 定义一个接口及其实现类；
  2. 自定义InvocationHandler并重写invoke方法，在invoke方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；
  3. 通过Proxy.newProxyInstance(ClassLoaderloader,Class<?>[]interfaces,InvocationHandlerh)方法创建代理对象；
JDK动态代理原理(给一个接口实现匿名内部类)

利用拦截器（必须实现InvocationHandler）加上反射机制生成一个代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。举个例子，假设有一个接口A，A有一个实现类B，现在要给B生成代理对象，那么实际上是给A接口自动生成了一个匿名实现类，并且在这个匿名实现类中调用到B中的方法。JDK代理是不需要第三方库支持，只需要JDK环境就可以进行代理，使用条件:

  1. 实现InvocationHandler
  2. 使用Proxy.newProxyInstance产生代理对象
  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. 定义一个JDK动态代理类

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

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()方法代替我们去调用了被代理对象的原生方法。

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");

运行上述代码之后，控制台打印出：

before method send
send message:java
after method send

CGLIB动态代理机制

介绍

JDK动态代理有一个最致命的问题是其只能代理实现了接口的类。为了解决这个问题，我们可以用CGLIB动态代理机制来避免。CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB通过继承方式实现代理。很多知名的开源框架都使用到了CGLIB，例如Spring中的AOP模块中：如果目标对象实现了接口，则默认采用JDK动态代理，否则采用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()创建代理类；
CGLIB动态代理原理(生成子类)

利用ASM框架，对代理对象类生成的class文件加载进来，通过修改其字节码生成子类来处理。举个例子，现在有一个类A，A没有接口，现在想给A生成一个代理对象，那么实际上是自动给A生成了一个子类，在这个子类中覆盖了A中的方法，所以要注意，A类以及它里边的方法不能是final类型的，否则无法生成代理。CGLib必须依赖于CGLib的类库，但是它需要类来实现任何接口代理的是指定的类生成一个子类，覆盖其中的方法，是一种继承但是针对接口编程的环境下推荐使用JDK的代理。如果被代理的对象有接口，则可以使用JDK动态代理，没有接口就可以使用CGLIB动态代理。

代码示例

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

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

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

package github.javaguide.dynamicProxy.cglibDynamicProxy;

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

2. 自定义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;
    }

}

3. 获取代理类

import net.sf.cglib.proxy.Enhancer;

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. 实际使用

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

运行上述代码之后，控制台打印出：

before method send
send message:java
after method send

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

  1. JDK动态代理只能代理实现了接口的类或者直接代理接口，而CGLIB可以代理未实现任何接口的类。另外，CGLIB动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为final类型的类和方法。
  2. 就二者的效率来说，大部分情况都是JDK动态代理更优秀，随着JDK版本的升级，这个优势更加明显。

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

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

为什么要用代理模式？

  1. 中介隔离作用
    在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。
  2. 开闭原则，增加功能
    代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后对返回结果的处理等。代理类本身并不真正实现服务，而是同过调用委托类的相关方法，来提供特定的服务。真正的业务功能还是由委托类来实现，但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能，我们就可以使用代理类来完成，而没必要打开已经封装好的委托类。

原文链接
代理 demo
Spring AOP相关

相关文章

终于有人把java代理讲清楚了，万字详解！ 设计模式—代理模式 一文读懂Java动态代理
一文读懂Java动态代理，那些面试中你容易忽略的细节 Java动态代理的两种方式及其优缺点 面试官：为什么JDK动态代理只能代理接口？
文章作者: xmxe
文章链接: https://xmxe.github.io/blog/posts/5c9c6aec0510/
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 xmxe !
无标签
赏
 上一篇
Java中的Unsafe类 Java中的Unsafe类
本文整理完善自下面这两篇优秀的文章： Java魔法类：Unsafe应用解析-美团技术团队-2019 Java双刃剑之Unsafe类详解-码农参上-2021 阅读过JUC源码的同学，一定会发现很多并发工具类都调用了一个叫做Unsafe
xmxe Java
下一篇 
序列化和反序列化 序列化和反序列化
什么是序列化、反序列化?如果我们需要持久化Java对象比如将Java对象保存在文件中，或者在网络传输Java对象，这些场景都需要用到序列化。简单来说： 序列化：将数据结构或对象转换成二进制字节流的过程 反序列化：将在序列化过程中所生成的二
xmxe Java
  目录