命令模式的理解

前一段看了一篇关于命令模式的文章，觉得非常好，也算做个笔记。

说的是一个地摊，有一个师傅，顾客过来买饭，师傅既要问他们需要什么，又要自己来做，师傅与顾客耦合度高，又违背了单一职责原则。

这时候顾客是请求者，师傅执行者，现在的问题就是请求者和执行者解耦。解决办法就是增加一个服务员。

服务员用来接收顾客的订单，再把订单传给师傅。这样顾客不必知道师傅有多少，是哪一个做的，师傅也不用知道谁要了什么，只管做。

其实服务员也不用知道师傅的存在，只需把订单放到桌子上，师傅也不需要知道服务员存在，只要看到订单就做。

师傅类

public class Kitchener

{

       public void MakeCake()

      {

            System.out.println("制作蛋糕");

       }

       public  void MakeBread()

       {

            System.out.println("制作面包");

       }

       public  void MakeLine()

       {

            System.out.println("制作快餐");

       }

       public  void MakeHamburger()

       {

            System.out.println("制作汉堡");

       }

}

 

命令抽象类

public abstract class CuisineCommand

{

     protected Kitchener kitchener;

     public  CuisineCommand(Kitchener kitchener) 

   {      

       this .kitchener = kitchener;  

     } 

         

        public   abstract   void  MakeFood();  

}

 

 

具体命令订单

public class CakeCommand extends CuisineCommand

{

         public CakeComman(Kitchener kitchener)

       {

               super(kitchener);

       }

       public void MakeFood()

       {

             kitchener.MakeCake();

       }

}

 

public class BreadCommand extends CuisineCommand

{

         public BreadCommand (Kitchener kitchener)

       {

               super(kitchener);

       }

       public void MakeFood()

       {

             kitchener.MakeBread();

       }

}

 

public class BentoCommandextends CuisineCommand

{

         public BentoCommand(Kitchener kitchener)

       {

               super(kitchener);

       }

       public void MakeFood()

       {

             kitchener.MakeBento();

       }

}

 

public class HamburgerCommandCuisineCommand

{

         public HamburgerCommand(Kitchener kitchener)

       {

               super(kitchener);

       }

       public void MakeFood()

       {

             kitchener.MakeHamburger();

       }

}

 

服务员

public class Waiter

{

      private CuisineCommand cuisineCommand;

      public Waiter(CuisineCommand cuisineCommand)

       {

         this.cuisineCommand=cuisineCommand;

        }

       public void SetCommand(CuisineCommand cuisineCommand)

       {

          this.cuisineCommand=cuisineCommand;

        }

        public void NotifyExecute()

        {

             this.cuisineCommand.MakeFood();

         }

}

 

客户端

public class Program

{

       static void Main(String[] args)

       {

             //首先要实例化一个厨师   

           Command.Kitchener kitchener =     new  Command.Kitchener();  

           //然后实例化一个命令对象 

          //这个命令对象中必须确定谁是接收者 

           Command.CuisineCommand cake =    new  Command.CakeCommand(kitchener);  

           //实例化一个服务员   

         //这个服务员来生成订单 

           Command.Waiter waiter = new  Command.Waiter(cake);  

  //通过服务员来通知厨师制作食品

           waiter.NotifyExecute();

        Command.CuisineCommand bread =  

           new  Command.BreadCommand(kitchener); 

          waiter = new  Command.Waiter(bread);

          waiter.NotifyExecute(); 

 

       }

}

 

客户端创建一个具体命令对象并且要确定其接受者

抽象命令定义一个接受者和行为之间的弱耦合

请求者角色负责调用命令对象执行请求

接受者角色负责具体实施和执行一个请求

请求者就是服务员，接受者就是师傅。

 

命令模式还有一个用途：队列请求和撤销请求

上面有一个不足，一个顾客只能点一道菜，如果多道菜怎么办，需要修改Waiter类

public class Waiter

{

         private List cuisineCommand = new list();

         public void SetCommand(CuisineCommand cuisineCommand)

         {

                this.cuisineCommand.Add(cuisineCommand);

         }

         //撤销

         public void UndoCommand(CuisineCommand cuisineCommand)

        {

                this.cuisineCommand.Remove(cuisineCommand);

        }

         //通知厨师

        public void NotifyExecute()

        {

                 for(int i=0;i<cuisineComman.size();i++)

                 {

                      cuisineComman[i].MakeFood();

                 }

        }

}

 

//客户端

public class Program

{

            static void Main(String[] args)

           {

                 Kitchener kitchener = new kitchener();

                 CuisineCommand cake = new CakeCommand(kitchener);

                 CuisineCommand bread = new BreadCommand(kitchener);

                 CuisineCommand bento = new BentoCommand(kitchener);

                 Waiter waiter = new Waiter();

                 waiter.setCommand(cake);

                 waiter.setCommand(bread);

                 waiter.setCommand(bento);

                 waiter.UndoCommand(bread);

                 waiter.NotifyExecute();

            }

}

 

总结：

命令模式为了让请求者和执行者解耦，并且具有队列请求和回退功能。

客户端创建命令对象和接受者：

                 Kitchener kitchener = new kitchener();

                 CuisineCommand cake = new CakeCommand(kitchener);

                 CuisineCommand bread = new BreadCommand(kitchener);

                 CuisineCommand bento = new BentoCommand(kitchener);

 

命令对象里面有一个接受者的引用，命令中的方法是执行接受者的方法。说明命令做什么事情指定接收人，具体怎么做是接受人的事。

请求者里面有一个包含命令的集合，可以添加命令，回退命令，调用命令。

接受者就是执行任务。