Java代理模式

最新推荐文章于 2023-07-04 16:10:57 发布

H3nry

最新推荐文章于 2023-07-04 16:10:57 发布

阅读量221

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_27783897/article/details/108457998

版权

1. 代理模式

我们使用代理对象来代替对真实对象的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。
代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后可以增加一些自定义操作。

2. 静态代理

从实现和应用角度来说
静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常不灵活（比如接口一旦新增加方法，目标对象和代理对象都要进行修改）
从JVM层面来说
静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的class文件。

静态代理实现步骤：

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

示例

定义发送短信的接口

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

相比于静态代理来说，动态代理更加灵活。
我们不需要为每一个目标类都单独创建一个代理类，并且也不需要必须一个个的趋势线目标接口，我们可以直接代理实现类（CDLIB）
** 从JVM角度来说，动态代理是在运行时动态生成类字节码，并加载到JVM中的**
SpringAOP、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 方法来调用。

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

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() 方法获取某个类的代理对象

实际使用

DebugProxy debugProxy = new DebugProxy(new SmsServiceImpl());
SmsService smsService = debugProxy.getProxy(SmsService.class);
smsService.send("java");

控制台打印出：

before method send
send message:java
after method send

3.2 CGLIB动态代理机制

3.2.1 介绍
JDK动态代理有一个问题是，只能代理实现了接口的类。
CGLIB可以避免。

CGLIB是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB通过继承方式实现代理。例如：Spring的AOP中，如果目标对象实现了接口，则默认采用JDK动态代理，否则采用CGLIB动态代理。

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

你需要自定义 MethodIntercept 并重写 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: 方法入参
methodProxy: 用于调用原始方法

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

3.2.2 CGLIB动态代理类使用步骤

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

3.2.3 代码示例
CGLIB实际是属于一个开源项目，需要手动添加相关依赖。

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

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

package github.javaguide.dynamicProxy.cglibDynamicProxy;

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

}

获取代理类

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

实际使用

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类型的类和方法。
就二者的效率来说，大部分情况都是JDK动态代理更优秀。

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

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