java 设计模式 -- 责任链模式

设计模式 – 责任链模式

介绍：

责任链模式是一种动态行为模式，有多个对象，每个对象分别拥有其下家的引用，连起来形成一条链，待处理对象则传到此链上，在此链进行传递，且待处理对象并不知道此会被链上的哪个对象处理，这使得我们可以动态的增加链上的对象并且分配责任。

纯责任链和非纯责任链

责任链分为两种，纯责任链和非纯责任链。
纯责任链是待处理对象request在处理对象handler链上传递，每个处理对象handler处理request的一部分，到最终处理完毕，非纯责任链则是待处理对象request在处理对象handler链上传递，每个处理对象handler要么把request拿出来全部处理，要不就不处理，留给下一个handler。

实现(非纯责任链)：

场景：
必须满足一定的条件时处理对象（handler）才能处理待处理对象（request），否则在责任链中传递下去，代码中我用的是能力值abilityToValue，handler满足能力值大于request即可处理，否则在责任链中传递下去。

Handler.java

/**
 * Created by wwh on 15-7-30.
 */
public abstract class Handler {

    /* 能力值 */
    protected int abilityToValue = 0;

    /* 持有下一个对象的引用 */
    protected Handler nextHandler;

    /* 具体的处理方法 */
    public abstract void handleRequest(int vaule);

    /* 得到下一个对象的引用 */
    public Handler getNextHandler(){
        if(nextHandler != null) {
            return nextHandler;
        }
        else{
            /* 到达责任链末尾，未能处理 */
            System.out.println("该待处理对象被责任链放过...");
        }
        return null;
    }

    /* 设置后继的处理对象 */
    public void setNextHandler(Handler nextHandler){
        if(nextHandler != null) {
            this.nextHandler = nextHandler;
        }else{
            System.out.println("到达末尾，设置完成责任链");
        }
    }
}

class HandlerRequest_one extends Handler{
    /* 设置能力值 */
    HandlerRequest_one(int atv){
        this.abilityToValue = atv;
    }
    /* 具体的处理请求方法 */
    @Override
    public void handleRequest(int value) {
        /* 如果处理对象的能力值在100-200范围内，那么处理此请求，
        否则没有能力处理此请求，交给下一个handler */
        if(abilityToValue > value){
            System.out.println("HandlerRequest_one 处理请求");
        }else{
            System.out.println("HandlerRequest_one 放过请求，传递给下一个Handler");
            if(getNextHandler() != null)
                getNextHandler().handleRequest(value);
        }
    }
}

class HandlerRequest_two extends Handler{
    /* 设置能力值 */
    HandlerRequest_two(int atv){
        this.abilityToValue = atv;
    }

    @Override
    public void handleRequest(int value) {
        /* 如果处理对象的能力值在200-400范围内，那么处理此请求，
        * 否则没有能力处理此请求，交给下一个handler */
        if(abilityToValue > value){
            System.out.println("HandlerRequest_two 处理请求");
        }else{
            System.out.println("HandlerRequest_two 放过请求，传递给下一个handler");
            if(getNextHandler() != null)
                getNextHandler().handleRequest(value);
        }
    }
}

request.java

/**
 * Created by wwh on 15-7-30.
 */
public class Request {
    public int ablity;
    Request(int ablity){ this.ablity = ablity; }
    public static void main (String[] args) throws Exception{
        Handler hd1 = new HandlerRequest_one(100);
        Handler hd2 = new HandlerRequest_two(500);
        hd1.setNextHandler(hd2);
        /* 情况1 */
        Request req1 = new Request(50);
        hd1.handleRequest(req1.ablity);
        System.out.println("-------------------------");
        /* 情况2 */
        Request req2 = new Request(300);
        hd1.handleRequest(req2.ablity);
        System.out.println("-------------------------");
        /* 情况3 */
        Request req3 = new Request(500);
        hd1.handleRequest(req3.ablity);
    }
}

结果：

责任链模式在java中应用很多，除了最近在看的netty中的Pipeline，还有Servlet中的过滤器（Filter），Struts2的拦截器（Interceptor）。

优点and缺点：

优点：
请求者与处理者代码分离：降低了耦合度。
缺点：责任链像一条链表一样，效率可能会有问题。不能保证请求一定被收到

贴张网上图片