设计模式之责任链模式（Chain）

设计模式之责任链模式（Chain）

本篇为 https://github.com/iluwatar/java-design-patterns/tree/master/chain 阅读笔记
意图

避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

优点

1、降低耦合度。它将请求的发送者和接收者解耦。
2、简化了对象。使得对象不需要知道链的结构。
3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。
4、增加新的请求处理类很方便。

缺点

1、不能保证请求一定被接收。
2、系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。
3、可能不容易观察运行时的特征，有碍于除错。

场景

国王发布不同类型的命令，根据命令类型由指挥官，军官，士兵执行

国王请求枚举

public enum RequestType {
    DEFEND_CASTLE, TORTURE_PRISONER, COLLECT_TAX
}

请求

public class Request {

    private final RequestType type;

    private final String requestDescription;

    private boolean handled;

    public Request(final RequestType type, final String requestDescription) {
        this.type = Objects.requireNonNull(type);
        this.requestDescription = Objects.requireNonNull(requestDescription);
    }

    public RequestType getType() {
        return type;
    }

    public String getRequestDescription() {
        return requestDescription;
    }

    public void markHandled(){
        this.handled = true;
    }

    public boolean isHandled() {
        return handled;
    }

    @Override
    public String toString(){
        return getRequestDescription();
    }
}

请求处理抽象类

public abstract class RequestHandler {
    private RequestHandler next;

    public RequestHandler(RequestHandler next) {
        this.next = next;
    }

    public void handlerRequest(Request request) {
        if (request != null) {
            next.handlerRequest(request);
        }
    }

    protected void printHandling(Request request) {
        System.out.println(MessageFormat.format("{0} handling \"{1}\"", this, request));
    }

    @Override
    public abstract String toString();
}

指挥官

public class Commander extends RequestHandler {
    public Commander(RequestHandler next) {
        super(next);
    }

    @Override
    public void handlerRequest(Request request) {
        if (request.getType().equals(RequestType.DEFEND_CASTLE)) {
            printHandling(request);
            request.markHandled();
        } else {
            System.out.println("Commander can't handle");
            super.handlerRequest(request);
        }
    }

    @Override
    public String toString() {
        return null;
    }
}

军官

public class Officer extends RequestHandler {
    public Officer(RequestHandler next) {
        super(next);
    }

    @Override
    public void handlerRequest(Request request) {
        if (request.getType().equals(RequestType.TORTURE_PRISONER)){
            printHandling(request);
            request.markHandled();
        }else {
            System.out.println("Officer can't handle");
            super.handlerRequest(request);
        }
    }

    @Override
    public String toString() {
        return "Officer";
    }
}

士兵

public class Soldier extends RequestHandler {


    public Soldier(RequestHandler handler) {
        super(handler);
    }

    @Override
    public void handlerRequest(Request request) {
        if (request.getType().equals(RequestType.COLLECT_TAX)){
            printHandling(request);
            request.markHandled();
        }else {
            System.out.println("Soldier can't handle");
            super.handlerRequest(request);
        }
    }

    @Override
    public String toString() {
        return "Soldier";
    }
}

国王，确定执行链

public class King {

    RequestHandler chain;

    public King() {
        chain = buildChain();
    }

    private RequestHandler buildChain() {
        return new Commander(new Officer(new Soldier(null)));
    }

    public void markRequest(Request request) {
        chain.handlerRequest(request);
    }
}

测试

  @Test
    public void chainTest(){
        King king = new King();
        Request request = new Request(RequestType.COLLECT_TAX,"soldier handle");
        king.markRequest(request);
        System.out.println(request.isHandled());
    }

类图