当前位置：首页 > article >正文

设计模式之代理模式：原理、实现与应用

article 2025/3/20 14:55:34

引言

代理模式（Proxy Pattern）是一种结构型设计模式，它通过提供一个代理对象来控制对另一个对象的访问。代理模式可以在不改变原始对象的情况下，增加额外的功能或控制访问。本文将深入探讨代理模式的原理、实现方式以及实际应用场景，帮助你更好地理解和使用这一设计模式。

1. 代理模式的核心概念

1.1 什么是代理模式？

代理模式是一种结构型设计模式，它通过提供一个代理对象来控制对另一个对象的访问。代理模式可以在不改变原始对象的情况下，增加额外的功能或控制访问。

1.2 代理模式的应用场景

远程代理：为远程对象提供一个本地代理，隐藏远程调用的复杂性。
虚拟代理：延迟创建开销较大的对象，直到真正需要时才创建。
保护代理：控制对敏感对象的访问，增加权限检查。
智能引用：在访问对象时执行额外的操作，如引用计数、懒加载等。

2. 代理模式的实现方式

2.1 基本结构

代理模式通常包含以下几个角色：

抽象主题（Subject）：定义真实主题和代理主题的共同接口。
真实主题（Real Subject）：实现抽象主题接口，是代理对象所代表的真实对象。
代理主题（Proxy）：实现抽象主题接口，并持有对真实主题的引用，控制对真实主题的访问。

2.2 代码示例

// 抽象主题
public interface Subject {
    void request();
}

// 真实主题
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject request");
    }
}

// 代理主题
public class Proxy implements Subject {
    private RealSubject realSubject;

    @Override
    public void request() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        preRequest();
        realSubject.request();
        postRequest();
    }

    private void preRequest() {
        System.out.println("Proxy preRequest");
    }

    private void postRequest() {
        System.out.println("Proxy postRequest");
    }
}

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

3. 代理模式的最佳实践

3.1 控制访问

权限控制：通过代理模式控制对敏感对象的访问，增加权限检查。
延迟加载：通过代理模式延迟创建开销较大的对象，直到真正需要时才创建。

3.2 增加功能

额外操作：通过代理模式在访问对象时执行额外的操作，如日志记录、性能监控等。
透明性：代理模式使得客户端无需关心代理对象的存在，保持透明性。

3.3 遵循开闭原则

扩展性：通过代理模式，可以在不修改现有代码的情况下扩展系统。
灵活性：代理模式使得代码更加灵活，易于维护和扩展。

4. 代理模式的实际应用

4.1 远程代理

在远程代理中，代理对象隐藏了远程调用的复杂性，使得客户端可以像调用本地对象一样调用远程对象。

// 抽象主题
public interface RemoteService {
    void execute();
}

// 真实主题
public class RemoteServiceImpl implements RemoteService {
    @Override
    public void execute() {
        System.out.println("RemoteService executed");
    }
}

// 代理主题
public class RemoteServiceProxy implements RemoteService {
    private RemoteService remoteService;

    @Override
    public void execute() {
        if (remoteService == null) {
            remoteService = new RemoteServiceImpl();
        }
        System.out.println("RemoteServiceProxy preExecute");
        remoteService.execute();
        System.out.println("RemoteServiceProxy postExecute");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        RemoteService proxy = new RemoteServiceProxy();
        proxy.execute();
    }
}

4.2 虚拟代理

在虚拟代理中，代理对象延迟创建开销较大的对象，直到真正需要时才创建。

// 抽象主题
public interface Image {
    void display();
}

// 真实主题
public class RealImage implements Image {
    private String filename;

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

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

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

// 代理主题
public class ProxyImage implements Image {
    private String filename;
    private RealImage realImage;

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Image image = new ProxyImage("test.jpg");
        image.display();
    }
}

4.3 保护代理

在保护代理中，代理对象控制对敏感对象的访问，增加权限检查。

// 抽象主题
public interface SensitiveData {
    void access();
}

// 真实主题
public class SensitiveDataImpl implements SensitiveData {
    @Override
    public void access() {
        System.out.println("Accessing sensitive data");
    }
}

// 代理主题
public class SensitiveDataProxy implements SensitiveData {
    private SensitiveData sensitiveData;
    private String userRole;

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

    @Override
    public void access() {
        if (userRole.equals("Admin")) {
            if (sensitiveData == null) {
                sensitiveData = new SensitiveDataImpl();
            }
            sensitiveData.access();
        } else {
            System.out.println("Access denied");
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        SensitiveData proxy = new SensitiveDataProxy("User");
        proxy.access();

        SensitiveData adminProxy = new SensitiveDataProxy("Admin");
        adminProxy.access();
    }
}