设计模式笔记之十四 (命令模式)

命令模式

命令模式是一种比较容易理解的设计模式，顾名思义，就是调用者发一个命令，有人给做完就行了，无关乎怎么做，也无关乎谁做。

我们继续我们以往的方式：理论联系实践的方式来理解命令模式。

 

最近我们实验室接到了一个新的订单，由于我们太阳兽人工厂的强大市场公关能力，我国某富豪需求一批太阳女兽人来满足其某些需求。

老总非常高兴得到这么大的一笔订单，所以大笔一挥，决定做，并且取代号为‘爱’。

俗话说得好，领导一动嘴，小弟弟跑断腿。老总只发号了一个做的命令，并不关心是谁做的，怎么做的，只关心最后能不能做好。

class MiShu {
    public void doLove() {
        
    }
}

public class Command {
    public static void main(String[] args) {
        //老总对秘书说把爱给做出来
        MiShu mishu = new MiShu();
        mishu.doLove();
    }
}

都说秘书是老板的小棉袄，秘书知道要将老板的命令交给一个信任的人去做，并且那个人还必须要能做，最直接的做法是，秘书直接通知兽人工厂来生产’爱‘

class MiShu {
    public void doLove() {
        new ShouRenFactory().make();
    }
}
class ShouRenFactory {
    public void make() {
        System.out.println("造一个爱，和苍老师");
        System.out.println("再造一个爱，和波多野小姐");
    }
}

但是这样也有一个问题，像我们实验室这种高刺激性地方，换厂长是很平常的事情，如果兽人工厂换个人来当厂长，并且做事风格变了，秘书就得来适应兽人工厂新厂长的做事风格

class MiShu {
    public void doLove() {
        //new ShouRenFactory().make();
        new ShouRenFactory().makeNew();// 这里秘书需要适应ShouRenFactory的新接口makeNew接口就得改代码
    }
}
class ShouRenFactory {
    public void makeNew() {
        System.out.println("造一个爱，和苍老师");
        System.out.println("再造一个爱，和波多野小姐");
    }
}

这怎么能行，秘书是老总的小棉袄又不是兽人工厂的小棉袄，只有你适应我的，哪有小棉袄适应你的，所以秘书想出一个方法：

我给你们这些个工厂一个模板，你们根据你们自己的能力填写这个模板，那我以后只要挑选模板就行了。

class MiShu {
    public void doLove() {
        ShouRenFactory factory = new ShouRenFactory();//指定执行者
        LoveMingLing love = new LoveMingLing(factory);//指定命令模板
        love.exec();//作吧
    }
}

class ShouRenFactory {
    public void make() {
        System.out.println("造一个爱，和苍老师");
        System.out.println("再造一个爱，和波多野小姐");
    }
}

interface MingLing {
    public void exec();
}

class LoveMingLing implements MingLing{
    
    private ShouRenFactory f;
    
    public LoveMingLing(ShouRenFactory f) {
        this.f = f;
    }
    
    @Override
    public void exec() {
        f.make();
    }
    
}
public class Command {
    public static void main(String[] args) {
        //老总对秘书说把爱给做出来
        MiShu mishu = new MiShu();
        mishu.doLove();
    }
}

现在就比较好了，如果以后又有新的厂长，我们大不了换个人就行了，或者更新下命令模板。当然最方便的是：

如果除了爱命令又有新的命令，比如恨命令， 只要新加一个恨命令模板就好了。

class MiShu {
    public void doLove() {
        ShouRenFactory factory = new ShouRenFactory();//指定执行者
        LoveMingLing love = new LoveMingLing(factory);//指定命令模板
        love.exec();//作吧
    }
    
    public void doHate() {
        ShouRenFactory factory = new ShouRenFactory();//指定执行者
        HateMingLing hate = new HateMingLing(factory);//指定命令模板
        hate.exec();//作吧
    }
}

class ShouRenFactory {
    public void make() {
        System.out.println("造一个爱，和苍老师");
        System.out.println("再造一个爱，和波多野小姐");
    }

    public void hate() {
        System.out.println("造一个恨，和罗玉风");
        System.out.println("再造一个恨，和校长");
    }
}

interface MingLing {
    public void exec();
}

class LoveMingLing implements MingLing{
    
    private ShouRenFactory f;
    
    public LoveMingLing(ShouRenFactory f) {
        this.f = f;
    }
    
    @Override
    public void exec() {
        f.make();
    }
    
}

class HateMingLing implements MingLing{
    
    private ShouRenFactory f;
    
    public HateMingLing(ShouRenFactory f) {
        this.f = f;
    }
    
    @Override
    public void exec() {
        f.hate();
    }
    
}

public class Command {
    public static void main(String[] args) {
        //老总对秘书说把爱给做出来
        MiShu mishu = new MiShu();
        mishu.doLove();
        mishu.doHate();
    }
}

当然，当兽人工厂不行的时候，我们还可以很简单的更换接收者，反正是我们的造人工厂就行

class MiShu {
    public void doLove() {
        Factory factory = new ShouRenFactory();//指定执行者
        LoveMingLing love = new LoveMingLing(factory);//指定命令模板
        love.exec();//作吧
    }
    
    public void doHate() {
        Factory factory = new RenYaoFactory();//指定执行者
        HateMingLing hate = new HateMingLing(factory);//指定命令模板
        hate.exec();//作吧
    }
}

interface Factory {
    public void make();
    public void hate();
}

class ShouRenFactory implements Factory{
    public void make() {
        System.out.println("造一个爱，和苍老师");
        System.out.println("再造一个爱，和波多野小姐");
    }

    public void hate() {
        System.out.println("造一个恨，和罗玉风");
        System.out.println("再造一个恨，和校长");
    }
}
class RenYaoFactory implements Factory{
    public void make() {
        System.out.println("造一个爱，和人妖");
    }

    public void hate() {
        System.out.println("造一个恨，和丑一点的人妖");
    }
}
interface MingLing {
    public void exec();
}

class LoveMingLing implements MingLing{
    
    private Factory f;
    
    public LoveMingLing(Factory f) {
        this.f = f;
    }
    
    @Override
    public void exec() {
        f.make();
    }
    
}

class HateMingLing implements MingLing{
    
    private Factory f;
    
    public HateMingLing(Factory f) {
        this.f = f;
    }
    
    @Override
    public void exec() {
        f.hate();
    }
    
}

public class Command {
    public static void main(String[] args) {
        //老总对秘书说把爱给做出来
        MiShu mishu = new MiShu();
        mishu.doLove();
        mishu.doHate();
    }
}

到这里我们就能看出命令模式的好处：

他能将命令发布者和命令执行者进行解偶。所以我们能够很容易扩展更多的执行者，扩展更多的命令。

 

 

PS:好久没有更新了，原因么，搞软件的大家应该都能猜到。 新开工程和交付工程总是要加班的。 希望大家一如既往的喜欢这个风格的设计模式。在枯燥的码海中找到一点欢乐，找到一点知识。

这段时间也反思了不少，觉得讲得不够清楚。本想再加一些UML图和一些概念的讲解。但是那些满地图都是，这个系列的博客本意只是将我对设计模式的理解用另类的方法记录下来，以便自己回忆。便又作罢，只是如此，搏一笑而已。