责任链在开发中的实际应用

使用场景：
项目中要使用到SQL解析器，目前选择了2个解析器，但各有各的优点。
解析器A：解析速度快，但兼容性差一些，有一些SQL支持不了，直接抛异常；
解析器B：解析速度慢，但兼容性好，几乎所有SQL都可以正常解析。

同一个需求，我们可以优先使用解析器A来处理，当处理失败(抛出异常时)再使用解析器B处理。

具体开发方案：设计单向链表，先用表头的处理器处理，处理失败则流转到下一个处理器进行处理，直到处理成功为止。

代码实现：
1、定义行为接口

public interface IHandler {

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

2、对行为接口进行抽象实现，并实现一个单向链表结构

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、开发具体的处理器

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个问题";
    }
}


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

    public String handle2(Object arg1) {
        return "用户Two解决第2个问题";
    }
}

4、开发责任链调用者

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、实际调用

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));

    }