持续总结中！2024年面试必问 20 道设计模式面试题（五）

本文链接：https://blog.csdn.net/2401_84542969/article/details/139813016

上一篇地址：持续总结中！2024年面试必问 20 道设计模式面试题（四）-CSDN博客

九、请解释代理模式（Proxy Pattern）及其类型。

代理模式（Proxy Pattern）是一种结构设计模式，它为另一个对象提供一个代替或占位符的对象，以便控制对它的访问。代理模式可以在不直接与实际对象交互的情况下，提供对目标对象的间接访问。这种模式在以下情况下非常有用：

当需要对目标对象的访问进行控制时。
当需要在访问对象时执行额外的操作，如延迟初始化、访问前的权限检查等。
当需要为远程对象或复杂对象提供一种更简单的接口时。

代理模式的组成部分：

主题接口（Subject Interface）：定义了真实对象和代理对象的共同接口，这样代理可以代替真实对象被使用。
真实主题（Real Subject）：定义了代理所代表的真实对象，实现了主题接口。
代理（Proxy）：包含对真实主题的引用，实现了相同的主题接口，并控制对真实主题的访问。

代理模式的类型：

远程代理（Remote Proxy）：为位于不同地址空间的对象提供代理，隐藏对象位于远程地址空间的事实。它通常用在分布式系统中。
虚拟代理（Virtual Proxy）：延迟创建开销较大的对象。当第一次需要时，虚拟代理会加载并初始化真实对象。
保护代理（Protection Proxy）：控制对原始对象的访问，根据不同的访问权限提供不同的访问策略。
智能引用（Smart Reference）：在访问对象时执行额外的操作，如引用计数、线程安全检查等。
缓存代理（Caching Proxy）：为开销较大的操作结果提供存储，当同样的操作请求发生时，可以直接使用缓存结果，避免重复计算。
同步代理（Synchronization Proxy）：为多个线程提供同步访问某个对象的代理，确保在同一时间只有一个线程可以访问对象。
防火墙代理（Firewall Proxy）：在网络中控制对某些资源的访问，提供安全控制。
复制代理（Copy Proxy）：在复制一个复杂对象时，复制代理可以优化复制过程，例如按需复制。

示例：

假设我们有一个大型图像处理对象，我们希望延迟其加载，直到真正需要显示图像时。使用虚拟代理模式，我们可以这样实现：

// 主题接口
interface ImageLoader {
    void load();
    void display();
}

// 真实主题
class RealImageLoader implements ImageLoader {
    private String imagePath;

    public RealImageLoader(String imagePath) {
        this.imagePath = imagePath;
    }

    @Override
    public void load() {
        System.out.println("Loading image from " + imagePath);
    }

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

// 代理
class ImageProxy implements ImageLoader {
    private RealImageLoader realImageLoader;
    private String imagePath;

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

    @Override
    public void load() {
        if (realImageLoader == null) {
            realImageLoader = new RealImageLoader(imagePath);
            realImageLoader.load();
        }
    }

    @Override
    public void display() {
        if (realImageLoader != null) {
            realImageLoader.display();
        }
    }
}

// 客户端代码
ImageLoader imageLoader = new ImageProxy("path/to/image.jpg");
imageLoader.display(); // 此时才加载图像

在这个例子中，ImageProxy 类作为 RealImageLoader 的代理，延迟了图像的加载过程，直到 display() 方法被调用时才真正加载图像。这展示了代理模式如何用于控制对资源的访问和执行延迟初始化。

十、什么是命令模式（Command Pattern）？它在实际开发中如何使用？

命令模式（Command Pattern）是一种行为设计模式，它将请求或操作封装为一个对象。这种模式的主要目的是将发起请求的对象（调用者）与执行请求的对象（接收者）解耦，从而让不同的请求可以以统一的方式处理，例如执行、排队、记录日志或撤销等。

命令模式的组成部分：

命令接口（Command Interface）：声明执行操作的方法，通常是一个 execute() 方法。
具体命令（Concrete Command）：实现命令接口，对应具体的操作，包含接收者对象的引用，并调用接收者的方法。
调用者（Invoker）：要求命令对象执行请求，通常包含一个或多个命令对象，并可以触发命令的执行。
接收者（Receiver）：知道如何实施与执行一个请求相关的操作，不直接与调用者或命令对象交互。
客户端（Client）：创建具体的命令对象，并设置它的接收者，然后将命令对象传给调用者。

命令模式在实际开发中的使用：

撤销操作：命令模式可以很容易地实现撤销功能。通过维护一个命令的历史记录，可以逐个撤销命令的效果。
日志记录：命令对象可以被用来记录操作历史，这对于审计和调试非常有用。
事务支持：命令模式可以支持事务性操作，确保一系列命令作为一个整体被执行或回滚。
宏命令：可以将多个命令组合成一个宏命令，作为一个单独的操作执行。
异步命令执行：命令模式可以用于实现异步操作，命令对象可以被发送到一个后台线程执行。
安全性：通过命令模式，可以控制哪些操作可以被执行，哪些不可以，从而提高系统的安全性。

示例：

假设我们有一个简单的文本编辑器，它支持撤销插入文本的操作。使用命令模式，我们可以这样实现：

// 命令接口
interface Command {
    void execute();
    void undo();
}

// 接收者
class TextEditor {
    private StringBuilder content = new StringBuilder();

    public void type(String words) {
        content.append(words);
    }

    public void remove(int numberOfChars) {
        content.delete(content.length() - numberOfChars, content.length());
    }

    public String getContent() {
        return content.toString();
    }
}

// 具体命令
class InsertCommand implements Command {
    private TextEditor editor;
    private String words;
    private int position;

    public InsertCommand(TextEditor editor, String words) {
        this.editor = editor;
        this.words = words;
        this.position = editor.getContent().length();
    }

    @Override
    public void execute() {
        editor.type(words);
    }

    @Override
    public void undo() {
        editor.remove(words.length());
    }
}

// 调用者
class CommandInvoker {
    private Stack<Command> commandHistory = new Stack<>();

    public void setCommand(Command command) {
        command.execute();
        commandHistory.push(command);
    }

    public void undo() {
        if (!commandHistory.isEmpty()) {
            Command command = commandHistory.pop();
            command.undo();
        }
    }
}

// 客户端代码
TextEditor editor = new TextEditor();
CommandInvoker invoker = new CommandInvoker();

invoker.setCommand(new InsertCommand(editor, "Hello"));
invoker.setCommand(new InsertCommand(editor, " World"));
System.out.println(editor.getContent()); // 输出: Hello World

invoker.undo(); // 撤销插入 " World"
System.out.println(editor.getContent()); // 输出: Hello

在这个例子中，InsertCommand 是一个具体命令，它封装了插入文本的操作。TextEditor 是接收者，执行实际的文本插入和删除操作。CommandInvoker 是调用者，它维护了一个命令的历史记录，并可以执行撤销操作。客户端代码通过调用者来执行命令和撤销操作，展示了命令模式如何在实际开发中使用。