Command 模式

Command 模式

一个类在进行工作时会调用自己或是其他类的方法，虽然调用结果会反映在对象的状态中，但并不会留下工作的历史记录。
这时，如果我们有一个类，用来表示“请进行这项工作”的“命令”就会方便很多。每一项想做的工作就不再是“方法的调用”这种动态处理了，而是一个表示命令的类的实例，即可以用“物”来表示。要想管理工作的历史记录，只需管理这些实例的集合即可，而且还可以随时再次执行过去的命令，或是将多个过去的命令整合为一个新命令并执行。
在设计模式中，我们称这样的“命令”为Command模式（command有“命令”的意思）。
Command有时也被称为事件（event）。它与“事件驱动编程”中的“事件”是一样的意思。当发生点击鼠标、按下键盘按键等事件时，我们可以先将这些事件作成实例，然后按照发生顺序放入队列中。接着，再依次去处理它们。在GUI（graphical user interface）编程中，经常需要与“事件”打交道。

示例程序

类和接口的一览表

名字	说明
Command	表示“命令”的接口
MacroCommand	表示“由多条命令整合成的命令”的类
DrawCommand	表示“绘制一个点的命令”的类
Drawable	表示“绘制对象”的接口
DrawCanvas	实现“绘制对象”的类
Main	测试程序行为的类

示例程序的类图

Command

public interface Command {
    void execute();
}

MacroCommand

import java.util.Stack;
import java.util.Iterator;

public class MacroCommand implements Command {
    // 命令的集合
    private Stack commands = new Stack();
    // 执行
    @Override
    public void execute() {
        Iterator it = commands.iterator();
        while (it.hasNext()) {
            ((Command)it.next()).execute();
        }
    }
    // 添加命令
    public void append(Command cmd) {
        if (cmd != this) {
            commands.push(cmd);
        }
    }
    // 删除最后一条命令
    public void undo() {
        if (!commands.empty()) {
            commands.pop();
        }
    }
    // 删除所有命令
    public void clear() {
        commands.clear();
    }
}

DrawCommand

import com.yangyun.japan.ch22.command.command.Command;
import java.awt.Point;

public class DrawCommand implements Command {
    // 绘制对象
    protected Drawable drawable;
    // 绘制位置
    private Point position;
    // 构造函数
    public DrawCommand(Drawable drawable, Point position) {
        this.drawable = drawable;
        this.position = position;
    }
    // 执行
    @Override
    public void execute() {
        drawable.draw(position.x, position.y);
    }
}

Drawable

public interface Drawable {
    void draw(int x, int y);
}

DrawCanvas

mport com.yangyun.japan.ch22.command.command.MacroCommand;

import java.awt.*;

public class DrawCanvas extends Canvas implements Drawable {
    // 颜色
    private Color color = Color.red;
    // 要绘制的圆点的半径
    private int radius = 6;
    // 命令的历史记录
    private MacroCommand history;

    // 构造函数
    public DrawCanvas(int width, int height, MacroCommand history) {
        setSize(width, height);
        setBackground(Color.white);
        this.history = history;
    }

    // 重新全部绘制
    @Override
    public void paint(Graphics g) {
        history.execute();
    }

    // 绘制
    @Override
    public void draw(int x, int y) {
        Graphics g = getGraphics();
        g.setColor(color);
        g.fillOval(x - radius, y - radius, radius * 2, radius * 2);
    }
}

Main

import com.yangyun.japan.ch22.command.command.Command;
import com.yangyun.japan.ch22.command.command.MacroCommand;
import com.yangyun.japan.ch22.command.drawer.DrawCanvas;
import com.yangyun.japan.ch22.command.drawer.DrawCommand;

import javax.swing.*;
import java.awt.event.*;

public class Main extends JFrame implements ActionListener, MouseMotionListener, WindowListener {
    // 绘制的历史记录
    private MacroCommand history = new MacroCommand();
    // 绘制区域
    private DrawCanvas canvas = new DrawCanvas(400, 400, history);
    // 删除按钮
    private JButton clearButton  = new JButton("clear");

    // 构造函数
    public Main(String title) {
        super(title);

        this.addWindowListener(this);
        canvas.addMouseMotionListener(this);
        clearButton.addActionListener(this);

        Box buttonBox = new Box(BoxLayout.X_AXIS);
        buttonBox.add(clearButton);
        Box mainBox = new Box(BoxLayout.Y_AXIS);
        mainBox.add(buttonBox);
        mainBox.add(canvas);
        getContentPane().add(mainBox);

        pack();
        show();
    }

    // ActionListener接口中的方法
    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == clearButton) {
            history.clear();
            canvas.repaint();
        }
    }

    // MouseMotionListener接口中的方法
    @Override
    public void mouseMoved(MouseEvent e) {
    }
    @Override
    public void mouseDragged(MouseEvent e) {
        Command cmd = new DrawCommand(canvas, e.getPoint());
        history.append(cmd);
        cmd.execute();
    }

    // WindowListener接口中的方法
    @Override
    public void windowClosing(WindowEvent e) {
        System.exit(0);
    }
    @Override
    public void windowActivated(WindowEvent e) {}
    @Override
    public void windowClosed(WindowEvent e) {}
    @Override
    public void windowDeactivated(WindowEvent e) {}
    @Override
    public void windowDeiconified(WindowEvent e) {}
    @Override
    public void windowIconified(WindowEvent e) {}
    @Override
    public void windowOpened(WindowEvent e) {}

    public static void main(String[] args) {
        new Main("Command Pattern Sample");
    }
}

示例程序的时序图

Command模式中的登场角色

1.Command（命令）

Command角色负责定义命令的接口（API）。在示例程序中，由Command接口扮演此角色。

2.ConcreteCommand（具体的命令）

ConcreteCommand角色负责实现在Command角色中定义的接口（API）。在示例程序中，由MacroCommand类接收DrawCommand的命令。

3.Receiver（接收者）

Receiver角色是Command角色执行命令时的对象，也可以称其为命令接收者。在示例程序中，由DrawCanvas类接收DrawCommand的命令。

4.Client（请求者）

Client角色负责生成ConcreteCommand角色并分配Receiver角色。在示例程序中，由Main类扮演此角色。在响应鼠标拖动事件时，它生成了DrawCommand类的实例，并将扮演Receiver角色的DrawCanvas类的实例传递给了DrawCommand类的构造函数。

5.Invoker（发动者）

Invoker角色是开始执行命令的角色，它会调用在Command角色中定义的接口（API）。在示例程序中，由Main类和DrawCanvas类扮演此角色。这两个类都调用了Command接口中的execute方法。Main类同时扮演了Client角色和Invoker角色。

通用类图

通用时序图