命令模式

昨天看到群里面有个人说，他用的命令模式可以少些几十万行代码。然后就看了一下。在代码正确的运用设计模式，确实方便许多。

查看大图https://img-blog.csdn.net/20171111094021913?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvcXFfMzkyMzgzNzA=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast

具体是这样的，在工作的过程中的。又有一些新的需求，比如页面的要改变，我们就要叫美工组改变对应的页面，功能逻辑要改变就要找到功能组去改变逻辑。而不是直接的用户说出他的需求之后，只要内部执行一系列的命令。大体思路是这样的。

1.定义不同组的抽象类Group
2.实现这个抽象类，完成自己的事情
3.定义命令的抽象类 Command 初始化好应的组，具有一个执行的抽象方法 execute
4.对应类实现Command方法，执行逻辑
5.定义具体执行这个的命令的执行类Invoker

一.定义不同组的抽象类Group

public abstract class Group {
    /**
     * 查找
     */
    public abstract void find();

    /**
     * 添加
     */
    public abstract void add();

    /**
     * 删除
     */
    public abstract void delete();

    /**
     * 修改
     */
    public abstract void change();

    /**
     * 更改计划
     */
    public abstract void plan();

}

二.实现这个抽象类，完成自己的事情

public class PageGroup extends Group {
    /**
     * 美工组
     * 其他类也是一样的，具体实现的是自己的方法
     */
    @Override
    public void find() {
        Log.e("PageGroup", "找到美工组");
    }

    @Override
    public void add() {
        Log.e("PageGroup", "添加页面");
    }

    @Override
    public void delete() {
        Log.e("PageGroup", "删除页面");
    }

    @Override
    public void change() {
        Log.e("PageGroup", "更改页面");
    }

    @Override
    public void plan() {

    }
}

三.定义命令的抽象类 Command 初始化好应的组，具有一个执行的抽象方法 execute

public abstract class Command {
    /**
     * 初始化对应组
     */
    PageGroup pageGroup = new PageGroup();
    RequirementGroup requirementGroup = new RequirementGroup();
    private Receiver receiver;

    public Command() {

    }

    public Command(Receiver receiver) {
        this.receiver = receiver;
    }

    /**
     * 执行的方法
     */
    public abstract void execute();

}

四.对应类实现Command方法，执行逻辑

public class PageCommand extends Command {
    /**
     * 可以扩展的receiver
     */
    private Receiver receiver;

    public PageCommand(PageReceiver _receiver) {
        this.receiver = _receiver;
    }

    /**
     * 无参构造
     */
    public PageCommand() {
        super(new PageReceiver());
    }

    /**
     * 对应类的执行
     */
    @Override
    public void execute() {
        //扩展方法
        receiver.receiver();
        super.pageGroup.find();
        super.pageGroup.add();
        super.pageGroup.change();
    }
}

五.定义具体执行这个的命令的执行类Invoker

public class Invoker {
    //命令的抽象接口
    private Command command;

    //设置执行什么命令
    public void setCommand(Command command) {
        this.command = command;
    }

    //开始执行
    public void action() {
        this.command.execute();
    }
}

六.使用

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //执行命令的类
        Invoker invoker = new Invoker();
        //告诉我们要执行什么命令
        invoker.setCommand(new PageCommand());
        //执行
        invoker.action();

    }
}

总结：
优点：
1.类间的解耦 ：
这样的使用直接传入Command然后直接执行execute方法，根本不用考虑接收者。
2.可扩展性
Command的子类非常容易的扩展，Invoker和高层的模块不产生代码的耦合。
3.结合其他模式的使用更优秀

缺点：
如果Command的子类的命令比较多，这个类就会膨胀的非常大。