Bootstrap

【软件设计】常用设计模式--代理模式

文章目录

代理模式（Proxy Pattern）

1. 概念

代理模式是一种结构型设计模式，它为另一个对象提供了一个替身或占位符，以控制对该对象的访问。代理可以代替原对象执行操作、控制访问权限、延迟加载等。这种模式的关键在于代理对象和被代理对象实现相同的接口，以确保它们可以互换。

2. 模式结构

代理模式的核心角色包括：

  • 主题（Subject）：定义了代理对象和真实对象的公共接口。
  • 真实主题（RealSubject）：实际的业务逻辑类，代理对象通过控制对它的访问来扩展功能。
  • 代理（Proxy）：持有对 RealSubject 的引用，并可以在调用前后对其操作进行控制或扩展。

3. UML 类图
Subject
+Request()
Proxy
+ RealSubject: Subject
+Request()
RealSubject
+Request()

4.实现方式

C# 示例

步骤1：定义主题接口
public interface ISubject
{
    void Request();
}
步骤2：实现真实主题
public class RealSubject : ISubject
{
    public void Request()
    {
        Console.WriteLine("RealSubject: Handling Request.");
    }
}
步骤3：实现代理类
public class Proxy : ISubject
{
    private RealSubject _realSubject;

    public void Request()
    {
        if (_realSubject == null)
        {
            _realSubject = new RealSubject();
        }
        Console.WriteLine("Proxy: Controlling access before forwarding the request.");
        _realSubject.Request();
    }
}
步骤4：客户端使用代理模式
class Program
{
    static void Main(string[] args)
    {
        ISubject proxy = new Proxy();
        proxy.Request();
    }
}
输出结果：
Proxy: Controlling access before forwarding the request.
RealSubject: Handling Request.

Java 示例

步骤1：定义主题接口
public interface Subject {
    void request();
}
步骤2：实现真实主题
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}
步骤3：实现代理类
public class Proxy implements Subject {
    private RealSubject realSubject;

    @Override
    public void request() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        System.out.println("Proxy: Controlling access before forwarding the request.");
        realSubject.request();
    }
}
步骤4：客户端使用代理模式
public class Main {
    public static void main(String[] args) {
        Subject proxy = new Proxy();
        proxy.request();
    }
}
输出结果：
Proxy: Controlling access before forwarding the request.
RealSubject: Handling request.

5. 代理模式的类型

5.1 虚拟代理

虚拟代理用于控制资源密集型对象的实例化，常用于延迟加载（Lazy Initialization）场景。代理类在实际使用时才实例化真实对象，从而节省系统资源。

  • 示例：当一个图像很大且加载时间较长时，使用虚拟代理可以延迟图像的加载，只有当图像真正需要显示时才进行加载。
public class ImageProxy : IImage
{
    private RealImage _realImage;
    private string _fileName;

    public ImageProxy(string fileName)
    {
        _fileName = fileName;
    }

    public void Display()
    {
        if (_realImage == null)
        {
            _realImage = new RealImage(_fileName);
        }
        _realImage.Display();
    }
}

5.2 远程代理

远程代理为位于不同地址空间的对象（如通过网络通信的对象）提供代理。客户端通过代理访问远程服务器上的对象，而不直接处理复杂的通信逻辑。

  • 示例：当客户端需要访问远程的Web服务或数据库时，使用远程代理可以将网络通信的复杂性隐藏在代理类中。
实现步骤
步骤1：定义主题接口

与真实对象和代理对象共享相同的接口，以便客户端可以通过代理访问。

public interface Subject {
    void request();
}
步骤2：实现真实主题

真实对象实现了主题接口，并包含了实际的业务逻辑。

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}
步骤3：实现远程代理

远程代理通常会处理网络通信的细节，比如使用HTTP、Socket等。它会将请求发送到远程服务器，接收响应并返回给客户端。

import java.io.*;
import java.net.*;

public class RemoteProxy implements Subject {
    private String serverAddress;

    public RemoteProxy(String serverAddress) {
        this.serverAddress = serverAddress;
    }

    @Override
    public void request() {
        try {
            Socket socket = new Socket(serverAddress, 8080);
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

            out.println("Request from Remote Proxy");
            String response = in.readLine();
            System.out.println("Response from Real Subject: " + response);

            in.close();
            out.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
步骤4：客户端使用远程代理

客户端通过远程代理调用真实主题的功能。

public class Client {
    public static void main(String[] args) {
        Subject proxy = new RemoteProxy("localhost");
        proxy.request();
    }
}

服务器端示例
服务器端接收请求并返回响应：

import java.io.*;
import java.net.*;

public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("Server is running...");

        while (true) {
            Socket clientSocket = serverSocket.accept();
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

            String request = in.readLine();
            System.out.println("Received: " + request);
            out.println("Handled by Real Subject");

            in.close();
            out.close();
            clientSocket.close();
        }
    }
}

5.3 保护代理

保护代理用于控制对原始对象的访问，主要是限制某些客户端的权限。代理会根据访问者的权限决定是否可以访问真实对象。

  • 示例：在访问控制系统中，代理可以根据用户的角色决定是否授予对特定资源的访问权。
public class ProtectedProxy : ISubject
{
    private RealSubject _realSubject;
    private string _userRole;

    public ProtectedProxy(string userRole)
    {
        _userRole = userRole;
    }

    public void Request()
    {
        if (_userRole == "Admin")
        {
            _realSubject = new RealSubject();
            _realSubject.Request();
        }
        else
        {
            Console.WriteLine("Access Denied: You don't have permission to perform this operation.");
        }
    }
}

5.4 智能代理

智能代理可以在真实对象操作的前后执行一些附加操作，例如记录日志、统计调用次数、缓存结果等。

  • 示例：在Web应用程序中，智能代理可以用于记录每个请求的处理时间。
public class LoggingProxy : ISubject
{
    private RealSubject _realSubject;

    public void Request()
    {
        Console.WriteLine("Logging: Before executing the request.");
        if (_realSubject == null)
        {
            _realSubject = new RealSubject();
        }
        _realSubject.Request();
        Console.WriteLine("Logging: After executing the request.");
    }
}
实现步骤
步骤1：定义主题接口

与之前相同，定义一个公共接口。


public interface Subject {
    void request();
}
步骤2：实现真实主题

实现主题接口的真实对象。

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}
步骤3：实现智能代理

智能代理在调用真实对象的请求方法前后执行一些附加操作，比如记录日志或计算执行时间。

public class SmartProxy implements Subject {
    private RealSubject realSubject;

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

    @Override
    public void request() {
        System.out.println("SmartProxy: Logging before request.");
        long startTime = System.currentTimeMillis();
        
        realSubject.request();
        
        long endTime = System.currentTimeMillis();
        System.out.println("SmartProxy: Logging after request. Execution time: " + (endTime - startTime) + " ms");
    }
}
步骤4：客户端使用智能代理

客户端通过智能代理调用真实主题。

public class Client {
    public static void main(String[] args) {
        Subject proxy = new SmartProxy();
        proxy.request();
    }
}

5.5 应用场景

远程代理
场景：在分布式系统中，客户端需要访问远程服务，远程代理负责处理网络通信和请求转发。
应用：RPC（远程过程调用）、RESTful API等场景。
智能代理
场景：需要对方法调用进行监控、统计或其他增强功能，智能代理可以提供附加的处理逻辑。
应用：日志记录、性能监控、缓存管理等场景。

6. 优点

  • 控制对象访问：代理模式可以控制对真实对象的访问，添加权限控制、延迟加载、网络通信等功能。
  • 节省系统资源：虚拟代理可以在对象真正需要时才创建，从而节省资源。
  • 增强功能：代理可以在真实对象执行操作前后添加额外的功能，如日志记录、缓存等。

7. 缺点

  • 增加复杂性：由于引入了代理类，系统变得更加复杂，增加了类的数量。
  • 性能开销：代理可能导致额外的开销，特别是在处理远程调用或过度使用智能代理时。

8. 代理模式应用场景

  • 远程代理：当需要访问远程对象时，可以使用远程代理隐藏通信的细节。
  • 虚拟代理：当需要延迟加载资源密集型对象时，可以使用虚拟代理。
  • 访问控制：当需要控制对某些资源或对象的访问权限时，保护代理是一个理想的选择。
  • 性能优化：使用智能代理可以在不改变原有业务逻辑的情况下，优化性能或增加功能。

9.代理模式变体

9.1 虚拟代理（Virtual Proxy）

虚拟代理用于延迟加载资源密集型对象的实例化，直到需要时才创建真实对象。这样可以节省系统资源，避免不必要的开销。

实现步骤
步骤1：定义主题接口
public interface Image {
    void display();
}
步骤2：实现真实主题
public class RealImage implements Image {
    private String fileName;

    public RealImage(String fileName) {
        this.fileName = fileName;
        loadImageFromDisk();
    }

    private void loadImageFromDisk() {
        System.out.println("Loading " + fileName);
    }

    @Override
    public void display() {
        System.out.println("Displaying " + fileName);
    }
}
步骤3：实现虚拟代理
public class ImageProxy implements Image {
    private RealImage realImage;
    private String fileName;

    public ImageProxy(String fileName) {
        this.fileName = fileName;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(fileName);
        }
        realImage.display();
    }
}
步骤4：客户端使用虚拟代理
public class Client {
    public static void main(String[] args) {
        Image image = new ImageProxy("test_image.jpg");
        image.display(); // 只在此处加载
        image.display(); // 直接显示，不再加载
    }
}
应用场景
  • 适用于需要加载大型对象的场景，例如图像、视频等。
  • 在图形界面应用中，通常使用虚拟代理来延迟加载图形组件。

9.2 保护代理（Protection Proxy）

保护代理控制对真实对象的访问，主要用于权限管理。它根据客户端的身份或角色决定是否允许访问真实对象。

实现步骤
步骤1：定义主题接口
public interface Document {
    void view();
}
步骤2：实现真实主题
public class RealDocument implements Document {
    @Override
    public void view() {
        System.out.println("Viewing Document");
    }
}
步骤3：实现保护代理
public class ProtectionProxy implements Document {
    private RealDocument realDocument;
    private String userRole;

    public ProtectionProxy(String userRole) {
        this.userRole = userRole;
    }

    @Override
    public void view() {
        if (userRole.equals("Admin")) {
            if (realDocument == null) {
                realDocument = new RealDocument();
            }
            realDocument.view();
        } else {
            System.out.println("Access Denied: You do not have permission to view this document.");
        }
    }
}
步骤4：客户端使用保护代理
public class Client {
    public static void main(String[] args) {
        Document doc = new ProtectionProxy("User");
        doc.view(); // Access Denied

        Document adminDoc = new ProtectionProxy("Admin");
        adminDoc.view(); // Access Granted
    }
}
应用场景
  • 适用于敏感数据或操作，需要根据用户权限控制访问的场景。
  • 在企业级应用中常见，用于控制对重要文档或资源的访问。

9.3 缓存代理（Caching Proxy）

缓存代理在调用真实对象的方法前检查是否已经缓存了结果。如果有，则直接返回缓存结果，否则调用真实对象并将结果存入缓存。

实现步骤
步骤1：定义主题接口
public interface Data {
    String fetchData();
}
步骤2：实现真实主题
public class RealData implements Data {
    @Override
    public String fetchData() {
        return "Data from Real Data Source";
    }
}
步骤3：实现缓存代理
import java.util.HashMap;

public class CachingProxy implements Data {
    private RealData realData;
    private HashMap<String, String> cache;

    public CachingProxy() {
        this.realData = new RealData();
        this.cache = new HashMap<>();
    }

    @Override
    public String fetchData() {
        if (cache.containsKey("data")) {
            System.out.println("Returning cached data.");
            return cache.get("data");
        }
        String data = realData.fetchData();
        cache.put("data", data);
        return data;
    }
}
步骤4：客户端使用缓存代理
public class Client {
    public static void main(String[] args) {
        Data dataProxy = new CachingProxy();
        System.out.println(dataProxy.fetchData()); // First call fetches data
        System.out.println(dataProxy.fetchData()); // Subsequent call returns cached data
    }
}
应用场景
  • 适用于数据查询频繁但变化不大的场景，例如Web应用中的数据库查询结果。
  • 可以显著提高性能，减少对真实数据源的调用次数。

10.总结

代理模式在控制对象访问和增强系统功能方面提供了很大的灵活性，且每种变体都有其独特的用处，需要根据需求进行选择和实施。

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
利用css旋转将横着的长方形盒子变成竖着的
SSH是什么？GIT码云如何配置SSH密钥？
N5095怎么样？放到现在还能“存活”吗？
Android获取拓展外置SD卡（可插拔）路径及读写外置SD卡的方法
webug4.0-ssrf
进来教你如何解决端口被占用问题
springboot的hibernate注解配置详解
Diffusers代码学习: PixArt-Σ
Android 系统签名
学习使用js判断当前页面是否是钉钉打开
;