Java设计模式 之命令模式

命令模式的思想

把一个请求或者操作封装到一个对象中，允许系统使用不同的请求把客户端参数化，从而实现对请求排队或者记录请求日志、提供命令的撤销和恢复功等能。

命令模式涉及5个角色

• 客户（Client）：创建一个具体命令对象并确定其接收者。
• 抽象命令（Command）：声明了一个给所有具体命令类的抽象接口。
• 具体命令（Concrete Command）：定义一个接收者和行为之间的弱耦合；实现execute()方法，负责调用接收者的相应操作。
• 请求者（Invoker）：负责调用命令对象执行请求。
• 接收者（Receiver）：负责具体实施和执行一个请求。任何一个类都可以成为接收者。
  

命令模式案例

案例前言

做项目，有一个项目经理（接头人），三个组：需求组，美工组，代码组，还有对应一个客户。

案例代码实现

定义组接口，抽象出组需要的功能。角色：Receiver

// 项目组分成了三个组,每个组还是要接受增删改的命令
public interface Group {

    //甲乙双方分开办公,你要和那个组讨论,你首先要找到这个组
    void find();
    //被要求增加功能
    void add();
    //被要求删除功能
    void delete();
    //被要求修改功能
    void change();
    //被要求给出所有的变更计划
    void plan();
}

实现需求组和代码组。

// 需求组
public class RequirementGroup implements Group{
    public void find() {
        System.out.println("找到需求组...");
    }
    public void add() {
        System.out.println("客户要求增加一项需求...");
    }
    public void change() {
        System.out.println("客户要求修改一项需求...");
    }
    public void delete() {
        System.out.println("客户要求删除一项需求...");
    }
    public void plan() {
        System.out.println("客户要求需求变更计划...");
    }
}

// 代码组
public class CodeGroup implements Group{
    public void find() {
        System.out.println("找到代码组...");
    }
    public void add() {
        System.out.println("客户要求增加一项功能...");
    }
    public void change() {
        System.out.println("客户要求修改一项功能...");
    }
    public void delete() {
        System.out.println("客户要求删除一项功能...");
    }
    public void plan() {
        System.out.println("客户要求代码变更计划...");
    }
}

定义客户发出的命令，抽象出命令，角色：Command

// 命令的抽象类,我们把客户发出的命令定义成一个一个的对象
public abstract class Command {

    // 定义好需要的组，子类可以直接使用
    protected RequirementGroup requirementGroup = new RequirementGroup();
    protected CodeGroup codeGroup = new CodeGroup();

    // 只要一个方法,你要我做什么事情
    public abstract void execute();
}

实现具体的命令，角色：Concrete Command

// 增加一项需求
public class AddRequirementCommand extends Command{

    //执行增加一项需求的命令
    @Override
    public void execute() {
        super.requirementGroup.find();
        super.requirementGroup.add();
        super.requirementGroup.plan();
    }
}

// 增加一段代码
public class AddCodeCommand extends Command{
    @Override
    public void execute() {
        super.codeGroup.find();
        super.codeGroup.add();
        super.codeGroup.plan();
    }
}

定义项目经理，即和客户的接头人。角色：Invoker

// 项目经理的职责就是接收命令,并执行
public class PM {
    // 持有的命令
    private Command command;

    // 客户发出的具体命令
    public void setCommand(Command command) {
        this.command = command;
    }

    // 执行客户的命令
    public void action() {
        command.execute();
    }
}

客户来了，和项目经理见面，并提出具体的命令。

public class Client {

    public static void main(String[] args) {
        // 定义项目经理
        PM tom = new PM();
        // 客户下发的命令
        Command addRequirementCommand = new AddRequirementCommand();
        tom.setCommand(addRequirementCommand);
        tom.action();

        System.out.println("---------------黄金分割线---------------");
        Command addCodeCommand = new AddCodeCommand();
        tom.setCommand(addCodeCommand);
        tom.action();
    }
}

运行结果。

总结

由于发起命令的对象和具体的实现完全解耦，因此扩展新的命令就很容易，只需要实现新的命令对象，然后在装配的时候，把具体的实现对象设置到命令对象中，然后就可以使用这个命令对象，已有的实现完全不用变化。

转载：https://blog.csdn.net/const_/article/details/101676512