首页 > 其他分享 >一文带你彻底搞懂什么是代理模式！！

一文带你彻底搞懂什么是代理模式！！

时间：2024-07-07 23:27:07浏览次数：17  
标签：一文 对象 代理 接口 搞懂 动态 方法 public

一文带你彻底搞懂什么是代理模式！！

什么是代理模式？

代理模式是一种常见的设计模式，它为其他对象提供了一种代理，以控制对这个对象的访问。

我们可以将代理模式看作是一个中介，它允许客户端通过代理对象与目标对象进行交互，而不是直接与目标对象交互。

代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。
在这里插入图片描述
代理模式有静态代理和动态代理两种实现方式，我们先来看一下静态代理模式的实现。

Tips: 在看接下来的文章时，前面的概念也许会让你看得云里雾里，摸不着头脑，强烈建议：先简单看一下即可，然后自己根据提供的代码去实现一遍，注意是自己敲一遍哈，直接复制的话效果可能会大打折扣，而梳理一遍后反过来再去理解，甚至像我一样写一篇博客，理解那就会大大滴深刻！！

静态代理

静态代理中，我们对目标对象的每个方法的增强都是手动完成的，非常不灵活比如接口一旦新增加方法，目标对象和代理对象都要进行修改，需要对每个目标类都单独写一个代理类。

在这里插入图片描述

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

静态代理实现步骤:

  1. 定义一个接口及其实现类；
  2. 创建一个代理类同样实现这个接口
  3. 将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。

这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

理论会很枯燥 通过代码展示更加形象：

  1. 定义发送短信的接口
public interface SmsService {
    String send(String message);
}
  1. 实现发送短信的接口
public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}
  1. 创建代理类并同样实现发送短信的接口
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;
    }
}

注意这里的 final 关键字，这里它的作用是确保 smsService 成员变量一旦被初始化后其值就不能被改变。因为代理类的目的是控制对真实对象的访问，如果允许 smsService 被更改，那么代理类就无法保证对真实对象的访问总是通过代理来控制，这可能会破坏代理模式的设计。

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

控制台输出：

在这里插入图片描述

可以看到，我们通过 代理类 SmsProxy 重写目标对象接口 SmsService 的 send() 方法的方式，扩展了目标对象的接口的功能(before 和 after)实现了静态代理

静态代理模式在不改变目标对象的前提下，实现了对目标对象的功能扩展。

静态代理的问题

静态代理中，接口一旦新增加方法，目标对象和代理对象都要进行修改，且需要对每个目标类都单独写一个代理类

比如我们对 SmsService 新增一个方法

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

此时，我们就不得不在目标对象和代理对象中都进行 recive 方法的重写

动态代理

相比于静态代理，动态代理展现出更高的灵活性。我们无需为每个目标类分别创建代理类，也无需强制实现接口，可以直接对实现类进行代理（例如使用CGLIB动态代理机制）。

从Java虚拟机（JVM）的角度来看，动态代理是在运行时动态生成类字节码，并将其加载到JVM中。

提及动态代理，Spring AOP和RPC（远程过程调用）框架是两个典型的应用案例，它们的实现都依赖于动态代理技术。

虽然在日常开发中，我们可能不会频繁直接使用动态代理，但在各种框架中，它几乎成为了一项不可或缺的技术。

掌握动态代理对于理解和学习各类框架的内部原理具有重要意义。在Java生态中，动态代理的实现方式多种多样，包括JDK动态代理和CGLIB动态代理等。

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

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

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

JDK 代理的使用步骤：

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

在这里插入图片描述

代码示例：

  1. 定义发送短信的接口
public interface SmsService {
    String send(String message);
}
  1. 实现发送短信的接口
public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}
  1. 定义一个 JDK 动态代理类
package Proxy.Trends_state;

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

/**
 * @Author:wjy
 */
public class DebugInvocationHandler implements InvocationHandler {
    private final Object target;

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

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

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

  1. 测试类
SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());
smsService.send("java");

结果：

在这里插入图片描述

代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用动态代理。

动态代理的方式中，所有的函数调用最终都会经过 invoke 函数的转发，因此我们就可以在这里做一些自己想做的操作，比如日志系统、事务、拦截器、权限控制等。

JDK 动态代理的问题

JDK 动态代理有一个最致命的问题是它只能代理实现了某个接口的实现类，并且代理类也只能代理接口中实现的方法，要是实现类中有自己私有的方法，而接口中没有的话，该方法不能进行代理调用。

怎么解决这个问题呢？我们可以用 CGLIB 动态代理机制。

CGLIB 动态代理

静态代理和JDK代理都需要某个对象实现一个接口，有时候代理对象只是一个单独对象，此时可以使用Cglib代理。

在这里插入图片描述

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

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

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() 创建代理类；

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

<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.3.0</version>
</dependency>
  1. 实现一个使用阿里云发送短信的类
package Proxy.cglib;

/**
 * @Author:wjy
 */
public class AliSmsService {
    public String send(String message){
        System.out.println("send message: "+ message);
        return message;
    }
}
  1. 自定义 MethodInterceptor（方法拦截器）
package Proxy.cglib;

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

import java.lang.reflect.Method;

/**
 * @Author:wjy
 */
public class DebugMethodInterceptor implements MethodInterceptor {
    @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;
    }
}
  1. 获取代理类
package Proxy.cglib;

import net.sf.cglib.proxy.Enhancer;

/**
 * @Author:wjy
 */
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();
    }
}
  1. 测试类
package Proxy.cglib;

/**
 * @Author:wjy
 */
public class Main {
    public static void main(String[] args) {
        AliSmsService aliSmsService = (AliSmsService) CglibProxyFactory.getProxy(AliSmsService.class);
        aliSmsService.send("java");
    }
}

结果：

在这里插入图片描述

Spring中 AOP 使用代理

Spring中 AOP 的实现有 JDK 和CGLIB 两种，如下图：

在这里插入图片描述

如果目标对象需要实现接口，则使用 JDK 代理。

如果目标对象不需要实现接口，则使用 CGLIB 代理。

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

JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。

另外，CGLIB 动态代理是通过生成一个被代理类的子类来拦截被代理类的方法调用，因此不能代理声明为 final 类型的类和方法。

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

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

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

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

总结

静态代理：需要代理类和目标类都实现接口的方法，从而达到代理增强其功能。

JDK 动态代理：需要代理类实现某个接口，使用 Proxy.newProxyInstance 方法生成代理类，并实现 InvocationHandler 中的 invoke 方法，实现增强功能。

CGLIB 动态代理：无需代理类实现接口，使用 CGLIB 中的 Enhancer 来生成代理对象子类，并实现 MethodInterceptor 中的 intercept 方法，在此方法中可以实现增强功能。

参考文章：
Java 代理模式详解

单例模式超详解：
一文带你彻底搞懂设计模式之单例模式！！由浅入深，图文并茂，超超超详细的单例模式讲解！！

标签：一文,对象,代理,接口,搞懂,动态,方法,public
From： https://blog.csdn.net/m0_63653444/article/details/140217375

相关文章

  • 虚拟机通过宿主机代理实现从外网拉取镜像的方法
     先看一下配置前的效果，在拉取镜像时等待了1分钟，毫无进展root@Y76-K8s-Master01:~#dockerpullnginxUsingdefaulttag:latestlatest:Pullingfromlibrary/nginxea235d1ccf77:Retryingin1seconde29cef106877:Retryingin1seconde9bf20d5335e:Retryingin1......
  • 配置与管理squid代理服务器
    应用背景如下图所示，公司用squid作代理服务器，代理服务器内网IP地址为192.168.200.1，外网IP为192.168.200.3公司内网所用IP地址段为192.168.200.0/24，并且想用8080作为代理端口。1：配置非透明代理1.1、配置主机网络准备三台Linux主机，第一台为外网主机名为www，网卡（Vmnet1）IP为218.2......
  • 【攻防技术系列+代理转发】工具--netcat
    【需求】现在想要实现两个不同网段的私网之间相互通信，我们该如何做呢？......
  • 一文带你了解Java虚拟机垃圾收集器
    如果你的世界，没有痛苦的害怕，没有尊严的担忧，没有富贵的贫贱，没有暖寒的交替，没有外貌的困扰，没有男女的区别，没有你我之分，没有生死顾虑，你才会离＂真正的活着＂越来越近。——余华《活着》在上一篇内容中我们提到在Java虚拟机中主要是通过标记整理、复制拷贝、标记清除三种算法进行内......
  • 一文讲透箭头函数和This
    目录前言环境说明准备node中this的坑this常用场景全局中的this函数中的this构造函数中的this改变this的三种方式箭头函数箭头函数This结论代码示例面试题测试：前言在JavaScript中，this是理解函数上下文的关键。本文将深入剖析this的奥秘，揭示其在不同场景下的行为，......
  • 一文理解 Treelite，Treelite 为决策树集成模型的部署和推理提供了高效、灵活的解决方案
    ......
  • 【汽车故障诊断3】一文了解诊断故障码DTC状态位
    在上篇 【汽车故障诊断2】一文了解诊断故障码DTC介绍DTC的基本概念，本篇文章将继续介绍DTC的其他信息：DTC状态位。1什么是DTC状态位  DTC状态位，即StatusOfDTC，是用来指示DTC所对应的故障是否发生，是否被确认等状态。DTC状态位包含1个字节数据长度，每一位都有具体的定义，如下......
  • 深度剖析：独享代理与共享代理的区别
    大家好，欢迎来到今天的网络小课堂！想象一下，我们在互联网的大海里遨游，每次点击都像是一次新的探险。在这片信息的海洋里，代理服务器就像是我们的航海助手，但不同的“助手”会带给我们截然不同的体验。今天，我们就来聊聊独享代理和共享代理，教你如何根据自己的需求，做出最合适的选择。......
  • 收集了几个Github文件代理下载的站点
     收集了几个Github文件代理下载的站点1、GitClone 2、ghproxy 3、moeyy  最后实在不行可以去Gitee上边，新建仓库->从现有仓库导入，然后从gitee上下载 ......
  • 免费代理 IP 如何泄露您的个人信息?
    互联网时代，信息安全和隐私保护成为人们关注的焦点。很多用户出于各种需要，使用代理服务器浏览网页或进行其他网络活动，其中免费代理IP因其免费的特点而受到广泛青睐。然而，免费代理IP并不总是一个安全可靠的选择，它们可能成为个人信息泄露的媒介。本文将详细分析免费代理IP如何泄露......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99