【深入浅出设计模式】代理模式（jdk/cglib动态代理）

最新推荐文章于 2024-08-26 17:08:27 发布

lans_g

最新推荐文章于 2024-08-26 17:08:27 发布

阅读量568

点赞数

分类专栏：设计模式文章标签：代理模式设计模式 java

本文链接：https://blog.csdn.net/lans_g/article/details/124538863

版权

设计模式专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、什么是代理模式？

1.定义

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

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

2.通用类图

3.解释

Subject

可以是抽象类也可以是接口，一般都是接口，其中包含了代理者和被代理者共同的业务逻辑（方法）。

public interface Subject {
	//定义一个方法
	public void request();
}

RealSubject

被代理者，实现了Subject接口，是业务逻辑的具体执行者。

public class RealSubject implements Subject {
	//实现方法
	public void request() {
		//业务逻辑处理
	}
}

Proxy

代理者，业务逻辑中调用的实际是被代理者的方法，并在其前后可以增加一些自定义的操作，同样要实现Subject接口。

public class Proxy implements Subject {
	//要代理哪个实现类
	private Subject subject = null;
	//指定被代理者
	public Proxy(Subject subject){
		this.subject = subject;
	}
	//实现接口中定义的方法
	public void request() {
		this.before();
		this.subject.request();
		this.after();
	}
	//预处理
	private void before(){
		//do something
	}
	//善后处理
	private void after(){
		//do something
	}
}

二、静态代理

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

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

1.实现步骤

（1）定义一个接口及其实现类；

（2）创建一个代理类同样实现这个接口

（3）将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

2.代码实现

（1）定义发送短信的接口（Subject）

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

（2）实现发送短信的接口（RealSubject）

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

三、动态代理

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

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

动态代理在我们日常开发中使用的相对较少，但是在框架中的几乎是必用的一门技术。Spring AOP（CGLIB）、RPC 的实现都依赖了动态代理。

在java中，动态代理的实现方式有很多种，比如 JDK 动态代理、CGLIB 动态代理等等。

JDK动态代理

1.介绍

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

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

三个参数如下：

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

可以在 invoke()方法中自定义处理逻辑，比如在方法执行前后做什么事情。

2.使用步骤

（1）定义一个接口及其实现类；

（2）自定义 InvocationHandler 并重写invoke方法，在 invoke 方法中我们会调用原生方法（被代理类的方法）并自定义一些处理逻辑；

（3）通过 Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法创建代理对象

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()方法和method.invoke()方法毫无关系，只是名字一样！

method表示调用方法的原生方法（实际执行的方法），target表示被代理的对象，args是原生方法中的参数。

（4）获取代理对象的工厂类

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

（5）实际使用

SmsService smsService = (SmsService) 			             JdkProxyFactory.getProxy(newSmsServiceImpl());

smsService.send("java");

CGLIB 动态代理

1.介绍

在JDK 动态代理中，有一个最致命的问题是其只能代理实现了接口的类。为了解决这个问题，我们可以用 CGLIB 动态代理机制来避免。如果目标对象实现了接口，则默认采用 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;
}

参数如下：

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

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

2.使用步骤

（1）定义一个类（被代理类）；

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

（3）通过 Enhancer 类的 create()创建代理类

3.代码示例

因为CGLIB实际是属于一个开源项目，如果要使用它的话，需要手动添加相关依赖。

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

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

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;

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

四、总结

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

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

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

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

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

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

参考:
[JavaGuide]
[设计模式之禅]

lans_g

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录