设计模式系列之「责任链模式」

“长安回望绣成堆，山顶千门次第开。一骑红尘妃子笑，无人知是荔枝来”。杜牧的《过华清宫》流传千古，杨贵妃喜食荔枝也成为众所周知的事情。杨贵妃吃的荔枝必须在采摘后的几天内送到，如果超过了四五天，荔枝就会腐烂，在古代路途遥远和交通不便成为了致命伤，为了让杨贵妃吃到新鲜的荔枝而不劳民伤财，小Y决定让杨贵妃和现代物流来一个偶遇。

杨贵妃： 大王，臣妾想吃新鲜可口的荔枝（一阵撒娇声，各位各自想象）。

唐玄宗： “ok！No趴笨”。然后马上召来路人甲，让路人甲无论如何都要在三天之内把荔枝送来，不然以死谢罪。

朝中大臣纷纷幸灾乐祸，觉得路人甲肯定会死无葬身之地的。但是路人甲胸有成竹的领命而去 （路人甲之所以这么信心十足，是因为路人甲曾得神秘高人Y指点，说命中必有一劫，只有按照几千年后的现代做法建一套有效的物流方法方可避过此劫，所以路人甲就按照神秘高人Y指点秘密在全国各地建造一个物流据点，然后通过特制的千里箭进行通讯） 。

回到家中的路人甲里面把荔枝的货物需求绑在千里箭中并射向了最近的据点bj仓，bj仓的负责人收到之后，发现这个仓中没有，然后又把这个需求通过千里箭射向了js仓，但最终在gd仓找到了货物，再通过特制的飞鹞在三天内把货物送到杨贵妃所在的地方。

杨贵妃吃到了新鲜的荔枝之后，心情大悦，路人甲也因此仕途畅通无阻。

本故事终，故事纯属小Y瞎掰，哇哈哈哈。

一、路人甲如何建立行之有效的物流系统

神秘高人Y把几千年后的发达物流模式传授给了路人甲，要求在全国各大城市建立据点。

1.粗糙期

①荔枝的接口

public interface ILiZhi {
	//得到荔枝的品种
	public int getType();
	//每个仓库中得到荔枝订单的请求
	public String getRequest();
}
复制代码

②定义荔枝的具体类

public class LiZhi implements ILiZhi {

	//荔枝的种类，1代表糯米糍 2代表桂味 3代表槐味
	private int type=0;
	//荔枝的订单需求
	private String request;

	public LiZhi(int type,String request) {
		this.type = type;
		this.request=request;
	}

	@Override
	public int getType() {
		return type;
	}

	@Override
	public String getRequest() {
		return request;
	}
}
复制代码

③定义一个据点接口

public interface ILiZhiHouse {
	//处理订单需求
	public void dealWithRequest(ILiZhi iLiZhi);
}
复制代码

④bj据点，只有糯米糍荔枝

public class BJHouse implements ILiZhiHouse {
	@Override
	public void dealWithRequest(ILiZhi iLiZhi) {
		System.out.println("订单需求："+iLiZhi.getRequest());
		System.out.println("货物已由bj据点火速送出");
	}
}
复制代码

⑤js据点，只有桂味荔枝

public class JSHouse implements ILiZhiHouse {
	@Override
	public void dealWithRequest(ILiZhi iLiZhi) {
	System.out.println("订单需求："+iLiZhi.getRequest());
	System.out.println("货物已由js据点火速送出");
	}
}
复制代码

⑥gd据点，只有槐味荔枝

public class GDHouse implements ILiZhiHouse {
	@Override
	public void dealWithRequest(ILiZhi iLiZhi) {
	System.out.println("订单需求："+iLiZhi.getRequest());
	System.out.println("货物已由gd据点火速送出");
	}
}
复制代码

物流系统建好了，现在就等杨贵妃下达荔枝需求了。

⑦杨贵妃一声令下，要求三天之内把糯米糍、桂味、槐味全部送达

public class Client {

	public static void main(String[] args) {
		//1代表糯米糍 2代表桂味 3代表槐味

		//路人甲根据杨贵妃的要求组装需求
		List<ILiZhi> liZhis=new ArrayList<>();
		liZhis.add(new LiZhi(1,"需要糯米糍30斤"));
		liZhis.add(new LiZhi(2,"需要桂味30斤"));
		liZhis.add(new LiZhi(3,"需要槐味30斤"));

		//定义三个据点
		BJHouse bjHouse=new BJHouse();
		JSHouse jsHouse=new JSHouse();
		GDHouse gdHouse=new GDHouse();

		for(ILiZhi liZhi:liZhis){
			if(liZhi.getType()==1){
				bjHouse.dealWithRequest(liZhi);
			}else if(liZhi.getType()==2){
				jsHouse.dealWithRequest(liZhi);
			}else if(liZhi.getType()==3){
				gdHouse.dealWithRequest(liZhi);
			}else{
			System.out.println("没有建立这样的据点，只能坐等死了。");
			}
		}
	}
}
复制代码

⑧运行结果

订单需求：需要糯米糍30斤
货物已由bj据点火速送出

订单需求：需要桂味30斤
货物已由js据点火速送出

订单需求：需要槐味30斤
货物已由gd据点火速送出
复制代码

这个就是早期路人甲根据神秘高人Y方法建立的一套物流系统，路人甲觉得这套系统已经完美无缺了，但是给神秘高人Y一看，立马指出了一下问题：

• Client的代码臃肿，不同的荔枝品种就需要增加一个判断，随着品种的增多会造成if...else的判断越来越多，很容易出现混乱，可读性不强。

• 耦合过重，违背开闭原则。

• 异常处理不合理。如果路人甲把糯米糍的订单直接发到了配送桂味的据点，那么桂味据点无法处理这个订单呀，不处理的话那么路人甲就要坐等死了。

路人甲一看分析出这么多问题，立马根据需求设计了一个新的物流系统：订单下来，由近到远的据点一个个分配订单，比如说桂味订单到了bj据点，bj据点处理不了，只能把这个订单继续往下一个据点传递，到达js据点能够处理就进行配送，不需要再外下一个据点进行传递了，即必然有一个唯一的据点给出唯一的答复。

2.完善期

(1)据点UML

(2)改进后的物流系统代码

①荔枝的接口

public interface ILiZhi {
	//得到荔枝的品种
	public int getType();
	//每个仓库中得到荔枝订单的请求
	public String getRequest();
}
复制代码

②定义荔枝的具体类

public class LiZhi implements ILiZhi {

	//荔枝的种类，1代表糯米糍 2代表桂味 3代表槐味
	private int type=0;
	//荔枝的订单需求
	private String request;

	public LiZhi(int type,String request) {
		this.type = type;
		this.request=request;
	}

	@Override
	public int getType() {
		return type;
	}

	@Override
	public String getRequest() {
		return request;
	}
}
复制代码

③定义一个抽象据点类

public abstract class ILiZhiHouse {

	//定义三种类型
	public final static int BJ_TYPE_REQUEST = 1;
	public final static int JS_TYPE_REQUEST = 2;
	public final static int GD_TYPE_REQUEST = 3;	

	//责任传递，下一个人责任人是谁
	private ILiZhiHouse liZhiHouse;
	//能处理的订单
	private int type =0;

	public ILiZhiHouse(int type) {
		this.type = type;
	}

	//分发请求
	public void handleMessage(ILiZhi iLiZhi){
		if(iLiZhi.getType()==type){
			this.dealWithRequest(iLiZhi);
		}else{
			if(this.liZhiHouse!=null){
				this.liZhiHouse.handleMessage(iLiZhi);
			}else{
				System.out.println("没有建立这样的据点，只能坐等死了。");
			}
		}

	}
	//设置下一个据点是哪个
	public void setNext(ILiZhiHouse liZhiHouse){
		this.liZhiHouse=liZhiHouse;
	}
	//处理订单需求
	public abstract void dealWithRequest(ILiZhi iLiZhi);
}
复制代码

④bj据点，只有糯米糍荔枝

public class BJHouse extends ILiZhiHouse {

	public BJHouse() {
		super(BJ_TYPE_REQUEST);
	}

	@Override
	public void dealWithRequest(ILiZhi iLiZhi) {
		System.out.println("订单需求："+iLiZhi.getRequest());
		System.out.println("货物已由bj据点火速送出");
	}
}
复制代码

⑤js据点，只有桂味荔枝

public class JSHouse extends ILiZhiHouse {

	public JSHouse() {
		super(JS_TYPE_REQUEST);
	}

	@Override
	public void dealWithRequest(ILiZhi iLiZhi) {
		System.out.println("订单需求："+iLiZhi.getRequest());
		System.out.println("获取已由js据点火速送出");
	}
}
复制代码

⑥gd据点，只有槐味荔枝

public class GDHouse extends ILiZhiHouse {
	public GDHouse() {
		super(GD_TYPE_REQUEST);
	}

	@Override
	public void dealWithRequest(ILiZhi iLiZhi) {
		System.out.println("订单需求："+iLiZhi.getRequest());
		System.out.println("获取已由gd据点火速送出");
	}
}
复制代码

⑦配送荔枝

public class Client {

	public static void main(String[] args) {
		//1代表糯米糍 2代表桂味 3代表槐味

		//路人甲根据杨贵妃的要求组装需求
		List<ILiZhi> liZhis=new ArrayList<>();
		liZhis.add(new LiZhi(ILiZhiHouse.BJ_TYPE_REQUEST,"需要糯米糍30斤"));
		liZhis.add(new LiZhi(ILiZhiHouse.JS_TYPE_REQUEST,"需要桂味30斤"));
		liZhis.add(new LiZhi(ILiZhiHouse.GD_TYPE_REQUEST,"需要槐味30斤"));

		//定义三个据点
		BJHouse bjHouse=new BJHouse();
		JSHouse jsHouse=new JSHouse();
		GDHouse gdHouse=new GDHouse();
		//根据据点远近设定顺序
		bjHouse.setNext(jsHouse);
		jsHouse.setNext(gdHouse);

		for(ILiZhi liZhi:liZhis){
			bjHouse.handleMessage(liZhi);
		}
	}
}
复制代码

⑧运行结果

订单需求：需要糯米糍30斤
货物已由bj据点火速送出

订单需求：需要桂味30斤
货物已由js据点火速送出

订单需求：需要槐味30斤
货物已由gd据点火速送出
复制代码

业务调用类Client也不用去做判断到底是需要谁去处理，而且ILiZhiHouse抽象类的子类可以继续增加下去，只需要扩展传递链而已，调用类可以不用了解变化过程，甚至是谁在处理这个请求都不用知道。

二、基本概念

1.定义

使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

2.责任链的重点

责任链模式的重点是在“链”上，由一条链去处理相似的请求在链中决定谁来处理这个请求，并返回相应的结果。

3.角色介绍

• Handler
  抽象的处理者实现三个职责：一是定义一个请求的处理方法handleMessage；二是定义一个链的编排方法setNext，设置下一个处理者；三是定义了具体的请求者必须实现的两个方法：定义自己能够处理的级别和具体的处理任务。

• ConcreteHandler
  责任链模式的核心在“链”上，“链”是由多个处理者ConcreteHandler组成的。具体的请求者必须实现的两个方法：定义自己能够处理的级别和具体的处理任务。

三、责任链模式优缺点

1.优点

• 责任链模式非常显著的优点是将请求和处理分开。请求者可以不用知道是谁处理的，处理者可以不用知道请求的全貌，，两者解耦，提高系统的灵活性

2.缺点

• 性能问题。每个请求都是从链头遍历到链尾，特别是在链比较长的时候，性能是一个非常大的问题

• 调试不很方便，特别是链条比较长，环节比较多的时候，由于采用了类似递归的方式，调试的时候逻辑可能比较复杂。

四、总结

链中节点数量需要控制，避免出现超长链的情况，一般的做法是在Handler中设置一个最大节点数量，在setNext方法中判断是否已经是超过其阈值，超过则不允许该链建立，避免无意识地破坏系统性能。