命令(Command)模式:指将请求封装为一个对象,从而使发出请求的动作与请求执行的动作分开。二者之间通过对象进行沟通,这样就可以很方便的将命令对象存储,传递和调用。

    优点:

    1. 通过引入中间件的方式,降低系统的耦合度
    2. 可以很方便的实现Undo和Redo操作。

    缺点:

    1. 可能产生大量的具体命令类
    2. 引入额外的类结构,增加了系统理解的难度

    示例:假设有一个编辑器,它具有创建和删除两个功能

    1. static class Editer{
    2. public void create(){
    3. System.out.println("创建一个对象");
    4. }
    5. public void delete(){
    6. System.out.println("删除一个对象");
    7. }
    8. }

    正常情况下,它将被这样调用

    1. public static void main(String[] args) {
    2. Editer editer = new Editer();
    3. editer.create();
    4. editer.delete();
    5. }

    但如果我们改用命令模式,将请求的动作和执行的操作分开,则可以引入一个Command接口

    1. interface Command{
    2. void execute();
    3. }

    然后创建对应的Command,然后执行,并不关心具体是如何实现的

    1. static class CreateCommand implements Command{
    2. // 持有被执行的对象
    3. private Editer editer;
    4. public CreateCommand(Editer editer){
    5. this.editer = editer;
    6. }
    7. @Override
    8. public void execute() {
    9. editer.create();
    10. }
    11. }
    12. static class DeleteCommand implements Command{
    13. // 持有被执行的对象
    14. private Editer editer;
    15. public DeleteCommand(Editer editer){
    16. this.editer = editer;
    17. }
    18. @Override
    19. public void execute() {
    20. editer.delete();
    21. }
    22. }

    测试

    1. public static void main(String[] args) {
    2. Editer editer = new Editer();
    3. // 执行创建命令
    4. CreateCommand createCommand = new CreateCommand(editer);
    5. createCommand.execute();
    6. // 执行删除命令
    7. DeleteCommand deleteCommand = new DeleteCommand(editer);
    8. deleteCommand.execute();
    9. }

    到此为止,可以发现命令模式貌似反而让系统复杂度更高了,还不如直接调用来的简单直接。
    但是,具体情况需要视需求而定,比如Editer功能类很复杂,并且需要支持Undo和Redo功能呢?此时就可以使用命令模式

    不难发现,设计模式带来的系统复杂度会随着系统复杂度增加的,它主要减少的是系统耦合度