1. 定义

为请求创建了一个接收者对象的链。

2. 案例

来一个请求，需要经过很多步处理，每一步处理成功后才能进行下一步，所有实现都放process中也可实现，但是不利于扩展维护：

Request：用建造者模式模拟请求频率、登录验证、访问权限、敏感词是否成功

class Request {
    private boolean loggedOn;//是否登录
    private boolean frequentOk;//是否请求频繁
    private boolean isPermits;//是否有访问权限
    private boolean containsSensitiveWords;//是否有敏感词
    public Request(boolean loggedOn, boolean frequentOk, boolean isPermits, boolean containsSensitiveWords) {
        this.loggedOn = loggedOn;
        this.frequentOk = frequentOk;
        this.isPermits = isPermits;
        this.containsSensitiveWords = containsSensitiveWords;
    }
    public boolean isLoggedOn() {
        return loggedOn;
    }
    public boolean isFrequentOk() {
        return frequentOk;
    }
    public boolean isPermits() {
        return isPermits;
    }
    public boolean isContainsSensitiveWords() {
        return containsSensitiveWords;
    }
    //构造器：静态内部类
    static class RequestBuilder {
        private boolean loggedOn;
        private boolean frequentOk;
        private boolean isPermits;
        private boolean containsSensitiveWords;
        RequestBuilder loggedOn(boolean loggedOn) {
            this.loggedOn = loggedOn;
            return this;
        }
        RequestBuilder frequentOk(boolean frequentOk) {
            this.frequentOk = frequentOk;
            return this;
        }
        RequestBuilder isPermits(boolean isPermits) {
            this.isPermits = isPermits;
            return this;
        }
        RequestBuilder containsSensitiveWords(boolean containsSensitiveWords) {
            this.containsSensitiveWords = containsSensitiveWords;
            return this;
        }
        public Request build() {
            Request request = new Request(loggedOn, frequentOk, isPermits, containsSensitiveWords);
            return request;
        }
    }
}

定义处理器链表：

//定义链表
abstract class Handler {
    Handler next;
    public Handler(Handler next) {
        this.next = next;
    }
    public Handler getNext() {
        return next;
    }
    public void setNext(Handler next) {
        this.next = next;
    }
    //处理每个节点
    abstract boolean process(Request request);
}

请求频率处理

// 请求频率处理
class FrequentHandler extends Handler {
    public FrequentHandler(Handler next) {
        super(next);
    }
    @Override
    boolean process(Request request) {
        System.out.println("访问频率控制.");
        if (request.isFrequentOk()) {
            Handler next = getNext();
            if (next == null) {
                return true;
            }
            //处理下个节点
            if (!next.process(request)) {//下个节点处理失败，返回false
                return false;
            } else {
                return true;
            }
        }
        return false;
    }
}

登录处理

//登录处理
class LoggingHandler extends Handler {
    public LoggingHandler(Handler next) {
        super(next);
    }
    @Override
    boolean process(Request request) {
        System.out.println("登录验证.");
        if (request.isLoggedOn()) {
            Handler next = getNext();
            if (next == null) {
                return true;
            }
            //处理下个节点
            if (!next.process(request)) {//下个节点处理失败，返回false
                return false;
            } else {
                return true;
            }
        }
        return false;
    }
}

权限、敏感词handler省略….

使用：

    public static void main(String[] args) {
        Request request = new Request.RequestBuilder().frequentOk(true).loggedOn(true).build();
        FrequentHandler handler = new FrequentHandler(new LoggingHandler(null));
        if (handler.process(request)) {
            System.out.println("正常业务处理");
        } else {
            System.out.println("访问异常");
        }
        //------输出--------
        //访问频率控制.
        //登录验证.
        //正常业务处理
        Request request2 = new Request.RequestBuilder().frequentOk(false).loggedOn(true).build();
        FrequentHandler handler2 = new FrequentHandler(new LoggingHandler(null));
        if (handler.process(request2)) {
            System.out.println("正常业务处理");
        } else {
            System.out.println("访问异常");
        }
        //------输出--------
        //访问频率控制.
        //访问异常
    }

3. 应用场景：

一个请求的处理需要多个对象当中的一个或几个协作处理。

4. 优点:

1. 请求的发送者和接受者解耦
2. 可以控制执行顺序
3. 符合开闭原则和单一职责原则

   5. 源码应用

   javax.servlet.Filter 
   javax.servlet.FilterChain