Question

我有一个方法需要执行多个任务才能完成更大的任务。每个任务可能需要20到30行代码，因此我决定为每个任务安排一个类。

public void bigTask() {
    TaskProcessor executor = new TaskProcessor();
    executor.addTask(new Task1(some arguments here));
    executor.addTask(new Task2(some other arguments here));
    executor.addTask(new Task2(some other arguments here));
    executor.run();
}

public interface Task {
    public void execute();
}

public class Task1 implements Task {
    @Override
    public void execute() {
        //Some code here
    }
}

public class Task2 implements Task {
    @Override
    public void execute() {
        //Some other code here
    }
}

public class Task3 implements Task {
    @Override
    public void execute() {
        //Some other code here
    }
}

public class TaskProcessor implements Serializable {

    private List<Task> tasksList;

    public TaskProcessor () {
        this.tasksList = new ArrayList<Task>();
    }

    public void addTask(Task task) {
        this.tasksList.add(task);
    }

    public void execute() {
        for (Task task : this.tasksList) {
            task.execute();
        }
    }
}

对于我来说，这段代码就像一个命令模式，但是我不确定，因为与传统的命令模式不同，每个任务的参数是不同的类型。

您认为这可以视为命令模式实现吗？您认为这种方法适合拆分大方法吗？

谢谢

Answer 1

您认为这可以视为命令模式的实现吗？

我认为这已经足够“命令模式”了。

您认为这种方法可以拆分大方法吗？

我们使用了一种非常相似的方法来剖析长的“序列”和小的“动作”。但是我们添加了不同种类的“容器”。如：在某些情况下，即使有一个条目失败，有时也会有一系列应继续执行的动作。在其他情况下，整个序列应立即停止。另一个味道是一个序列，其中每个Action都有一个const result = peopleArray.map((value) => { return { name: value.name, score: value.scores.reduce((total, score) => total + Number(score), 0) } }) console.log(result);方法，以便当某个Action失败时，序列容器可以回滚所有先前（通过）的Action。

根据您的上下文，您可能会“很好”，但是我认为您至少应该考虑一下，如果单个任务可以失败，/您的TaskProcessor容器应该如何应对失败步骤。

Answer 2

就结构而言，此代码是Command设计模式的一种应用。到“四人帮”一书中的模式参与者的映射如下：

Task是模式中的Command接口，具有execute方法；
Task1-3是具体命令；
TaskProcessor是Invoker，它“询问命令以执行请求”

但是，就意图而言，存在一些不匹配。《四人帮》一书中所述的命令模式的初衷是

将请求封装为对象，从而使您可以将具有不同请求，队列或日志请求的客户端参数化，并支持不可撤消的操作。

但是，问题“您认为这种方法适合拆分大方法吗？”建议的目标是为复杂的计算模块提供模块化分解，这是不一样的。

这段代码是某种命令模式吗？

2 个答案: