By

概述

责任链主要应用在如下场景：客户端发出一个请求，很多对象都有机会来处理这个请求，这些能够处理这个请求的对象组成一个责任链，客户发出的请求可以顺着这个责任链传递。
这个责任链是可以动态变化的，也就是客户端请求的处理流程是可以变化的。责任链中的各个处理请求的对象时可以替换的。
在标准的责任链模式中，只要有对象处理了请求，这个请求就不再被处理和传递了。但是也有种变体：每个责任链的对象都对这个请求进行一定功能处理，而不是被处理后就停止，这种变体一般称为功能链。

责任链的组织方式：

责任链中最关键的问题是如何组织这个责任链，一般有如下几种方式：

  1. 在客户端组合责任链，这种称为外部链。
  2. 在Handler类中实现链的组合，这种称为内部链。
  3. 在各个职责对象中，各个职责对象自己决定后续的处理对象。

责任链的创建可以在程序中动态组合，也可以通过数据库或者配置文件来记录组合信息。
每个对象都会按照条件来判断是否属于自己处理的范围，如果是就处理，如果不是就转发请求给下个对象，如果传到最后还是没有被处理就传给默认的处理对象对其进行处理。

在责任链模式中，请求者和接收者之间是一种松散耦合的关系。请求者并不知道接收者是谁，也不知道具体将会如何处理，请求者只是负责向责任链发出请求，而每个处理对象也不管请求者或者是其他的职责对象，只负责处理自己的部分，其他就交给其他的处理对象来处理。
并且责任链是动态的，责任链上的处理对象都是可换的。

public interface Handler {
    public void setNext(Handler handler);
    public void handleRequest(Request rq);
} 
public class HandlerOne implements Handler {
    private int HandleCode = 1;
    private Handler mNextHandler = null;
    public void setNext(Handler handler) {
        mNextHandler = handler;
        
    }
    public void handleRequest(Request rq) {
        if(rq.getRequestCode() == HandleCode) {
            System.out.println("This Request has been handle by HandlerOne");
        }else {
            if(mNextHandler != null) {
                mNextHandler.handleRequest(rq);
            }
        }
    }
}
public class HandlerTwo implements Handler {
    private int HandleCode = 2;
    private Handler mNextHandler = null;
    public void setNext(Handler handler) {
        mNextHandler = handler;
        
    }
    public void handleRequest(Request rq) {
        if(rq.getRequestCode() == HandleCode) {
            System.out.println("This Request has been handle by HandlerTwo");
        }else {
            if(mNextHandler != null) {
                mNextHandler.handleRequest(rq);
            }
        }
    }
}
public class HandlerThree implements Handler {
    private int HandleCode = 3;
    private Handler mNextHandler = null;
    public void setNext(Handler handler) {
        mNextHandler = handler;
    }
    public void handleRequest(Request rq) {
        if(rq.getRequestCode() == HandleCode) {
            System.out.println("This Request has been handle by HandlerThree");
        }else {
            if(mNextHandler != null) {
                mNextHandler.handleRequest(rq);
            }
        }
    }
}
public class DefaultHandler implements Handler {
    public void setNext(Handler handler) {
        throw new UnsupportedOperationException();
    }
    public void handleRequest(Request rq) {
        System.out.println("This Request has been handle by DefaultHandler");
    }
}
public class Request {
    private int requestCode = -1;
    public void setRequestCode(int requestCode) {
        this.requestCode = requestCode;
    }
    public int getRequestCode() {
        return requestCode;
    }
} 
public class Client {
    public static void main(String[] args) {
        Handler handler1 = new HandlerOne();
        Handler handler2 = new HandlerTwo();
        Handler handler3 = new HandlerThree();
        Handler handler4 = new DefaultHandler();
        
        handler1.setNext(handler2);
        handler2.setNext(handler3);
        handler3.setNext(handler4);
        
        Request request = new Request();
        request.setRequestCode(2);
        handler1.handleRequest(request);
    }
}
Contents
  1. 1. 概述
  2. 2. 责任链的组织方式：