设计模式之责任链模式

开篇说明：

我这里所记录的设计模式，可能和原版的有很大的出入，我记录的设计模式只不过是模仿正版的思想，加以修改，取其巧妙的地方，或组装，或改装。

责任链特征：
 * 链上的对象实现同一个接口或者继承抽象类,能够根据逻辑使责任链或链或环或树访问下去
 * 然后通过对这些对象所对接口实现的方法的实现方式不同，或中途调用结束返回，或全部调用

情景剧场：

  这是一个小摊贩和城管的故事：某天一群小摊贩到一个秘密地点密谋一件针对城管的大事，不幸由于内奸消息提前泄露，城管通过内奸的情报和提供的帮助，成功的混入这群小摊贩之中。这群小摊贩中的头头，手头有一个检查是否是城管的利器，为了稳妥起见，头头要对每个小摊贩进行检查。如果没有城管混入则，密谋如期进行，如果混入需要传递消息出去，让没受到检查的小摊贩逃跑，但是已经检查的摊贩一定会被抓。

上边说了链上的对象是实现同一个接口的对象，这些对象所实现接口的方法的逻辑不同，可以决定如何访问方式，和访问的结果。这里我为了省力就写了一个接口实现。根据接口所实现方法的逻辑来决定调用：

具体代码

接口：

package zerenlian;

/**
 * 责任链特征：
 * 链上的对象实现同一个接口或者继承抽象类
 * 然后通过对这些对象所实现的方法的实现方式不同，或中途调用结束返回，或全部调用
 * @author 追本溯源
 *
 */
public interface IUserInfo {
	public String invoke(Central central);
}

如果想按链，环，或树访问下去，形成一个递归式调用时必须的，现我所知道的递归方式实现有两种，自身调用，多方法间的调用。

我这里采用2个方法间的递归。首先让两个方法形成一个环调用(死循环),然后根据想实习的接口 添加一些条件，让他在某个时刻跳出这个环。

而接口刚好规范统一了一个方法，所以不同对接口实现的对象，可以根据同一个接口的方法调用，自身实现的方法。

接口实现：

package zerenlian;

public class AUser implements IUserInfo{
	private String name;
	public AUser(String name){
		this.name = name;
	}
	/** 责任链或链或环或树，想访问下去，递归的想法是必须的**/
	public String invoke(Central central) {
		String str = "";
		if(!name.equals("城管")){
			System.out.println("用户:"+name+"当前处于活动状态");
			str = central.execute();
			if(str.equals("城管来了,大家快跑啊!")){
				System.out.println("用户"+name+"被抓！");
			}
		}else{
			str = "城管来了,大家快跑啊!";
			System.out.println(str);
		}
		return str;
	}
	
}

控制方法：

package zerenlian;

import java.util.List;

public class Central {
	private List<IUserInfo> infos;
	private int cursor = 0;;
	
	public Central(List<IUserInfo> infos){
		this.infos = infos;
	}
	
	public String execute(){
		String str = "";
		if(cursor < infos.size()){
			IUserInfo info = infos.get(cursor++);
			str = info.invoke(this);
		}else{
			str = "还好这次城管没来";
		}
		return str;	
	}
}

测试：

package zerenlian;

import java.util.ArrayList;
import java.util.List;

public class MainTest {
	
	
	public static void main(String[] args) {
		AUser aUser = new AUser("小摊贩A");
		AUser bUser = new AUser("小摊贩B");
		AUser cUser = new AUser("小摊贩C");
		AUser dUser = new AUser("小摊贩E");
		AUser eUser = new AUser("城管");
		List<IUserInfo> infos = new ArrayList<IUserInfo>();
		infos.add(aUser);
		infos.add(bUser);
		infos.add(eUser);
		infos.add(cUser);
		infos.add(dUser);
		
		Central ctrl = new Central(infos);
		ctrl.execute();
		
	}
}

结果：

用户:小摊贩A当前处于活动状态
用户:小摊贩B当前处于活动状态
城管来了,大家快跑啊!
用户小摊贩B被抓！
用户小摊贩A被抓！

一件非常复杂的事，分而治之，分成几个模块，用递归来控制模块所调用的顺序，用逻辑来控制他们调用的方向。

下面在将一个好理解的责任链

情景剧场：

一个人需要请假，但是公司规定：每个员工需要按照请假时间的长短来决定由哪个管理层进行审批。

代码展示

抽象类：

package zerenlian.other;

public abstract class IUserInfo {
	
	private IUserInfo next;
	
	 
	
	public IUserInfo getNext() {
		return next;
	}

	public void setNext(IUserInfo next) {
		this.next = next;
	}



	public abstract void invoke(int leaveday);
	
}

各个继承类

CellManager:

package zerenlian.other;

public class CellManager extends IUserInfo{
	private String name;
	public CellManager(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void invoke(int leaveday) {
		if(leaveday < 3){
			System.out.println("单位经理"+getName()+"同意了");
		}else{
			if(this.getNext()!=null){
				this.getNext().invoke(leaveday);
			}else{
				System.out.println("你的请求不符合公司要求，不要再提这种无理要求");
			}
		}
		System.out.println("结果已经出来了，按照上面的指示执行吧");
	}

}

DeptManager:

package zerenlian.other;

public class DeptManager extends IUserInfo{
	private String name;
	public DeptManager(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void invoke(int leaveday) {
		if(leaveday < 13){
			System.out.println("部门经理"+getName()+"同意了");
		}else{
			if(this.getNext()!=null){
				this.getNext().invoke(leaveday);
			}else{
				System.out.println("你的请求不符合公司要求，不要再提这种无理要求");
			}
		}
	}

}

GeneralManager:

package zerenlian.other;


public class GeneralManager extends IUserInfo{
	private String name;
	public GeneralManager(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void invoke(int leaveday) {
		if(leaveday < 20){
			System.out.println("部门经理"+getName()+"同意了");
		}else{
			if(this.getNext()!=null){
				this.getNext().invoke(leaveday);
			}else{
				System.out.println("你的请求不符合公司要求，不要再提这种无理要求");
			}
		}
	}

}

MainTest：

package zerenlian.other;

public class MainTest {
	
	public static void main(String[] args) {
		IUserInfo aManager = new CellManager("小C");
		IUserInfo bManager = new DeptManager("小K");
		IUserInfo cManager = new GeneralManager("小J");
		aManager.setNext(bManager);
		bManager.setNext(cManager);
		aManager.invoke(13);
	}
}

测试结果：

部门经理小J同意了
结果已经出来了，按照上面的指示执行吧