万字解析设计模式之代理模式

最新推荐文章于 2024-07-24 15:26:16 发布

烟雨平生9527

最新推荐文章于 2024-07-24 15:26:16 发布

阅读量318

点赞数 1

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

本文链接：https://blog.csdn.net/qq_62377885/article/details/134516770

版权

设计模式专栏收录该内容

12 篇文章 4 订阅

订阅专栏

一、代理模式

1.1概述

代理模式是一种结构型设计模式，它允许通过创建代理对象来控制对其他对象的访问。这种模式可以增加一些额外的逻辑来控制对原始对象的访问，同时还可以提供更加灵活的访问方式。

代理模式分为静态代理和动态代理两种。静态代理是在编译时就确定代理对象和目标对象的关系，由程序员手动编写代理类；动态代理是在运行时根据接口动态生成代理对象，无需手动编写代理类。静态代理代理类在编译期就生成，而动态代理代理类则是在Java运行时动态生成。动态代理又有JDK代理和CGLib代理两种。

代理模式可以用于实现对象的远程访问、权限控制、性能优化等功能。在实际应用中，代理模式常用于网络编程、数据库操作、日志记录等方面。

1.2 结构

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

抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。（定义了被代理对象和代理对象的公共接口)
真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
代理（Proxy）类：保存一个引用使得代理可以访问实体，并提供一个与抽象主题相同的接口，这样代理就可以用于替代实体实现主题接口，它可以访问、控制或扩展真实主题的功能。

1.3实现

静态代理

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

【例】火车站卖票

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

抽象主题（Subject）类

package com.yanyu.Proxy_static;

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

接口规定是为了让代理类包含和被代理类相同的功能

真实主题（Real Subject）类

package com.yanyu.Proxy_static;

//火车站  火车站具有卖票功能，所以需要实现SellTickets接口
public class TrainStation implements SellTickets {
    public void sell() {
        System.out.println("火车站卖票");
    }
}

代理（Proxy）类

package com.yanyu.Proxy_static;

public class ProxyPoint implements SellTickets {

    private TrainStation station = new TrainStation();

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

测试类

package com.yanyu.Proxy_static;

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

以上代码实现了代理模式，其中：

1. SellTickets接口定义了卖票功能，作为代理点和火车站的共同接口；

2. TrainStation类实现了SellTickets接口，表示火车站具有卖票功能；

3. ProxyPoint类也实现了SellTickets接口，但它并没有直接卖票，而是在卖票前先收取一些服务费用，然后再调用TrainStation的sell方法，实现了代理的功能；

JDK动态代理

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

package com.yanyu.Proxy_static;

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

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

    // 创建一个 TrainStation 实例
    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 ： 代理对象
                        method ： 对应于在代理对象上调用的接口方法的 Method 实例
                        args ： 代理对象调用接口方法时传递的实际参数
                */
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("代理点收取一些服务费用(JDK 动态代理方式)");
                    // 执行真实对象，并获取其返回值
                    /*
                      station 是一个Object类型的实例对象，表示要调用方法的目标对象。
                       args 是一个Object类型的数组，表示传递给要调用的方法的参数列表。
                    */
                    Object result = method.invoke(station, args);
                    return result;
                }
            });
        return sellTickets;
    }
}

该代码为使用Java反射中的动态代理实现代理模式的示例代码。

这段代码是一个代理工厂，主要作用是创建一个代理对象。具体实现是使用Java反射中的Proxy类的newProxyInstance()方法来创建代理对象，该方法的三个参数分别表示代理类的类加载器、代理类需要实现的接口、代理对象的调用处理程序。其中，调用处理程序是一个接口InvocationHandler的实现类，具体实现了invoke()方法，该方法用于在代理对象上调用接口方法时，实现对真实对象的调用，并在调用前后添加了一些额外的操作，比如收取一些服务费用。最终，该工厂返回一个代理对象，该对象实现了SellTickets接口，可以直接用于卖票业务。

package com.yanyu.Proxy_static;

//测试类
// 定义一个公共类Client
public class Client {
   
    public static void main(String[] args) {
        // 创建一个代理工厂对象
        ProxyFactory factory = new ProxyFactory();

        // 获取代理对象
        SellTickets proxyObject = factory.getProxyObject();

        // 调用代理对象的sell方法
        proxyObject.sell();
    }
}

执行流程如下：

在测试类中通过代理对象调用sell()方法
根据多态的特性，执行的是代理类（$Proxy0）中的sell()方法
代理类（$Proxy0）中的sell()方法中又调用了InvocationHandler接口的子实现类对象的invoke方法
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();
    }
}

1.4三种代理的对比

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）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。

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

1.5 优缺点

优点：

代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
代理对象可以扩展目标对象的功能；
代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度；

缺点：

增加了系统的复杂度；

1.6使用场景

适合应用场景

远程（Remote）代理：为一个位于不同的地址空间的对象提供一个局域代表对象。这个不同的地址空间可以是在本机器中，也可是在另一台机器中。远程代理又叫做大使（Ambassador）。好处是系统可以将网络的细节隐藏起来，使得客户端不必考虑网络的存在。客户完全可以认为被代理的对象是局域的而不是远程的，而代理对象承担了大部份的网络通讯工作。由于客户可能没有意识到会启动一个耗费时间的远程调用，因此客户没有必要的思想准备。

虚拟（Virtual）代理：根据需要创建一个资源消耗较大的对象，使得此对象只在需要时才会被真正创建。使用虚拟代理模式的好处就是代理对象可以在必要的时候才将被代理的对象加载；代理可以对加载的过程加以必要的优化。当一个模块的加载十分耗费资源的情况下，虚拟代理的好处就非常明显。

Copy-on-Write代理：虚拟代理的一种。把复制（克隆）拖延到只有在客户端需要时，才真正采取行动。

保护（Protect or Access）代理：控制对一个对象的访问，如果需要，可以给不同的用户提供不同级别的使用权限。保护代理的好处是它可以在运行时间对用户的有关权限进行检查，然后在核实后决定将调用传递给被代理的对象。

Cache代理：为某一个目标操作的结果提供临时的存储空间，以便多个客户端可以共享这些结果。

防火墙（Firewall）代理：保护目标，不让恶意用户接近。

同步化（Synchronization）代理：使几个用户能够同时使用一个对象而没有冲突。

智能引用。可在没有客户端使用某个重量级对象时立即销毁该对象。代理会将所有获取了指向服务对象或其结果的客户端记录在案。代理会时不时地遍历各个客户端，检查它们是否仍在运行。如果相应的客户端列表为空，代理就会销毁该服务对象，释放底层系统资源。

二、实验

任务描述

第三方 hunau 程序库提供了视频下载类 ThirdPartyhunauClass,但是该类的效率非常低。如果客户端程序多次请求同一视频，程序库会反复下载该视频，而不会将首次下载的文件缓存下来复用。

本关任务：使用代理模式在第三方 hunau 视频程序库中添加延迟初始化和缓存。代理类 HunauCacheProxy 实现和原下载器 ThirdPartyhunauClass 相同的接口，并将所有工作委派给原下载器 ThirdPartyhunauClass。不过，代理类 HunauCacheProxy 会保存所有的文件下载记录，如果程序多次请求同一文件，它会返回缓存的文件。类图结构如图

实现方式

如果没有现成的服务接口，你就需要创建一个接口来实现代理和服务对象的可交换性。从服务类中抽取接口并非总是可行的，因为你需要对服务的所有客户端进行修改，让它们使用接口。备选计划是将代理作为服务类的子类，这样代理就能继承服务的所有接口了；

创建代理类，其中必须包含一个存储指向服务的引用的成员变量。通常情况下，代理负责创建服务并对其整个生命周期进行管理。在一些特殊情况下，客户端会通过构造函数将服务传递给代理；

根据需求实现代理方法。在大部分情况下，代理在完成一些任务后应将工作委派给服务对象；

可以考虑新建一个构建方法来判断客户端可获取的是代理还是实际服务。你可以在代理类中创建一个简单的静态方法，也可以创建一个完整的工厂方法；

可以考虑为服务对象实现延迟初始化。

编程要求

根据提示，在右侧编辑器 Begin-End 内补充 “HunauCacheProxy.java” 的代码，并输出模拟结果。

实体类

package step1;

// 创建一个 Video 类用于表示视频信息
public class Video {
    // 视频的ID
    public String id;
    // 视频的标题
    public String title;
    // 视频的数据
    public String data;

    // 构造方法，用于初始化视频的ID和标题，数据初始化为"Random video."
    Video(String id, String title) {
        this.id = id;
        this.title = title;
        this.data = "Random video.";
    }
}

抽象主题（Subject）类

package step1;

import java.util.HashMap;

// 创建一个接口 ThirdPartyhunauLib 用于定义获取视频的方法
public interface ThirdPartyhunauLib {
    // 定义获取视频的方法，参数为视频ID，返回类型为Video
    Video getVideo(String videoId);
}

真实主题（Real Subject）类

package step1;

import java.util.HashMap;

// 创建一个实现接口 ThirdPartyhunauLib 的类 ThirdPartyhunauClass
public class ThirdPartyhunauClass implements ThirdPartyhunauLib{

  // 私有方法，用于模拟连接到服务器
  private void connectToServer(String server) {
      System.out.print("Connecting to " + server + "... ");
      experienceNetworkLatency();
      System.out.print("Connected!" + "\n");
  }

  // 实现接口中的获取视频方法
  @Override
  public Video getVideo(String videoId) {
      // 连接到服务器
      connectToServer("https://www.hunau.edu.cn/" + videoId);
      // 获取视频
      return getSomeVideo(videoId);
  }

  // 生成指定范围的随机整数
  private int random(int min, int max) {
      return min + (int) (Math.random() * ((max - min) + 1));
  }

  // 模拟网络访问的时间间隔
  private void experienceNetworkLatency() {
      int randomLatency = random(5, 10);
      for (int i = 0; i < randomLatency; i++) {
          try {
              Thread.sleep(100);
          } catch (InterruptedException ex) {
              ex.printStackTrace();
          }
      }
  }

  // 模拟获取视频的过程
  private Video getSomeVideo(String videoId) {
      System.out.print("Downloading video... ");
      experienceNetworkLatency();
      Video video = new Video(videoId, "Some video title");
      System.out.print("Done!" + "\n");
      return video;
  }
}

代理（Proxy）类

package step1;

import java.util.HashMap;

// 创建一个 HunauCacheProxy 类用作视频缓存代理，实现了 ThirdPartyhunauLib 接口
public class HunauCacheProxy implements ThirdPartyhunauLib {
    // 使用 ThirdPartyhunauLib 接口作为被代理的服务
    private ThirdPartyhunauLib hunauService;
    // 视频缓存
    private HashMap<String, Video> cacheAll = new HashMap<String, Video>();

    // 构造方法
    public HunauCacheProxy() {
        // 初始化 hunauService 为 ThirdPartyhunauClass 的实例
        hunauService = new ThirdPartyhunauClass();
    }

    // 实现接口中的获取视频方法
    @Override
    public Video getVideo(String videoId) {
        // 从缓存中获取视频
        Video video = cacheAll.get(videoId);
        if (video == null) {
            // 如果缓存中没有视频，则调用 hunauService 的 getVideo 方法获取视频，并将其放入缓存
            video = hunauService.getVideo(videoId);
            cacheAll.put(videoId, video);
        } else {
            // 如果缓存中有视频，则直接从缓存中获取
            System.out.println("Retrieved video '" + videoId + "' from cache.");
        }
        return video;
    }

    // 重置缓存
    public void reset() {
        cacheAll.clear();
    }
}

测试类

package step1;

// 创建一个 HunauDownloader 类用于渲染视频页面
public class HunauDownloader {
    // 使用 ThirdPartyhunauLib 接口作为 API
    private ThirdPartyhunauLib api;

    // 构造方法，接收一个 ThirdPartyhunauLib 对象作为参数
    public HunauDownloader(ThirdPartyhunauLib api) {
        this.api = api;
    }

    // 渲染视频页面的方法
    public void renderVideoPage(String videoId) {
        // 调用 API 的 getVideo 方法获取视频信息
        Video video = api.getVideo(videoId);
        // 打印视频页面信息
        System.out.println("\n-------------------------------");
        System.out.println("Video page (imagine fancy HTML)");
        System.out.println("ID: " + video.id);
        System.out.println("Title: " + video.title);
        System.out.println("Video: " + video.data);
        System.out.println("-------------------------------\n");
    }
}

package step1;

// 创建一个客户端类
public class Client {
    public static void main(String[] args) {
        // 创建一个 HunauDownloader 对象，并将其构造方法的参数设置为 HunauCacheProxy 对象
        HunauDownloader smartDownloader = new HunauDownloader(new HunauCacheProxy());
        // 调用 HunauDownloader 对象的 renderVideoPage 方法渲染视频页面
        smartDownloader.renderVideoPage("catzzzzzzzzz");
        smartDownloader.renderVideoPage("dancesvideoo");
        smartDownloader.renderVideoPage("catzzzzzzzzz");
        smartDownloader.renderVideoPage("catzzzzzzzzz");
    }
}

烟雨平生9527

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
万字解析设计模式之代理模式

代理模式是一种结构型设计模式，它允许通过创建代理对象来控制对其他对象的访问。这种模式可以增加一些额外的逻辑来控制对原始对象的访问，同时还可以提供更加灵活的访问方式。代理模式分为静态代理和动态代理两种。是在编译时就确定代理对象和目标对象的关系，由程序员手动编写代理类；是在运行时根据接口动态生成代理对象，无需手动编写代理类。静态代理代理类在编译期就生成，而动态代理代理类则是在Java运行时动态生成。动态代理又有两种。代理模式可以用于实现对象的远程访问、权限控制、性能优化等功能。
复制链接

扫一扫