java设计模式：03-07-代理模式

Mr_Air_Boy2024-07-23 13:07

代理模式（Proxy Pattern）

代理模式（Proxy Pattern）是一种结构型设计模式，它为其他对象提供一种代理以控制对这个对象的访问。代理模式通过创建一个代理对象来控制对实际对象的访问，通常用于在访问实际对象时增加额外的功能或进行额外的处理。

代理模式的应用场景

  • 远程代理（Remote Proxy）：为一个对象在不同地址空间提供局部代表。远程代理可以隐藏一个对象存在于不同地址空间的事实。
  • 虚代理（Virtual Proxy）：根据需要创建开销较大的对象。虚代理可以缓存一个真实对象的实例，并在需要时创建它。
  • 保护代理（Protection Proxy）：控制对原始对象的访问。保护代理可以在访问真实对象之前进行权限检查。
  • 智能引用（Smart Reference）：取代了简单的指针，它在访问对象时执行一些附加操作，如计算一个对象被引用的次数。

代理模式的实现方式

1. 静态代理

思想：通过代理类实现与目标类相同的接口，并在代理类的方法中调用目标类的方法。

实现方式：

java 复制代码 
// 抽象接口
interface Subject {
    void request();
}

// 真实对象
class RealSubject implements Subject {
    public void request() {
        System.out.println("RealSubject request");
    }
}

// 代理对象
class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy() {
        this.realSubject = new RealSubject();
    }

    public void request() {
        System.out.println("Proxy before request");
        realSubject.request();
        System.out.println("Proxy after request");
    }
}

// 客户端代码
public class StaticProxyPattern {
    public static void main(String[] args) {
        Subject proxy = new Proxy();
        proxy.request();
    }
}

优点：

  • 控制访问：代理可以在调用真实对象前后进行额外处理，增加控制逻辑。
  • 分离职责：将真实对象的核心功能和代理对象的控制逻辑分离开来，符合单一职责原则。

缺点：

  • 代码冗余：为每个真实对象都要创建一个代理类，导致代码量增加。
  • 灵活性差：静态代理需要为每个接口或类创建代理类，增加维护成本。
2. 动态代理

思想 ：在运行时创建代理对象，而不是在编译时创建。Java中的动态代理可以使用 java.lang.reflect.Proxy 类来实现。

实现方式：

java 复制代码 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 抽象接口
interface Subject {
    void request();
}

// 真实对象
class RealSubject implements Subject {
    public void request() {
        System.out.println("RealSubject request");
    }
}

// 动态代理处理器
class ProxyHandler implements InvocationHandler {
    private Object realSubject;

    public ProxyHandler(Object realSubject) {
        this.realSubject = realSubject;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Proxy before request");
        Object result = method.invoke(realSubject, args);
        System.out.println("Proxy after request");
        return result;
    }
}

// 客户端代码
public class DynamicProxyPattern {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        Subject proxy = (Subject) Proxy.newProxyInstance(
            realSubject.getClass().getClassLoader(),
            realSubject.getClass().getInterfaces(),
            new ProxyHandler(realSubject)
        );
        proxy.request();
    }
}

优点：

  • 减少代码量：不需要为每个真实对象都创建代理类，减少代码冗余。
  • 灵活性高：可以在运行时动态创建代理对象，增强系统的灵活性和可扩展性。

缺点：

  • 性能开销：反射机制的使用会导致一定的性能开销，特别是在大量调用时。
  • 调试困难：由于代理对象是在运行时动态生成的，调试和排查问题较为困难。

总结

实现方式 优点 缺点
静态代理 控制访问，分离职责 代码冗余，灵活性差
动态代理 减少代码量，灵活性高 性能开销，调试困难

选择哪种实现方式应根据具体的需求和系统的复杂度来决定。如果系统中代理类数量较少，可以选择静态代理。如果需要动态生成代理对象并且系统的灵活性要求较高，可以选择动态代理。

应用场景实现

代理模式在不同的应用场景中可以采用不同的实现方式。下面分别实现远程代理、虚代理、保护代理和智能引用的例子，并说明各个方式的思想和优劣。

1. 远程代理 (Remote Proxy)

思想：远程代理用于隐藏一个对象存在于不同地址空间的事实。远程代理可以用于本地客户端与远程服务器之间的通信。

实现方式：

java 复制代码 
// 抽象接口
interface Subject {
    void request();
}

// 远程服务接口（假设这是远程服务）
interface RemoteService {
    void remoteRequest();
}

// 远程服务实现（模拟远程服务）
class RemoteServiceImpl implements RemoteService {
    public void remoteRequest() {
        System.out.println("Remote service request");
    }
}

// 远程代理
class RemoteProxy implements Subject {
    private RemoteService remoteService;

    public RemoteProxy(RemoteService remoteService) {
        this.remoteService = remoteService;
    }

    public void request() {
        System.out.println("Proxy: forwarding request to remote service...");
        remoteService.remoteRequest();
    }
}

// 客户端代码
public class RemoteProxyPattern {
    public static void main(String[] args) {
        RemoteService remoteService = new RemoteServiceImpl();
        Subject proxy = new RemoteProxy(remoteService);
        proxy.request();
    }
}

优点：

  • 隐藏复杂性：客户端不需要了解远程调用的细节，只需通过代理进行操作。
  • 提高系统的可扩展性：可以轻松地添加新的远程服务。

缺点：

  • 性能开销：网络通信的开销可能较大，影响性能。
  • 失败风险：网络的不稳定性可能导致远程调用失败。

2. 虚代理 (Virtual Proxy)

思想：虚代理用于根据需要创建开销较大的对象。虚代理可以延迟对象的创建，节省资源。

实现方式：

java 复制代码 
// 抽象接口
interface Image {
    void display();
}

// 真实对象
class RealImage implements Image {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadFromDisk();
    }

    private void loadFromDisk() {
        System.out.println("Loading " + filename);
    }

    public void display() {
        System.out.println("Displaying " + filename);
    }
}

// 虚代理
class ProxyImage implements Image {
    private RealImage realImage;
    private String filename;

    public ProxyImage(String filename) {
        this.filename = filename;
    }

    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

// 客户端代码
public class VirtualProxyPattern {
    public static void main(String[] args) {
        Image image = new ProxyImage("test.jpg");
        // Image will be loaded from disk
        image.display();
        // Image will not be loaded from disk
        image.display();
    }
}

优点：

  • 延迟加载：延迟创建开销较大的对象，节省资源。
  • 节省内存：避免不必要的对象创建，节省内存。

缺点：

  • 代码复杂度增加：引入代理模式后，代码变得更复杂。
  • 第一次访问性能开销：第一次访问时仍需创建真实对象，有一定的性能开销。

3. 保护代理 (Protection Proxy)

思想：保护代理用于控制对真实对象的访问。保护代理可以在访问真实对象之前进行权限检查。

实现方式：

java 复制代码 
// 抽象接口
interface Document {
    void display();
}

// 真实对象
class RealDocument implements Document {
    private String content;

    public RealDocument(String content) {
        this.content = content;
    }

    public void display() {
        System.out.println("Displaying document: " + content);
    }
}

// 保护代理
class ProtectionProxy implements Document {
    private RealDocument realDocument;
    private String userRole;

    public ProtectionProxy(String userRole, String content) {
        this.userRole = userRole;
        this.realDocument = new RealDocument(content);
    }

    public void display() {
        if ("admin".equals(userRole)) {
            realDocument.display();
        } else {
            System.out.println("Access denied. Insufficient permissions.");
        }
    }
}

// 客户端代码
public class ProtectionProxyPattern {
    public static void main(String[] args) {
        Document document = new ProtectionProxy("admin", "Sensitive content");
        document.display();

        Document document2 = new ProtectionProxy("user", "Sensitive content");
        document2.display();
    }
}

优点：

  • 控制访问：可以在访问真实对象之前进行权限检查，确保安全性。
  • 分离职责：将权限检查和核心功能分离开来，符合单一职责原则。

缺点：

  • 增加代码复杂性：引入权限检查逻辑后，代码变得更复杂。
  • 可能影响性能：权限检查可能带来一定的性能开销。

4. 智能引用 (Smart Reference)

思想：智能引用在访问对象时执行一些附加操作，如计算对象被引用的次数或进行垃圾回收等。

实现方式：

java 复制代码 
// 抽象接口
interface Subject {
    void request();
}

// 真实对象
class RealSubject implements Subject {
    public void request() {
        System.out.println("RealSubject request");
    }
}

// 智能引用代理
class SmartReferenceProxy implements Subject {
    private RealSubject realSubject;
    private int referenceCount;

    public SmartReferenceProxy() {
        this.realSubject = new RealSubject();
        this.referenceCount = 0;
    }

    public void request() {
        referenceCount++;
        System.out.println("Reference count: " + referenceCount);
        realSubject.request();
    }
}

// 客户端代码
public class SmartReferenceProxyPattern {
    public static void main(String[] args) {
        Subject proxy = new SmartReferenceProxy();
        proxy.request();
        proxy.request();
    }
}

优点：

  • 附加操作：可以在访问对象时执行附加操作，如引用计数、缓存等。
  • 增强功能：智能引用代理可以为真实对象提供额外的功能。

缺点：

  • 增加代码复杂性：附加操作增加了代码的复杂性。
  • 可能影响性能：附加操作可能带来一定的性能开销。

总结

代理模式 优点 缺点
远程代理 隐藏远程调用的复杂性，提高系统的可扩展性 网络通信开销大，失败风险高
虚代理 延迟加载，节省资源和内存 代码复杂度增加，第一次访问性能开销
保护代理 控制访问，分离职责，确保安全性 增加代码复杂性，可能影响性能
智能引用 附加操作，增强功能 增加代码复杂性，可能影响性能

选择哪种实现方式应根据具体的需求和系统的复杂度来决定。如果需要控制远程访问，可以选择远程代理。如果需要延迟加载对象，可以选择虚代理。如果需要控制访问权限，可以选择保护代理。如果需要在访问对象时执行附加操作，可以选择智能引用代理。

相关推荐
喵叔哟15 分钟前
重构代码中引入外部方法和引入本地扩展的区别
java·开发语言·重构
尘浮生21 分钟前
Java项目实战II基于微信小程序的电影院买票选座系统（开发文档+数据库+源码）
java·开发语言·数据库·微信小程序·小程序·maven·intellij-idea
闲人一枚（学习中）28 分钟前
设计模式-创建型-抽象工厂模式
设计模式·抽象工厂模式
不是二师兄的八戒44 分钟前
本地 PHP 和 Java 开发环境 Docker 化与配置开机自启
java·docker·php
爱编程的小生1 小时前
Easyexcel（2-文件读取）
java·excel
带多刺的玫瑰1 小时前
Leecode刷题C语言之统计不是特殊数字的数字数量
java·c语言·算法
计算机毕设指导62 小时前
基于 SpringBoot 的作业管理系统【附源码】
java·vue.js·spring boot·后端·mysql·spring·intellij-idea
Gu Gu Study2 小时前
枚举与lambda表达式，枚举实现单例模式为什么是安全的，lambda表达式与函数式接口的小九九~
java·开发语言
Chris _data2 小时前
二叉树oj题解析
java·数据结构
牙牙7052 小时前
Centos7安装Jenkins脚本一键部署
java·servlet·jenkins
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07怎样让音频速度变慢？请跟随以下方法进行操作08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10【目标跟踪】相机运动补偿