设计模式之责任链模式

责任链模式

适合处理一个请求要经过若干个处理者，处理者抽象为 Handler，避免代码中出现大量的 if..else。 处理链定义为链表，链表元素是Handler抽象类。

定义handler

Handler.java

public abstract class Handler {
    private Handler next;

    public abstract void handle(Object in);

    public Handler getNext() {
        return next;
    }

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

PredicateHandler.java

public abstract class PredicateHandler<T> extends Handler implements Predicate<T> {
    @Override
    public void handle(Object in) {
        if (!test((T) in)) {
            return;
        }

        Handler next = getNext();
        if (next == null) {
            return;
        }
        next.handle(in);
    }
}

FuncHandler.java

public abstract class FuncHandler<T,R> extends Handler implements Function<T, R> {
    @Override
    public void handle(Object in) {
        R r = apply((T) in);
        Handler next = getNext();
        if (next == null) {
            return;
        }
        next.handle(r);
    }
}

ConsumeHandler.java

public abstract class ConsumeHandler<T> extends Handler implements Consumer<T> {
    @Override
    public void handle(Object in) {
        accept((T) in);
    }
}

定义pipline

ProcessChain.java

public class ProcessChain {
    private Handler head = null;
    private Handler tail = null;


    public void addLast(Handler handler) {
        handler.setNext(null);
        if (head == null) {
            head = handler;
            tail = handler;
            return;
        }

        tail.setNext(handler);
        tail = handler;
    }

    public void doProcess(Object value) {
        if (Objects.isNull(value) || head == null) {
            return;
        }

        head.handle(value);
    }
}