命令模式

背景简介：
开发软件，项目划分几个小组：需求组，美工组，代码组。
开发流程，客户提出需求=》需求分析=》美工设计界面=》写代码实现功能

//项目小组抽象类
public abstract class Group
{
	public abstract void find();
	public abstract void add();
	public abstract void delete();
	public abstract void change();
	public abstract void action();
}

//需求组
public class XuqiuGroup extends Group
{
    public void find()
    {
        //找到需求人员
    }
    public void add()
    {
        //叫需求人员增加页面
    }
    public void delete()
    {
        //叫需求人员删除页面
    }
    public void change()
    {
        //叫需求人员修改页面
    }
    public void action()
    {
        //叫需求人员执行以上动作
    }
}

//美工组
public class MeigongGroup extends Group
{
    public void find()
    {
        //找到美工
    }
    public void add()
    {
        //叫美工增加页面
    }
    public void delete()
    {
        //叫美工删除页面
    }
    public void change()
    {
        //叫美工修改页面
    }
    public void action()
    {
        //叫美工执行以上动作
    }
}

//代码组
public class CodeGroup extends Group
{
    public void find()
    {
        //找到程序员
    }
    public void add()
    {
        //叫程序员增加页面
    }
    public void delete()
    {
        //叫程序员删除页面
    }
    public void change()
    {
        //叫程序员修改页面
    }
    public void action()
    {
        //叫程序员执行以上动作
    }
}


public class Client
{
    public void static main()
    {
        XuqiuGroup xg = new XuqiuGroup();
        xg.find();  //找到需求
        xg.add();   //增加一个页面
        xg.action();//给我去执行
        //找完需求后又去找美工再去找程序员。客户很累，发火了，你们给我一个接头人。
        //我不管你们内部如何实现，我只想告诉你们我想要什么，你们给我去做就行。
    }
}

客户的想法随时改变，一会增加功能、一会删除。然后，还得把想法跟每个组沟通。疲于奔命。
客户是甲方，他说这样修改需求太累了，我还得找这么多组的人来商量如何处理一个需求。
这样吧，你们找个接头人给我，我只需要把我的想法告诉他，至于内部怎么实现我不管，你们自己商量好如何去做。

于是，把客户的想法封装成一个个的命令，比如增加需求的命令 和 删除需求的命令。
再来找个接头人，让他把这个命令分发到每个组执行下去。

public abstract class Command
{
    protected XuqiuGroup xg = new XuqiuGroup();
    protected MeigongGroup mg = new MeigongGroup();
    protected CodeGroup cg = new CodeGroup();
    public abstract void excute();  //你要我做什么我就做什么
}

//增加需求命令
public class AddXuqiuCommand extends Command
{
    //找到需求方 增加需求，再让美工 设计界面，最后让程序员实现功能
    public void excute()
    {
        xg.find();
        xg.add();
        xg.action();
        mg.find();
        mg.add();
        mg.action();
        cg.find();
        cg.add();
        cg.action();
    }
}

//删除需求命令
public class DelXuqiuCommand extends Command
{
    //找到需求方 删除需求，最后让程序员删除该功能
    public void excute()
    {
        xg.find();
        xg.add();
        xg.action();
        cg.find();
        cg.add();
        cg.action();
    }
}

//调度器 接头人
public class Invoker
{
    private Command command;
    //客户向我发出命令
    public void setCommand(Command command)
    {
        this.command = command;
    }
    //执行客户给的命令
    public void action()
    {
        command.excute();
    }
}

public class Client
{
    public static void main()
    {
        //接头人 你来给我执行一个 增加需求的命令
        Invoker invoker = new Invoker();
        invoker.setCommand(new AddXuqiuCommand());
        invoker.action();
        //接头人 你来给我执行一个 删除需求的命令
        invoker.setCommand(new DelXuqiuCommand());
        invoker.action();
    }
}

最终，这么实现就轻松很多了，客户不需要找到每个组下达命令。

但是，命令模式同时也有个缺点，当命令的组合情况复杂的时候，就是封装的命令就有很多。