责任链模式

一个信息的展示需要经过很多层过滤规则处理，在整个规则过滤链路过程中，可以使用责任链模式

过滤规则 可映射为一个 值对象

模式定义：使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

public abstract class Handler {
    private Handler nextHandler;
    private int level;

    public Handler(int level) {
        this.level = level;
    }

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    // final修饰的方法，不能重写
    public final void handleMessage(Request request) {
        if (level == request.getRequestLevel()) {
            this.execute(request);
        } else {
            if (this.nextHandler != null) {
                this.nextHandler.handleMessage(request);
            } else {
                System.out.println("处理链条已经到尽头");
            }
        }
    }

    public abstract void execute(Request request);
}

public class HandlerA extends Handler {
    public HandlerA(int level) {
        super(level);
    }

    // 重写子类具体的执行/判断逻辑
    @Override
    public void execute(Request request) {
        System.out.println("这是处理者A，正在处理A规则");
    }
}

// 省略具体实现...
public class HandlerB extends Handler {
}

// 具体到业务逻辑中，请求可以是一个包含很多内容的context
@AllArgsConstructor
public class Request {
    private int requestLevel;

    public int getRequestLevel() {
        return requestLevel;
    }

    public void setRequestLevel(int requestLevel) {
        this.requestLevel = requestLevel;
    }
}

public class TestMain {
    public static void main(String[] args) {
        // 初始化一个规则链，chainHandler是链表的头结点
        HandlerA chainHandler = new HandlerA(HandlerEnum.A.code);
        HandlerB handlerB = new HandlerB(HandlerEnum.B.code);
        chainHandler.setNextHandler(handlerB);

        // 头结点开始执行不同的规则处理,通过传入不同的context进行规则执行
        chainHandler.handleMessage(new Request(HandlerEnum.A.code));
        chainHandler.handleMessage(new Request(HandlerEnum.B.code));
        chainHandler.handleMessage(new Request(HandlerEnum.DEFAULT.code));
    }
}

输出结果：