Java责任链模式(Chain of Responsibility)

一、定义：
       在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。
二、责任链模式的结构

       责任链模式涉及到的角色如下所示：

     （1）抽象处理者(Handler)角色：定义出一个处理请求的接口。如果需要，接口可以定义 出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用，抽象方法handleRequest()规范了子类处理请求的操作。

     （2）具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

三、示例程序

抽象处理者角色（Handler）

public abstract class Handler {

	// 持有后继的责任对象
	protected Handler successor;

	// 示意处理请求的方法，虽然这个示意方法是没有传入参数的 但实际是可以传入参数的，根据具体需要来选择是否传递参数
	public abstract void handleRequest();

	// 取得后继的责任对象
	public Handler getSuccessor() {
		return successor;
	}

	// 设置后继的责任对象
	public void setSuccessor(Handler successor) {
		this.successor = successor;
	}
}

具体处理者角色（ConcreteHandler）

public class ConcreteHandlerA extends Handler {

	// 处理方法，调用此方法处理请求
	@Override
	public void handleRequest() {

		// 判断是否有后继的责任对象 如果有，就转发请求给后继的责任对象 如果没有，则处理请求
		if (getSuccessor() != null) {
			System.out.println("A放过这个请求");
			getSuccessor().handleRequest();
		} else {
			System.out.println("A处理这个请求");
		}
	}
}

public class ConcreteHandlerB extends Handler {

	// 处理方法，调用此方法处理请求
	@Override
	public void handleRequest() {

		// 判断是否有后继的责任对象 如果有，就转发请求给后继的责任对象 如果没有，则处理请求
		if (getSuccessor() != null) {
			System.out.println("B放过这个请求");
			getSuccessor().handleRequest();
		} else {
			System.out.println("B处理这个请求");
		}
	}
}

客户端:

public class Client {

	public static void main(String[] args) {
		// 组装责任链
		Handler handler1 = new ConcreteHandlerA();
		Handler handler2 = new ConcreteHandlerB();
		handler1.setSuccessor(handler2);
		// 提交请求
		handler1.handleRequest();
	}
}

实验结果：

A放过这个请求
B处理这个请求

四、Filter实例说明责任链模式

      在处理用户的请求时可能要根据不同的情况对请求添加不同的处理逻辑，在这时候就可以利用责任链进行设计。当需要添加一个处理逻辑时可以很方便的添加一个处理的节点。现在我们的需求是处理用户的请求，将用户提交的字符串信息进行层层处理，同时在处理完成之后返回结果时，也要对返回的字符串进行层层处理，而处理返回的情况时其处理的顺序和先前是正好相反的顺序。
      在FilterChain中继承了Filter接口，从而实现了doFilter方法，在FilterChain中又有一个index变量，该变量是用来标记当前访问的是哪一个过滤器，这些过滤器是存放在ArrayList中的，这样用户在使用的时候就可以实现自己的过滤器，编写自己的处理逻辑，从而将自己的过滤器添加到ArrayList中，再调用FilterChain的doFilter方法遍历整个责任链。
1）首先建立用户的请求和接收对象Request和Response：

public class Request {  
    String requestStr;  
  
    public String getRequestStr() {  
        return requestStr;  
    }  
  
    public void setRequestStr(String requestStr) {  
        this.requestStr = requestStr;  
    }  
}

public class Response {  
    String responseStr;  
  
    public String getResponseStr() {  
        return responseStr;  
    }  
  
    public void setResponseStr(String responseStr) {  
        this.responseStr = responseStr;  
    }  
}

我们将处理用户信息的逻辑抽象成为一个个的过滤器，进一步抽象出过滤器接口Filter：

public interface Filter {  
    public void doFilter(Request request, Response response, FilterChain chain);  
  
}

注意在Filte接口中doFilter方法参数中有FilterChain的一个变量，我们再建立FilterChain类：

import java.util.ArrayList;  
import java.util.List;  
public class FilterChain implements Filter {  
    List<Filter> filters = new ArrayList<Filter>();  
    int index = 0;  
  
    public FilterChain addFilter(Filter f) {  
        this.filters.add(f);  
        return this;  
    }
    @Override  
    public void doFilter(Request request, Response response, FilterChain chain) {  
        if (index == filters.size())  
            return;  
        Filter f = filters.get(index);  
        index++;  
        f.doFilter(request, response, chain);  
    }  
}

下面我们编写三个过滤器：

public class HTMLFilter implements Filter {  
    @Override  
    public void doFilter(Request request, Response response,FilterChain chain) {  
        request.requestStr = request.getRequestStr().replace("<", "[")  
                .replace(">", "] --------HTMLFilter");  
        chain.doFilter(request, response, chain);  
        response.responseStr += "--------HTMLFilter";  
    }  
}

public class SesitiveFilter implements Filter {  
    @Override  
    public void doFilter(Request request, Response response, FilterChain chain) {  
        request.requestStr = request.getRequestStr().replace("敏感", "  ")  
                .replace("猫猫", "haha------SesitiveFilter");  
        chain.doFilter(request, response, chain);  
        response.responseStr += "------SesitiveFilter";  
    }  
}

public class FaceFilter implements Filter {  
    @Override  
    public void doFilter(Request request, Response response, FilterChain chain) {  
        request.requestStr = request.getRequestStr().replace(":)",  
                "^V^-------FaceFilter");  
        chain.doFilter(request, response, chain);  
        response.responseStr += "-------FaceFilter";  
    }  
}

public class Client {
	public static void main(String[] args) {
		String message = "敏感词汇，重庆，<script> 躲猫猫 :)";
		Request request = new Request();
		request.setRequestStr(message);
		Response response = new Response();
		response.setResponseStr("response");
		FilterChain fc = new FilterChain();
		fc.addFilter(new HTMLFilter()).addFilter(new SesitiveFilter());
		fc.doFilter(request, response, fc);
		System.out.println("request = " + request.getRequestStr());
		System.out.println("response = " + response.getResponseStr());
		System.out.println("=====================================");
		FilterChain fc2 = new FilterChain();
		fc2.addFilter(new FaceFilter());
		fc.addFilter(fc2);
		fc.doFilter(request, response, fc);
		System.out.println("request = " + request.getRequestStr());
		System.out.println("response = " + response.getResponseStr());
	}
}

运行结果：

request =   词汇，重庆，[script] --------HTMLFilter 躲haha------SesitiveFilter :)
response = response------SesitiveFilter--------HTMLFilter
=====================================
request =   词汇，重庆，[script] --------HTMLFilter 躲haha------SesitiveFilter ^V^-------FaceFilter
response = response------SesitiveFilter--------HTMLFilter-------FaceFilter

          对于实现责任链的访问处理顺序问题，该问题的解决使用的是递归的思想，从而使先调用的结点在处理返回结果时其调用过滤器的顺序是相反的。这种解决方案在Struts和其他框架中实现过滤器和拦截器使用的较为普遍，并且十分巧妙。哪一个对象最终处理一个命令可以指定由哪些处理器对象参加责任链、这些对象在责任链上的位置可以设定。
在下面的情况下使用责任链模式：
　　第一、系统已经有一个由处理者对象组成的链，这个链可能由复合模式给出；
　　第二、当有多于一个的处理者对象会处理一个请求，而且在事先并不知道到底由哪一个处理者对象处理一个请求。这个处理者对象是动态确定的；
　　第三、当系统想发出一个请求给多个处理者对象中的某一个，但是不明显指定是哪一个处理者对象会处理此请求；
　　第四、当处理一个请求的处理者对象集合需要动态地指定时。
      优点：降低了耦合、提高了灵活性。因为无法预知来自外界（客户端）的请求是属于哪种类型，每个类如果碰到它不能处理的请求只要放弃就可以。发出命令的对象只是把命令传给链结构的起始者，而不需要知道到底是链上的哪一个节点处理了这个命令。
      缺点：效率低，因为它要从链子开头开始遍历，但是一个请求的完成可能要遍历到最后才可能完成，所以可能会带来一些额外的性能损耗。