结构型模式 - 代理模式

news2024/11/30 13:49:02

概述

由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

Java中的代理按照代理类生成时机不同又分为静态代理和动态代理。静态代理代理类在编译期就生成，而动态代理代理类则是在Java运行时动态生成。动态代理又有JDK代理和CGLib代理两种。

结构

代理（Proxy）模式分为三种角色：

  • 抽象主题（Subject）类： 通过接口或抽象类声明真实主题和代理对象实现的业务方法。

  • 真实主题（Real Subject）类： 实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。

  • 代理（Proxy）类 ： 提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。

静态代理

我们通过案例来感受一下静态代理。

【例】火车站卖票

如果要买火车票的话，需要去火车站买票，坐车到火车站，排队等一系列的操作，显然比较麻烦。而火车站在多个地方都有代售点，我们去代售点买票就方便很多了。这个例子其实就是典型的代理模式，火车站是目标对象，代售点是代理对象。类图如下：

 代码如下：

//卖票接口
public interface SellTickets {
    void sell();
}

//火车站  火车站具有卖票功能，所以需要实现SellTickets接口
public class TrainStation implements SellTickets {

    public void sell() {
        System.out.println("火车站卖票");
    }
}

//代售点
public class ProxyPoint implements SellTickets {

    private TrainStation station = new TrainStation();

    public void sell() {
        System.out.println("代理点收取一些服务费用");
        station.sell();
    }
}

//测试类
public class Client {
    public static void main(String[] args) {
        ProxyPoint pp = new ProxyPoint();
        pp.sell();
    }
}

从上面代码中可以看出测试类直接访问的是ProxyPoint类对象，也就是说ProxyPoint作为访问对象和目标对象的中介。同时也对sell方法进行了增强（代理点收取一些服务费用）。

JDK动态代理

接下来我们使用动态代理实现上面案例，先说说JDK提供的动态代理。Java中提供了一个动态代理类Proxy，Proxy并不是我们上述所说的代理对象的类，而是提供了一个创建代理对象的静态方法（newProxyInstance方法）来获取代理对象。

代码如下：

//卖票接口
public interface SellTickets {
    void sell();
}

//火车站  火车站具有卖票功能，所以需要实现SellTickets接口
public class TrainStation implements SellTickets {

    public void sell() {
        System.out.println("火车站卖票");
    }
}

//代理工厂，用来创建代理对象
public class ProxyFactory {

    private TrainStation station = new TrainStation();

    //获取代理对象方法
    public SellTickets getProxyObject() {
        //使用Proxy获取代理对象
        /*
            newProxyInstance()方法参数说明：
                ClassLoader loader ： 类加载器，用于加载代理类，使用真实对象的类加载器即可
                Class<?>[] interfaces ： 真实对象所实现的接口，代理模式真实对象和代理对象实现相同的接口，代理类实现的接口的字节码对象
                InvocationHandler h ： 代理对象的调用处理程序
         */
        SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(station.getClass().getClassLoader(),
                station.getClass().getInterfaces(),
                new InvocationHandler() {
                    /*
                        InvocationHandler中invoke方法参数说明：
                            proxy ： 代理对象。和sellTickets对象是同一个对象，在invoke方法中基本不用
                            method ： 对应于在代理对象上调用的接口方法的 Method 实例
                            args ： 代理对象调用接口方法时传递的实际参数
                            返回值：方法的返回值
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        System.out.println("代理点收取一些服务费用(JDK动态代理方式)");
                        //执行真实对象
                        Object result = method.invoke(station, args);
                        return result;
                    }
                });
        return sellTickets;
    }
}

//测试类
public class Client {
    public static void main(String[] args) {
        //获取代理对象
        //1,创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        //2,使factory对象的方法获取代理对象
        SellTickets proxyObject = factory.getProxyObject();
        //3,调用卖电脑的方法
        proxyObject.sell();
    }
}

使用了动态代理，我们思考下面问题：

  • ProxyFactory是代理类吗？

    ProxyFactory不是代理模式中所说的代理类，而代理类是程序在运行过程中动态的在内存中生成的类。通过阿里巴巴开源的 Java 诊断工具（Arthas【阿尔萨斯】）查看代理类的结构：

Arthas【阿尔萨斯】工具下载链接https://download.csdn.net/download/qq_36942720/88059724

查看代理类的字节码：

public static void main(String[] args) {
    //获取代理对象
    //1,创建代理工厂对象
    ProxyFactory factory = new ProxyFactory();
    //2,使用factory对象的方法获取代理对象
    SellTickets proxyObject = factory.getProxyObject();
    //3,调用卖调用的方法
    proxyObject.sell();

    System.out.println(proxyObject.getClass());

    //让程序一直执行
    while(true) {}
}

 启动Arthas工具：java -jar arthas-boot.jar

选择当前类实例，使用命令查看文件信息：jad com sun.proxy.$Proxy0

以下是输出的内存中的代理文件信息：

package com.sun.proxy;

import com.itheima.proxy.dynamic.jdk.SellTickets;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements SellTickets {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler invocationHandler) {
        super(invocationHandler);
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.itheima.proxy.dynamic.jdk.SellTickets").getMethod("sell", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
            return;
        }
        catch (NoSuchMethodException noSuchMethodException) {
            throw new NoSuchMethodError(noSuchMethodException.getMessage());
        }
        catch (ClassNotFoundException classNotFoundException) {
            throw new NoClassDefFoundError(classNotFoundException.getMessage());
        }
    }

    public final boolean equals(Object object) {
        try {
            return (Boolean)this.h.invoke(this, m1, new Object[]{object});
        }
        catch (Error | RuntimeException throwable) {
            throw throwable;
        }
        catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final String toString() {
        try {
            return (String)this.h.invoke(this, m2, null);
        }
        catch (Error | RuntimeException throwable) {
            throw throwable;
        }
        catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final int hashCode() {
        try {
            return (Integer)this.h.invoke(this, m0, null);
        }
        catch (Error | RuntimeException throwable) {
            throw throwable;
        }
        catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    public final void sell() {
        try {
            this.h.invoke(this, m3, null);
            return;
        }
        catch (Error | RuntimeException throwable) {
            throw throwable;
        }
        catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }
}

从上面的类中，我们可以看到以下几个信息：

  • 代理类（$Proxy0）实现了SellTickets。这也就印证了我们之前说的真实类和代理类实现同样的接口。

  • 代理类（$Proxy0）将我们提供了的匿名内部类对象传递给了父类。

动态代理的执行流程是什么样？

下面是摘取的重点代码：

//程序运行过程中动态生成的代理类
public final class $Proxy0 extends Proxy implements SellTickets {
    private static Method m3;

    public $Proxy0(InvocationHandler invocationHandler) {
        super(invocationHandler);
    }

    static {
        m3 = Class.forName("com.itheima.proxy.dynamic.jdk.SellTickets").getMethod("sell", new Class[0]);
    }

    public final void sell() {
        this.h.invoke(this, m3, null);
    }
}

//Java提供的动态代理相关类
public class Proxy implements java.io.Serializable {
	protected InvocationHandler h;
	 
	protected Proxy(InvocationHandler h) {
        this.h = h;
    }
}

//代理工厂类
public class ProxyFactory {

    private TrainStation station = new TrainStation();

    public SellTickets getProxyObject() {
        SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(station.getClass().getClassLoader(),
                station.getClass().getInterfaces(),
                new InvocationHandler() {
                    
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        System.out.println("代理点收取一些服务费用(JDK动态代理方式)");
                        Object result = method.invoke(station, args);
                        return result;
                    }
                });
        return sellTickets;
    }
}


//测试访问类
public class Client {
    public static void main(String[] args) {
        //获取代理对象
        ProxyFactory factory = new ProxyFactory();
        SellTickets proxyObject = factory.getProxyObject();
        proxyObject.sell();
    }
}

执行流程如下：

  1. 在测试类中通过代理对象调用sell()方法

  2. 根据多态的特性，执行的是代理类（$Proxy0）中的sell()方法

  3. 代理类（$Proxy0）中的sell()方法中又调用了InvocationHandler接口的子实现类对象的invoke方法

  4. invoke方法通过反射执行了真实对象所属类(TrainStation)中的sell()方法

CGLIB动态代理

同样是上面的案例，我们再次使用CGLIB代理实现。

如果没有定义SellTickets接口，只定义了TrainStation(火车站类)。很显然JDK代理是无法使用了，因为JDK动态代理要求必须定义接口，对接口进行代理。

CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。

CGLIB是第三方提供的包，所以需要引入jar包的坐标：

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

代码如下：

//火车站
public class TrainStation {

    public void sell() {
        System.out.println("火车站卖票");
    }
}

//代理工厂
public class ProxyFactory implements MethodInterceptor {

    private TrainStation target = new TrainStation();

    public TrainStation getProxyObject() {
        //创建Enhancer对象，类似于JDK动态代理的Proxy类，下一步就是设置几个参数
        Enhancer enhancer =new Enhancer();
        //设置父类的字节码对象
        enhancer.setSuperclass(target.getClass());
        //设置回调函数
        enhancer.setCallback(this);
        //创建代理对象
        TrainStation obj = (TrainStation) enhancer.create();
        return obj;
    }

    /*
        intercept方法参数说明：
            o ： 代理对象
            method ： 真实对象中的方法的Method实例
            args ： 实际参数
            methodProxy ：代理对象中的方法的method实例
     */
    public TrainStation intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("代理点收取一些服务费用(CGLIB动态代理方式)");
        TrainStation result = (TrainStation) methodProxy.invokeSuper(o, args);
        return result;
    }
}

//测试类
public class Client {
    public static void main(String[] args) {
        //创建代理工厂对象
        ProxyFactory factory = new ProxyFactory();
        //获取代理对象
        TrainStation proxyObject = factory.getProxyObject();

        proxyObject.sell();
    }
}

三种代理的对比

  • JDK代理和CGLIB代理

    使用CGLib实现动态代理，CGLib底层采用ASM字节码生成框架，使用字节码技术生成代理类，在JDK1.6之前比使用Java反射效率要高。唯一需要注意的是，CGLib不能对声明为final的类或者方法进行代理，因为CGLib原理是动态生成被代理类的子类。

    在JDK1.6、JDK1.7、JDK1.8逐步对JDK动态代理优化之后，在调用次数较少的情况下，JDK代理效率高于CGLib代理效率，只有当进行大量调用的时候，JDK1.6和JDK1.7比CGLib代理效率低一点，但是到JDK1.8的时候，JDK代理效率高于CGLib代理。所以如果有接口使用JDK动态代理，如果没有接口使用CGLIB代理。

  • 动态代理和静态代理

    动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。

    如果接口增加一个方法，静态代理模式除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。而动态代理不会出现该问题

优缺点

优点：

  • 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；

  • 代理对象可以扩展目标对象的功能；

  • 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度；

缺点：

  • 增加了系统的复杂度；

使用场景

  • 远程（Remote）代理

    本地服务通过网络请求远程服务。为了实现本地到远程的通信，我们需要实现网络通信，处理其中可能的异常。为良好的代码设计和可维护性，我们将网络通信部分隐藏起来，只暴露给本地服务一个接口，通过该接口即可访问远程服务提供的功能，而不必过多关心通信部分的细节。

  • 防火墙（Firewall）代理

    当你将浏览器配置成使用代理功能时，防火墙就将你的浏览器的请求转给互联网；当互联网返回响应时，代理服务器再把它转给你的浏览器。

  • 保护（Protect or Access）代理

    控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/768617.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Docker 基础知识解析：容器与传统虚拟化对比：资源利用、启动时间、隔离性和部署效率

Docker 基础知识解析：容器与传统虚拟化对比：资源利用、启动时间、隔离性和部署效率

&#x1f337;&#x1f341; 博主 libin9iOak带您 Go to New World.✨&#x1f341; &#x1f984; 个人主页——libin9iOak的博客&#x1f390; &#x1f433; 《面试题大全》 文章图文并茂&#x1f995;生动形象&#x1f996;简单易学&#xff01;欢迎大家来踩踩~&#x1f33…
阅读更多...
Vscode配置grpc+c#+proto

Vscode配置grpc+c#+proto

首先是环境配置&#xff0c;用的dotnet5.0的sdk&#xff0c;所以Vscode的C#插件版本要选择1.24&#xff0c;然后需要配置C# Snippets、NuGget Package Manager、vscode-proto3、vscode-solution-extension&#xff08;可选&#xff09;。 以vscode-solution-extension为例新建A…
阅读更多...
【大数据之Hive】二十四、HQL语法优化之任务并行度

【大数据之Hive】二十四、HQL语法优化之任务并行度

1 优化说明 Hive的计算任务由MapReduce完成&#xff0c;并行度调整分为Map端和Reduce端。 1.1 Map端并行度 Map端的并行度及Map的个数&#xff0c;由输入文件的切片数决定&#xff0c;一般情况下Map端并行度不需要手动调整。   在特殊情况下&#xff08;查询的表中存在大量小…
阅读更多...
大数据学习03-Hive分布式集群部部署

大数据学习03-Hive分布式集群部部署

系统环境&#xff1a;centos7 软件版本&#xff1a;jdk1.8、zookeeper3.4.8、hadoop2.8.5、hive1.1.0 一、下载安装 下载hive安装包&#xff0c;上传到linux服务器上&#xff0c; 解压安装包 tar -zxvf apache-hive-1.1.0-bin.tar.gz -C /home/local/重命名文件 mv apache-…
阅读更多...
手机VPN的连接方法分享

手机VPN的连接方法分享

1、首先在手机屏幕左右的滑动，找到手机的设置图标。 2、在打开的小米手机设置页面中点击“更多连接方式”的菜单项。 3、然后在打开的更多连接方式页面中点击VPN的菜单项。 4、在打开的VPN设置页面中点击“添加VPN”的按钮。 5、在打开的添加VPN的页面中输入VPN的信息后点击右…
阅读更多...
Element-UI 实现动态增加多个不同类型的输入框并校验（双重v-for表单验证）

Element-UI 实现动态增加多个不同类型的输入框并校验（双重v-for表单验证）

文章目录 前言定义表单格式表单渲染和验证扩展 前言 在做复杂的动态表单&#xff0c;实现业务动态变动&#xff0c;比如有一条需要动态添加的el-form-item中包含了多个输入框&#xff0c;并实现表单验证&#xff0c;但在element-ui组件库中给出的表单校验中没有这样的格式&…
阅读更多...
简析三相电能预付费控制系统的设计与产品选型

简析三相电能预付费控制系统的设计与产品选型

摘要&#xff1a;介绍了一种电能预付费系统&#xff0c;主要用于三相动力用户。采用预付费控制器终端和电能表分离的方式&#xff0c;从原有电表读取相关数据用于比较&#xff0c;在尽量少改动原有接线的情况下安装预付费控制系统。采用安全性和稳定性高的RFID卡&#xff0c;数…
阅读更多...
真正的理解WPF中的TemplatedParent

真正的理解WPF中的TemplatedParent

童鞋们在WPF中经常看到 TemplatedParent ，或者经常看到下面的用法： {Binding RelativeSource={RelativeSource TemplatedParent}, Path=Content} 是不是看的一脸蒙圈？ 先看官方文档： 意思是 和这个控件的 模板上的 父亲，如果这个控件不是模板创建的，那么这个值就…
阅读更多...
Servlet 会话跟踪基础

Servlet 会话跟踪基础

文章目录 前言Cookie实例Cookie缺点Cookie案例代码 SessionSession的创建与销毁Session的创建Session的销毁 Session和Cookie的区别不同联系 前言 提示&#xff1a;这里可以添加本文要记录的大概内容&#xff1a; 在Web应用程序中&#xff0c;会话跟踪是一种技术&#xff0c;…
阅读更多...
vue+element-ui通用后台管理系统（适合新手）

vue+element-ui通用后台管理系统（适合新手）

vueelement-ui通用后台管理系统&#xff08;适合新手&#xff09; 1、使用到的技术 使用vue2element-uiaxiosjs-cookielessecharts实现的一个简易的通用后台管理系统&#xff0c;具有很强的可扩展性&#xff0c;修改简单&#xff0c;只要有点前端基础就能看懂&#xff1b; 2…
阅读更多...
汇编 -20230718

汇编 -20230718

一. 练习&#xff1a; 1. 1-100的和 .text .globl _start_start:mov r0, #0 存放结果mov r1, #0 存放当前数mov r2, #100 结束条件的数addFun:add r1, r1, #1add r0, r0, r1cmp r1, r2bne addFunstop:b stop.end结果展示&#xff1a;
阅读更多...
将DAST集成到CI/CD管道中的优势和实施步骤

将DAST集成到CI/CD管道中的优势和实施步骤

在当今快速发展的网络环境中&#xff0c;维护Web应用程序的安全更加必要。由于漏洞的出现速度比以往任何时候都要快&#xff0c;将动态应用程序安全测试&#xff08;DAST&#xff09;集成到持续集成/持续部署&#xff08;CI/CD&#xff09;管道中成为改变游戏规则的因素&#x…
阅读更多...
uni-app：单位像素rpx

uni-app：单位像素rpx

rpx:响应式单位&#xff0c;长宽可以随着屏幕大小改变&#xff0c;其尺寸根据iPhone 6的标准来参考&#xff08;750rpx为占满屏幕宽&#xff0c;1334rpx为占满屏幕长。7501334rpx&#xff09; 例子&#xff1a; 现在展示型号为iPhone 12 pro的型号&#xff0c;这里750px和750…
阅读更多...
利用大模型进行法律判决预测

利用大模型进行法律判决预测

概述 本文研究背景是法律专业人员常用的演绎推理方法&#xff0c;即法律演绎&#xff0c;用于案例分析。 过去的方法主要是通过学习、微调或示例来教授大型语言模型&#xff08;LLM&#xff09;进行法律判决预测。这些方法存在的问题是学习样本有限&#xff0c;解释性差。因此…
阅读更多...
02 - 如何制定性能调优策略？

02 - 如何制定性能调优策略？

1、性能测试攻略 性能测试是提前发现性能瓶颈&#xff0c;保障系统性能稳定的必要措施。下面我先给你介绍两种常用的测试方法&#xff0c;帮助你从点到面地测试系统性能。 1.1、微基准性能测试 微基准性能测试可以精准定位到某个模块或者某个方法的性能问题&#xff0c;特别…
阅读更多...
数仓-零基础小白到入土-学习路线

数仓-零基础小白到入土-学习路线

数仓-零基础小白到入土-学习路线 铺垫一下下讲在前面涉及基础技术栈&#xff1a;中级&#xff1a;全部掌握之后&#x1f446;&#xff1a;去刷面试题&#xff1a; 初级中级高级博主独家面试题&#xff1a;数仓名词&#xff1a;催更我戳戳个人主页&#xff1a;[up自己的网站](ht…
阅读更多...
Kafka - 分区中各种偏移量的说明

Kafka - 分区中各种偏移量的说明

文章目录 引子名词解释分区中各种偏移量的说明 引子 名词解释 Kafka是一个高性能、高吞吐量的分布式消息系统&#xff0c;被广泛应用于大数据领域。在Kafka中&#xff0c;分区是一个重要的概念&#xff0c;它可以将数据分发到不同的节点上&#xff0c;以实现负载均衡和高可用性…
阅读更多...
【PHP面试题73】TCP和UDP的特点和区别是什么？

【PHP面试题73】TCP和UDP的特点和区别是什么？

文章目录 一、前言二、TCP&#xff08;Transmission Control Protocol&#xff09;三、UDP&#xff08;User Datagram Protocol&#xff09;四、TCP和UDP的区别五、总结 一、前言 本文已收录于PHP全栈系列专栏&#xff1a;PHP面试专区。 计划将全覆盖PHP开发领域所有的面试题&a…
阅读更多...
Go速成-常量

Go速成-常量

1.常量的定义 Go语言常量&#xff0c;定义的值是不能进修修改的&#xff0c;定义常量就是const&#xff0c;常量定义建议全部大写 const PI float32 3.1415946 //显式定义 const (x int 16ys "abc"z)fmt.Print(x,y,s,z) 在定义常量的时候如果没有声明值&#xff…
阅读更多...
微信小程序的目录解析--【浅入深出系列001外篇】

微信小程序的目录解析--【浅入深出系列001外篇】

浅入深出系列总目录在000集 如何0元学微信小程序–【浅入深出系列000】 文章目录 本系列校训学习资源的选择先说总目录经常碰到的文件(目录&#xff09;最最常见的目录pages次最常用的就是images 目录 操作起来真正的操作 配套资源 本系列校训 用免费公开视频&#xff0c;卷…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023