设计模式-责任链模式

概述

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

涉及角色

抽象处理者(Handler)角色：定义一个处理请求的抽象类。如果需要，可以定义一个方法以设定和返回对下家的引用。
具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

应用场景

很常见的一个场景：请假。假定请假3天以内，由项目经理直接审批；3-5天，由部门经理审批通过；大于5天，则由总经理通过。

实现

请求实体类:

public class Request {
     private String name;
     private String reason;
     private int days;
     private String groupLeaderInfo;
     private String managerInfo;
     private String departmentHeaderInfo;
     private String customInfo;
     public Request(Builder builder) {
          super();
          this.name = builder.name;
          this.reason = builder.reason;
          this.days = builder.days;
          this.groupLeaderInfo = builder.groupLeaderInfo;
          this.managerInfo = builder.managerInfo;
          this.departmentHeaderInfo = builder.departmentHeaderInfo;
          this.customInfo = builder.customInfo;
     }
     public static class Builder {
          public String name;
          public String reason;
          public int days;
          public String groupLeaderInfo;
          public String managerInfo;
          public String departmentHeaderInfo;
          public String customInfo;
          public Builder() {
          }
          //Builder模式set方法 省略...
          public Request build() {
              return new Request(this);
          }
     }
 	//get set toString方法省略
}

抽象处理类:

public interface Ratify {
	public Result deal(Chain chain);
}

具体处理类:

public class GroupLeader implements Ratify {
	@Override
	public Result deal(Chain chain) {
		Request request = chain.request();
		System.out.println("GroupLeader=====>request:" + request.toString());
		if (request.days() > 1) {
			// 包装新的Request对象
			Request newRequest = new Request.Builder().newRequest(request).setManagerInfo(request.name() + "平时表现不错，而且现在项目也不忙").build();
			return chain.proceed(newRequest);
		}
		return new Result(true, "GroupLeader：早去早回");
	}
}
public class Manager implements Ratify {
	@Override
	public Result deal(Chain chain) {
		Request request = chain.request();
		System.out.println("Manager=====>request:" + request.toString());
		if (request.days() > 3) {
			// 构建新的Request
			Request newRequest = new Request.Builder().newRequest(request).setManagerInfo(request.name() + "每月的KPI考核还不错，可以批准").build();
			return chain.proceed(newRequest);
		}
		return new Result(true, "Manager：早点把事情办完，项目离不开你");
	} 
}
public class DepartmentHeader implements Ratify {
	@Override
	public Result deal(Chain chain) {
		Request request = chain.request();
		System.out.println("DepartmentHeader=====>request:" + request.toString());
		if (request.days() > 7) {
			return new Result(false, "你这个完全没必要");
		}
		return new Result(true, "DepartmentHeader：不要着急，把事情处理完再回来！");
	}
}

抽象责任链控制器:

public interface Chain {
	// 获取当前request
	Request request();
	// 转发request
	Result proceed(Request request);
}

具体责任链控制器:

public class RealChain implements Chain {
	public Request request;
	public List<Ratify> ratifyList;
	public int index;
	public RealChain(List<Ratify> ratifyList, Request request, int index) {
		this.ratifyList = ratifyList;
		this.request = request;
		this.index = index;
	}
	@Override
	public Result proceed(Request request) {
		Result proceed = null;
			if (index < ratifyList.size()) {
				RealChain realChain = new RealChain(ratifyList, request, index + 1);
				Ratify ratify = ratifyList.get(index);
				proceed = ratify.deal(realChain);
			}
		return proceed;
	}
	@Override
	public Request request() {
		return request;
	}
}

客户端类:

public class ChainOfResponsibilityClient {
	private ArrayList<Ratify> ratifies;
		public ChainOfResponsibilityClient() {
		ratifies = new ArrayList<Ratify>();
	}
	public void addRatifys(Ratify ratify) {
		ratifies.add(ratify);
	}
	public Result execute(Request request) {
		ArrayList<Ratify> arrayList = new ArrayList<Ratify>();
		arrayList.addAll(ratifies);
		arrayList.add(new GroupLeader());
		arrayList.add(new Manager());
		arrayList.add(new DepartmentHeader());
		RealChain realChain = new RealChain(arrayList, request, 0);
		return realChain.proceed(request);
	}
}

测试类

public class Main { 
	public static void main(String[] args) { 
		Request request = new Request.Builder().setName("张三").setDays(9).setReason("事假").build();
		ChainOfResponsibilityClient client = new ChainOfResponsibilityClient();
		Result result = client.execute(request);
		System.out.println("结果：" + result.toString());
	} 
}

打印结果:

GroupLeader=====>request:Request [name=张三, reason=事假,days=9,customInfo=null, groupLeaderInfo=null, managerInfo=null,departmentHeaderInfo=null]
Manager=====>request:Request [name=张三, reason=事假,days=9,customInfo=null, groupLeaderInfo=null, managerInfo=张三平时表现不错，而且现在项目也不忙, departmentHeaderInfo=null]
DepartmentHeader=====>request:Request [name=张三, reason=事假, days=9,customInfo=null, groupLeaderInfo=null, managerInfo=张三每月的KPI考核还不错，可以批准, departmentHeaderInfo=null]
结果：Result [isRatify=false, info=你这个完全没必要]