行为类模式PK (一)：策略模式和命令模式

行为类模式

行为类模式比较多：
责任链模式，命令模式，解释器模式，迭代器模式，访问者模式，备忘录模式，中介者模式，观察者模式， 状态模式，策略模式，模板方法。11个

• 命令模式和策略模式
  策略模式的意图是封装算法，封装完整的，不可拆分的原子业务，其意图是让算法独立，并且可以相互替换，让行为的变化独立于行为的客户。
  命令模式 命令模式是对动作的解藕，把一个动作执行分为执行对象，执行行为，让两者相互独立而不相互影响。
  这里多次提到解藕，不相互影响，那么常见的办法就是作为参数传进去，而不是写死。

策略模式由上下文封装具体的策略类，策略类具体执行。 命令模式，命令封装具体的命令接收者，命令接收者负责具体实现。 由invoker调用命令。

以 zip和gzip为例，进行策略模式和命令模式的比较。

策略模式：

public interface Algorithm{
    
    public boolean compress(String source,String to);
    public boolean uncompress(String source,String to);
}

public class Zip implements Algorithm{

    
    @Override
    public boolean compress(String source, String to) {
        System.out.println(source+"-->"+to+"zip compress");
        return true;
    }

    @Override
    public boolean uncompress(String source, String to) {
        System.out.println(source+"-->"+to+"zip uncompress");
        return true;
    }
}



public class Gzip implements Algorithm{


    @Override
    public boolean compress(String source, String to) {
        System.out.println(source+"-->"+to+"gzip compress");
        return true;
    }

    @Override
    public boolean uncompress(String source, String to) {
        System.out.println(source+"-->"+to+"gzip uncompress");
        return true;
    }
}


public class Context{
    
    private Algorithm al;
    
    public Context(Algorithm al){
        this.al=al;
    }
    
    public boolean compress(String source,String to){
        return al.compress(source,to);
    }
    public boolean uncompress(String source,String to){
        return al.uncompress(source,to);
    }
}

public class Client{
    public static void main(String [] args){
        
        Context context;
        System.out.println("执行算法");
        
        context=new Context(new Zip());

        /**
         * context=new Context(new Gzip());
         */
        
        context.compress("/home/xxxx","/opt/xxx");
        context.uncompress("/home/xxxx","/opt/xxx");
    }
}

命令模式：
定义命令，命令引用具体执行者， invoker调用命令

public abstract class AbstractCmd{

    protected IReceiver zip=new ZipReceiver();
    protected IReceiver gzip=new GzipReceiver();

    public abstract boolean execute(String source,String to);
}

public class ZipCompressCmd extends AbstractCmd{

    @Override
    public boolean execute(String source, String to) {
        return super.zip.compress(source,to);
    }
}


public class ZipUncompressCmd extends AbstractCmd{

    @Override
    public boolean execute(String source, String to) {
        return super.zip.uncompress(source,to);
    }
}


public class GzipCompressCmd extends AbstractCmd{

    @Override
    public boolean execute(String source, String to) {
        return super.gzip.compress(source,to);
    }
}


public class GzipUncompressCmd extends AbstractCmd{

    @Override
    public boolean execute(String source, String to) {
        return super.gzip.uncompress(source,to);
    }
}

public class Invoker{
    
    private AbstractCmd cmd;
    
    public Invoker(AbstractCmd cmd){
        this.cmd=cmd;
    }
    
    public boolean execute(String source ,String to){
        return cmd.execute(source,to);
    }
}

public class Client{
    public static void main(String [] args){
        
        AbstractCmd cmd=new ZipCompressCmd();

        /**
         * 换个cmd
         * AbstractCmd cmd=new ZipUncompressCmd();
         */
        Invoker invoker=new Invoker(cmd);
        
        cmd.execute("/home/zz","/opt/zz");
    }
}

在命令模式中，请求者与执行者分离了， 请求执行者不了解谁具体的执行命令。 由命令本身保证谁具体执行。

策略模式和状态模式比较

• 关注点不同。策略模式关注的是算法替换的问题。 关注的是算法的完整性和封装性。
  命令模式关注的是解藕问题，如何让请求者和具体的执行者解耦是它需要解决的。 解耦的要求就是把请求的内容封装为一个一个的命令，由接收者执行。由于封装成了命令，就同时可以对命令进行多种处理。
• 重要的是使用场景不同。 策略模式适用于算法要求变换的场景，而命令模式适用于解耦两个有紧耦合关系的对象场合或者多命令撤销的场景。