责任链模式

《ａｎｄｒｏｉｄ设计模式》读书笔记，如有侵权，请尽快与我联系删除，谢谢

一。定义

　　责任链模式，是行为型设计模式之一。对于链，就是由多个节点相连构成的模型，对于链式结构，每个节点都可以被拆开再连接，很灵活。应用到编程领域，将每个节点看成一个对象，每个对象拥有不同的处理逻辑，将一个请求从链式的首部发出，沿着链的路径依次传递给每一个节点对象，直至有对象处理这个请求为止，我们将这样一种模式称为责任链模式。
　　使多个对象都由机会处理请求，从而避免了请求的发送者与接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。
二。使用场景
（１）多个对象可以处理同一个请求，但具体由哪个对象处理则在运行时动态决定
（２）在请求处理者不明确的情况下，向多个对象中的一个提出一个请求
（３）需要动态制定一组对象处理请求。
三。代码实现
简化版，请求的对象是固定的字符串
***********************************************************************************************
package com.yinazh.designpattern;

//抽象处理者的角色，声明一个请求处理的方法，并保持一个对下一个节点对象的引用
public abstract class Handler{
public Handler successor;//下一个节点的处理者

public abstract void handleRequest(String condition); //请求处理
}

//具体处理者，对请求进行处理如果不能处理，则将请求发给下一个节点上的处理者
public class ConcreteHandler1 extends Handler{
public void handleRequest(String condition){
if(condition.equals("ConcreteHandler1")){
System.out.println("ConcreteHandler1 handled");
return;
}else{
successor.handleRequest(condition);
}
}
}

public class ConcreteHandler2 extends Handler{
public void handleRequest(String condition){
if(condition.equals("ConcreteHandler2")){
System.out.println("ConcreteHandler2 handled");
return;
}else{
successor.handleRequest(condition);
}
}
}

public class Client{
public static void main(String[] args){
ConcreteHandler1 handler1 = new ConcreteHandler1();
ConcreteHandler2 handler2 = new ConcreteHandler2();
handler1.successor = handler2;//设置下一个节点
handler2.successor = handler1;//设置下一个节点
handler1.handleRequest("ConcreteHandler2");
}
}

***********************************************************************************************
然而，多数情况下，责任链中的请求和对应的处理规则是不尽相同的，在这种情况下，可以将请求进行封装，同时对请求的处理规则也进行封装作为一个独立的对象，实现如下：
***********************************************************************************************
package com.yinazh.designpattern;

public abstract class AbstractHandler{
protected AbstractHandler nextHandler;//下一个节点上的处理者对象

　　　　//处理请求
public final void handleRequest(AbstractRequest request){
if(getHandlerLevel() == request.getHandlerLevel()){//判断当前的处理者对象的级别是否与请求者的级别一致
handle(request);//一致，则处理
}else{
if(nextHandler != null){//否则将请求转发给下一个处理者
nextHandler.handleRequest(request);
}else{//所有的处理者对象都不能处理该请求时，输出
System.out.println("All of handler can not handle the request");
}
}
}

protected abstract int getHandlerLevel();//获取处理者对象的处理级别

protected abstract void handle(AbstractRequest request);//处理请求方法
}

//下面实现三个不同级别的处理者
public class Handler1 extends AbstractHandler{
protected int getHandlerLevel(){
return 1;
}
protected void handle(AbstractRequest request){
System.out.println("handle1 handle request:" + request.getRequestLevel());
}
}

public class Handler2 extends AbstractHandler{
protected int getHandlerLevel(){
return 2;
}
protected void handle(AbstractRequest request){
System.out.println("handle2 handle request:" + request.getRequestLevel());
}
}

public class Handler3 extends AbstractHandler{
protected int getHandlerLevel(){
return 3;
}
protected void handle(AbstractRequest request){
System.out.println("handle3 handle request:" + request.getRequestLevel());
}
}

//抽象请求者，其内部也声明了一个与处理者对应级别的请求级别
public abstract class AbstractRequest{
private Object obj;//处理对象
public AbstractRequest(Object obj){
this.obj = obj;
}

public Object getContent(){//获取请求的内容
return obj;
}

public abstract int getRequestLevel();//请求级别
}

public class Request1 extends AbstractRequest{
public Request1(Object obj){
super(obj);
}
public int getRequestLevel(){
return 1;
}
}

public class Request2 extends AbstractRequest{
public Request2(Object obj){
super(obj);
}
public int getRequestLevel(){
return 2;
}
}

public class Request3 extends AbstractRequest{
public Request3(Object obj){
super(obj);
}
public int getRequestLevel(){
return 3;
}
}

public class Client{
public static void main(String[] args){
AbstractHandler hanlder1 = new Handler1();
AbstractHandler hanlder2 = new Handler2();
AbstractHandler hanlder3 = new Handler3();

handler1.nextHandler = handler2;
handler1.nextHandler = handler3;

AbstractRequest request1 = new Request1("Request1");
AbstractRequest request2 = new Request2("Request2");
AbstractRequest request3 = new Request3("Request3");
handler1.handleRequest(request1);
handler1.handleRequest(request2);
handler1.handleRequest(request3);
}
}
***********************************************************************************************
　　请求的发起可以从责任链的任何一个节点处开始，同事也可以改变责任链内部传递的规则。
四。总结
　　责任链模式可以对请求者和处理者关系解藕，提高代码的灵活性。但如果链中的请求处理者太多，那么请求处理遍历的时候，必然会影响性能。
　　一个纯的责任链模式要求一个具体的处理者对象只能在两个行为中选择一个:一是承担责任，二是把责任推给下家。不允许出现某一个处理对象在承担一部分责任后又把责任传给下家的情况。
　　在一个纯的责任链模式里面，一个请求必须被某一个处理者对象所接收；在一个不纯的责任链模式里，一个请求可以最终不被任何接收端对象所接收。