使用場(chǎng)景：
項(xiàng)目中要使用到SQL解析器，目前選擇了2個(gè)解析器，但各有各的優(yōu)點(diǎn)。
解析器A：解析速度快，但兼容性差一些，有一些SQL支持不了，直接拋異常；
解析器B：解析速度慢，但兼容性好，幾乎所有SQL都可以正常解析。

同一個(gè)需求，我們可以優(yōu)先使用解析器A來(lái)處理，當(dāng)處理失敗(拋出異常時(shí))再使用解析器B處理。

具體開發(fā)方案：設(shè)計(jì)單向鏈表，先用表頭的處理器處理，處理失敗則流轉(zhuǎn)到下一個(gè)處理器進(jìn)行處理，直到處理成功為止。

代碼實(shí)現(xiàn)：
1、定義行為接口

public interface IHandler {

    public boolean handle1(Object arg1, Object arg2);
    public String handle2(Object arg1);
}

2、對(duì)行為接口進(jìn)行抽象實(shí)現(xiàn)，并實(shí)現(xiàn)一個(gè)單向鏈表結(jié)構(gòu)

public abstract class AbstractHandler implements IHandler{

    protected AbstractHandler next;
    public AbstractHandler next(){
        return this.next;
    }


    protected <R> R call(AbstractHandler header, Handler<R> handler){
        AbstractHandler chain = header;
        R result = null;
        do{
            try{
                result = handler.handle(chain);
                break;
            }catch(Exception e){
                if(chain.next() == null){
                    throw new RuntimeException();
                }
                chain = chain.next();
            }
        }while (chain != null);
        return result;
    }

    protected abstract class Handler<R>{
        public abstract R handle(AbstractHandler chain);
    }

    public AbstractHandler getNext() {
        return next;
    }

    public void setNext(AbstractHandler next) {
        this.next = next;
    }

    public static class Buider{
        private AbstractHandler header;
        private AbstractHandler tail;

        public static Buider create(){
            return new Buider();
        }

        public Buider addChain(AbstractHandler chain){
            if(header == null){
                this.header = this.tail = chain;
                return this;
            }
            this.tail.setNext(chain);
            this.tail = chain;
            return this;
        }

        public AbstractHandler build(){
            return this.header;
        }

    }

}

3、開發(fā)具體的處理器

public class OneHandler extends AbstractHandler{
    public boolean handle1(Object arg1, Object arg2) {
        return false;
    }

    public String handle2(Object arg1) {
        if(null == arg1){
            throw new RuntimeException();
        }
        return "用戶One解決第2個(gè)問(wèn)題";
    }
}


public class TwoHandler extends AbstractHandler{
    public boolean handle1(Object arg1, Object arg2) {
        return true;
    }

    public String handle2(Object arg1) {
        return "用戶Two解決第2個(gè)問(wèn)題";
    }
}

4、開發(fā)責(zé)任鏈調(diào)用者

public class HandlerChain extends AbstractHandler{

    private AbstractHandler chainHeader;

    public boolean handle1(final Object arg1, final Object arg2) {
        return call(chainHeader, new AbstractHandler.Handler<Boolean>(){
            public Boolean handle(AbstractHandler chain) {
                return chain.handle1(arg1, arg2);
            }
        });
    }

    public String handle2(final Object arg1) {
        return call(chainHeader, new AbstractHandler.Handler<String>(){
            public String handle(AbstractHandler chain) {
                return chain.handle2(arg1);
            }
        });
    }

    public void setChainHeader(AbstractHandler chainHeader) {
        this.chainHeader = chainHeader;
    }
    
}

5、實(shí)際調(diào)用

public static void main(String[] args) {
        AbstractHandler chainHeader = AbstractHandler.Buider.create()
                .addChain(new OneHandler())
                .addChain(new TwoHandler())
                .build();

        HandlerChain chain = new HandlerChain();
        chain.setChainHeader(chainHeader);

        System.out.println(chain.handle1(null,null));
        System.out.println(chain.handle2(null));

    }