策略模式和责任链模式

一、策略模式

策略模式，就是为了解决像有很多if else这样的代码

代码如下（示例）：

/**
 * 公共策略
 */
public interface IStratery {

    void operator();
}

public class StrateryA implements IStratery
{
    public void operator() {
        System.out.println("派张飞从左翼杀出");
    }
}

public class StrateryB implements IStratery
{
    public void operator() {
        System.out.println("派关羽从右翼杀出");
    }
}

public class StrateryC implements IStratery
{
    public void operator() {
        System.out.println("派赵云从中间直捣黄龙");
    }
}

public class AbstractStratery {
    private static String ZHANG_FEI="张飞";
    private static String GUAN_YU="关羽";
    private static String ZHAO_YUN="赵云";
    static Map<String,IStratery> map = new HashMap<String,IStratery>();

    static {
        map.put(ZHANG_FEI,new StrateryA());
        map.put(GUAN_YU,new StrateryB());
        map.put(ZHAO_YUN,new StrateryC());
    }

    static void  invoke(String name){
        if (name != null) {
            map.get(name).operator();
        }
    }

}

测试一下

public class Test {
    public static void main(String[] args) {
        AbstractStratery.invoke("张飞");
        AbstractStratery.invoke("关羽");
        AbstractStratery.invoke("赵云");
    }
}

2.责任链模式

比如说登录，校验，权限这一系列操作，假设一个场景，员工离职，层层递进，我们使用建造者模式加责任链模式试试。

/**
 * 抽象链
 */
public abstract class AbstractChain<T> {

    protected AbstractChain<T> chain;

    public void next(AbstractChain<T> chain){
        this.chain=chain;
    }

    public void doChain(String name) {
        System.out.println("开始做某事");
    }

    public static class Buider<T>{
        private AbstractChain<T> header;
        private AbstractChain<T> tail;

        public Buider<T> addChain(AbstractChain<T> chain){
            if(header==null){
                this.header= this.tail=chain;
                return this;
            }
            this.tail.next(chain);
            this.tail=chain;
            return this;
        }

        public AbstractChain<T> build(){
            return this.header;
        }

    }
}

public class Boss extends AbstractChain{

    public void doChain(String name) {
        System.out.println("boss开启欢送离职会");
    }
}

/**
 * 人力
 */
public class EmployeeA  extends  AbstractChain{


    public void doChain(String name) {
        if("离职".equals(name)){
            System.out.println("员工A无法解决离职问题，移送boss");
            chain.doChain(name);
        }else {
            System.out.println("员工A解决"+name);
        }
    }
}

/**
 * 人力
 */
public class EmployeeB extends  AbstractChain {


    public void doChain(String name) {
        if("请假".equals(name)||"离职".equals(name)){
            System.out.println("员工B无法解决请假或者离职问题，移送员工A");
            chain.doChain(name);
        }else {
            System.out.println("员工B解决"+name);
        }
    }
}

/**
 * 人力
 */
public class EmployeeC  extends  AbstractChain {



    public void doChain(String name) {
        System.out.println("基层员工开始"+name);
        chain.doChain(name);
        System.out.println("基层员工"+name+"完毕");
    }
}

测试一下

   public static void main(String[] args) {
        Boss boss = new Boss();
        AbstractChain.Buider buider = new AbstractChain.Buider();
        buider.addChain( new EmployeeC()).addChain( new EmployeeB()).addChain( new EmployeeA()).addChain(new Boss()).build();
        buider.build().doChain("离职");
    }