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缺点：

长处：

请求者与处理者代码分离：减少了耦合度。

缺点：责任链像一条链表一样，效率可能会有问题。

不能保证请求一定被收到

---

贴张网上图片