1　使用责任链模式设计热插拔权限控制

本文节选自《设计模式就该这样学》作者 谭勇德（Tom）

首先创建一个实体类Member。

	public class Member {
	private String loginName;
	private String loginPass;
	private String roleName;
	public Member(String loginName, String loginPass) {
	this.loginName = loginName;
	this.loginPass = loginPass;
	}
	public String getLoginName() {
	return loginName;
	}
	public String getLoginPass() {
	return loginPass;
	}
	public String getRoleName() {
	return roleName;
	}
	public void setRoleName(String roleName) {
	this.roleName = roleName;
	}
	@Override
	public String toString() {
	return "Member{" +
	"loginName='" + loginName + '\'' +
	", loginPass='" + loginPass + '\'' +
	'}';
	}
	}

然后来看一段我们经常写的代码。

	public class MemberService {
	public void login(String loginName,String loginPass){
	if(StringUtils.isEmpty(loginName) ||
	StringUtils.isEmpty(loginPass)){
	System.out.println("用户名和密码校验成功，可以往下执行");
	return;
	}
	System.out.println("用户名和密码不为空，可以往下执行");
	Member member = checkExists(loginName,loginPass);
	if(null == member){
	System.out.println("用户不存在");
	return;
	}
	System.out.println("登录成功！");
	if(!"管理员".equals(member.getRoleName())){
	System.out.println("您不是管理员，没有操作权限");
	return;
	}
	System.out.println("允许操作");
	}
	private Member checkExists(String loginName,String loginPass){
	Member member = new Member(loginName,loginPass);
	member.setRoleName("管理员");
	return member;
	}
	public static void main(String[] args) {
	MemberService service = new MemberService();
	service.login("tom","666");
	}
	}

在上面代码中，主要做了登录前的数据验证。其判断逻辑是有先后顺序的。首先做非空判断，然后检查账号是否有效，最终获得用户角色。根据用户角色所拥有的权限匹配是否有操作权限。那么这样的检验性代码一般都是必不可少的，但是写在具体的业务代码中又显得非常臃肿，因此可以用责任链模式，将这些检查步骤串联起来，而且不影响代码美观，可以使我们在编码时更加专注于某一个具体的业务逻辑处理。 下面用责任链模式来优化代码，首先创建一个Handler类。

	public abstract class Handler {
	protected Handler chain;
	public void next(Handler handler){
	this.chain = handler;
	}
	public abstract void doHandle(Member member);
	}

然后分别创建非空校验ValidateHandler类、登录校验LoginHandler类和权限校验AuthHandler类。ValidateHandler类的代码如下。

	public class ValidateHandler extends Handler {
	public void doHandle(Member member) {
	if(StringUtils.isEmpty(member.getLoginName()) ||
	StringUtils.isEmpty(member.getLoginPass())){
	System.out.println("用户名或者密码为空");
	return;
	}
	System.out.println("用户名和密码校验成功，可以往下执行");
	chain.doHandle(member);
	}
	}

LoginHandler类的代码如下。

	public class LoginHandler extends Handler {
	public void doHandle(Member member) {
	System.out.println("登录成功！");
	member.setRoleName("管理员");
	chain.doHandle(member);
	}
	}

AuthHandler类的代码如下。

	public class AuthHandler extends Handler {
	public void doHandle(Member member) {
	if(!"管理员".equals(member.getRoleName())){
	System.out.println("您不是管理员，没有操作权限");
	return;
	}
	System.out.println("您是管理员，允许操作");
	}
	}

接着修改MemberService中的代码，其实只需要将前面定义好的几个Handler根据业务需求串联起来，形成一条链即可。

	public class MemberService {
	public void login(String loginName,String loginPass){
	Handler validateHandler = new ValidateHandler();
	Handler loginHandler = new LoginHandler();
	Handler authHandler = new AuthHandler();
	validateHandler.next(loginHandler);
	loginHandler.next(authHandler);
	validateHandler.doHandle(new Member(loginName,loginPass));
	}
	}

最后编写客户端调用代码。

	public class Test {
	public static void main(String[] args) {
	MemberService service = new MemberService();
	service.login("tom","666");
	}
	}

其运行结果如下图所示。

其实我们平时使用的很多权限校验框架都是运用这个原理的，将各个维度的权限处理解耦之后再串联起来，只处理各自相关的职责。如果职责与自己不相关，则抛给链上的下一个Handler，俗称“踢皮球”。

2　责任链模式和建造者模式结合使用

因为责任链模式具备链式结构，而在上面代码中，负责组装链式结构的角色是MemberService，当链式结构较长时，MemberService的工作会非常烦琐，并且MemberService的代码相对臃肿，且后续更改处理者或消息类型时，都必须在MemberService中进行修改，不符合开闭原则。产生这些问题的原因就是因为链式结构的组装过于复杂，而对于复杂结构的创建，我们很自然地就会想到建造者模式，使用建造者模式，完全可以对MemberService指定的处理节点对象进行自动链式组装，客户只需指定处理节点对象，其他任何事情都不用关心，并且客户指定的处理节点对象的顺序不同，构造出来的链式结构也随之不同。我们来改造一下，首先修改Handler的代码。

	public abstract class Handler<T> {
	protected Handler chain;
	public void next(Handler handler){
	this.chain = handler;
	}
	public abstract void doHandle(Member member);
	public static class Builder<T> {
	private Handler<T> head;
	private Handler<T> tail;
	public Builder<T> addHandler(Handler<T> handler) {
	if (this.head == null) {
	this.head = this.tail = handler;
	return this;
	}
	this.tail.next(handler);
	this.tail = handler;
	return this;
	}
	public Handler<T> build() {
	return this.head;
	}
	}
	}

然后修改MemberService的代码。

	public class MemberService {
	public void login(String loginName,String loginPass){
	Handler.Builder builder = new Handler.Builder();
	builder.addHandler(new ValidateHandler())
	.addHandler(new LoginHandler())
	.addHandler(new AuthHandler());
	builder.build().doHandle(new Member(loginName,loginPass));
	}
	}

因为建造者模式要构建的是节点处理者，所以我们把Builder作为Handler的静态内部类，并且因为客户端不需要进行链式组装，所以还可以把链式组装方法next()方法设置为private，使Handler更加高聚合，代码如下。

	public abstract class Handler<T> {
	protected Handler chain;
	private void next(Handler handler){
	this.chain = handler;
	}
	...
	}

通过这个案例，小伙伴们应该已经感受到责任链和建造者结合的精髓了。

来源：

https://www.cnblogs.com/gupaoedu-tom/p/15472401.html