设计模式行为模式-命令模式

前言

定义

命令模式（Command Pattern）是一种行为型设计模式，用于将请求封装为对象，从而使你可以使用不同的请求、队列或者日志请求来参数化其他对象。这样可以实现请求的参数化操作、队列化和日志化，且能够支持撤销操作。

结构

命令模式由以下几个核心组件组成：

• 命令（Command）: 定义了执行操作的接口。通常包含一个 execute() 方法，该方法在调用时会触发接收者执行相关操作。
• 具体命令（Concrete Command）：实现命令接口，并将真正的操作委托给接收者。
• 接收者（Receiver）：负责执行实际的操作。具体命令将请求委托给接收者完成具体的业务逻辑。
• 调用者（Invoker）：负责调用命令并触发执行操作的方法。
• 客户端（Client）：创建具体命令，并将其与接收者进行绑定。
  

工作原理

1. 客户端创建一个具体命令，并将其与接收者（执行操作的对象）进行绑定。
2. 调用者接收到命令后，将其存储起来，可以将命令存储在队列中，以支持撤销和重做操作。
3. 调用者根据需要调用命令的 execute() 方法。该方法会将请求传递给接收者，由接收者执行实际的操作。
4. 接收者执行命令所指定的操作，并完成相应的业务逻辑。

优点

• 解耦调用者和接收者：调用者无需了解命令的具体实现，只需调用命令对象的方法来触发执行。
• 支持撤销和重做：通过存储命令的历史记录，可以方便地进行撤销和重做操作。
• 支持事务：可以通过一系列的命令组合形成事务，保证一组操作的原子性。

适用场景

• 需要将请求和执行操作解耦的情况。
• 需要支持撤销、重做、事务等操作的场景。
• 需要将一组操作组织成具体的命令队列或日志操作。

消息队列模式Demo实现

好的，下面是一个简单的使用 Java 实现的消息队列框架示例：

import java.util.LinkedList;
import java.util.Queue;

// 消息接口
interface IMessage {
    void execute();
}

// 具体消息类
class ConcreteMessage implements IMessage {
    private String content;

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

    public void execute() {
        System.out.println("处理消息：" + content);
    }
}

// 消息队列类
class MessageQueue {
    private Queue<IMessage> queue;

    public MessageQueue() {
        queue = new LinkedList<>();
    }

    public void enqueue(IMessage message) {
        queue.offer(message);
    }

    public IMessage dequeue() {
        return queue.poll();
    }

    public boolean isEmpty() {
        return queue.isEmpty();
    }
}

// 消费者类
class Consumer {
    private MessageQueue messageQueue;

    public Consumer(MessageQueue messageQueue) {
        this.messageQueue = messageQueue;
    }

    public void processMessages() {
        while (!messageQueue.isEmpty()) {
            IMessage message = messageQueue.dequeue();
            message.execute();
        }
    }
}

// 生产者类
class Producer {
    private MessageQueue messageQueue;

    public Producer(MessageQueue messageQueue) {
        this.messageQueue = messageQueue;
    }

    public void sendMessage(String content) {
        IMessage message = new ConcreteMessage(content);
        messageQueue.enqueue(message);
        System.out.println("发送消息：" + content);
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建消息队列对象
        MessageQueue messageQueue = new MessageQueue();

        // 创建消费者对象并启动消费者线程
        Consumer consumer = new Consumer(messageQueue);
        Thread consumerThread = new Thread(consumer::processMessages);
        consumerThread.start();

        // 创建生产者对象并发送消息
        Producer producer = new Producer(messageQueue);
        producer.sendMessage("消息1");
        producer.sendMessage("消息2");
        producer.sendMessage("消息3");

        // 等待消费者线程处理完所有消息
        try {
            consumerThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，我们实现了一个简单的消息队列框架。IMessage 是消息接口，定义了 execute() 方法表示具体的消息处理逻辑。ConcreteMessage 是具体的消息类，实现了 IMessage 接口，并在 execute() 方法中执行具体的处理操作。

MessageQueue 是消息队列类，使用 Queue 数据结构来保存消息对象，并提供了入队、出队和判断队列是否为空的方法。

Consumer 是消费者类，通过循环从消息队列中取出消息，并调用消息对象的 execute() 方法进行处理。

Producer 是生产者类，负责向消息队列中发送消息。

在客户端代码的 main() 方法中，我们创建了一个消息队列对象，然后分别创建了消费者对象和生产者对象。生产者使用 sendMessage() 方法向消息队列发送消息，而消费者通过启动一个新线程来调用 processMessages() 方法处理消息。

分写业务

这个业务代码实现了一个简单的消息队列框架。下面对代码进行逐步解释：

1. 首先，定义了一个消息接口 IMessage，其中包含了 execute() 方法用于执行具体的消息处理操作。

2. 接着，实现了具体的消息类 ConcreteMessage，它实现了 IMessage 接口，并在 execute() 方法中执行具体的消息处理逻辑。在本例中，处理逻辑简单地打印出消息内容。

3. 然后，定义了消息队列类 MessageQueue，使用 Queue 数据结构来保存消息对象。它提供了入队（enqueue()）、出队（dequeue()）和判断队列是否为空（isEmpty()）的方法。

4. 接下来，定义了消费者类 Consumer，它通过循环从消息队列中取出消息，并调用消息对象的 execute() 方法进行处理。

5. 最后，定义了生产者类 Producer，它负责向消息队列中发送消息。通过调用 sendMessage() 方法，生产者创建一个具体的消息对象并将其加入到消息队列中，同时打印出发送的消息内容。

在客户端代码的 main() 方法中，完成以下步骤：

1. 创建了一个消息队列对象 messageQueue。

2. 创建了消费者对象 consumer，并启动一个新线程来执行消费者的消息处理逻辑。

3. 创建了生产者对象 producer，通过调用 sendMessage() 方法发送了三条消息。

4. 最后，通过调用 join() 方法等待消费者线程处理完所有消息。

总结

这个示例展示了如何使用 Java 实现一个简单的消息队列框架。通过将消息封装为对象，我们可以方便地在生产者和消费者之间进行消息的传递和处理。使用消息队列框架可以实现解耦和异步处理的优势。生产者负责发送消息，消费者负责处理消息，它们通过共享的消息队列进行通信。通过多线程的方式，我们可以实现并发的消息处理，提高系统的吞吐量和响应性能。