责任链模式是将链中每一个节点看作是一个对象,每个节点处理的请求均不同,且内部自动维护一个下一节点对象。当一个请求从链式的首端发出时,会沿着链的路径依次传递给每一个节点对象,直至有对象处理这个请求为止。属于行为型模式。
场景在日常生活中责任链模式还是比较常见的,我们平常处理一些事务,往往是各个部门协同合作的完成某一个任务,而每个部分都是各自的职责,因此,很多时候事情完成一半,便会转交给下一个部门,直到所有部门都过一遍之后事情才能完成。还有我们平时俗话说的过五关,斩六将其实也是一种责任链。
1,多个对象可以处理同一个请求,但具体由哪个对象处理则在运行时候动态决定;
2,在不明确指定接收者的情况下,向多个对象中的一个提交一个请求;
3,可动态指定一组对象处理请求。
抽象处理者:定义一个请求处理的方法,并维护一个下一个处理节点Handle对象的引用;
具体处理者:对请求进行处理,如果不感兴趣,则进行转发。
责任链模式的本质是解耦请求和处理,请求在处理链中能进行传递与被处理;理解责任链模式模式应当理解的是其模式而不是其具体实现,责任链模式的独到之处是其将节点处理组合成链式结构,并允许点自身决定是否进行请求处理或转发,相当于让请求流动了起来
利用责任链模式进行数据校验拦截
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 void setLoginName(String loginName) {
this.loginName = loginName;
}
public String getLoginPass() {
return loginPass;
}
public void setLoginPass(String loginPass) {
this.loginPass = loginPass;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
@Override
public String toString() {
return "Member{" +
"loginName='" + loginName + ''' +
", loginPass='" + loginPass + ''' +
", roleName='" + roleName + ''' +
'}';
}
}
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");
}
}
下面用责任链模式来优化一下代码。
public abstract class Handler {
protected Handler next;
public void next(Handler next){ this.next = next;}
public abstract void doHandler(Member member);
}
我们分别创建非空校验ValidateHandler类,登录校验LoginHandler 类和权限校验AuthHandler
public class ValidateHandler extends Handler {
public void doHandler(Member member) {
if(StringUtils.isEmpty(member.getLoginName()) ||
StringUtils.isEmpty(member.getLoginPass())){
System.out.println("用户名和密码为空");
return;
}
System.out.println("用户名和密码不为空,可以往下执行");
next.doHandler(member);
}
}
public class LoginHandler extends Handler {
public void doHandler(Member member) {
System.out.println("登录成功!");
member.setRoleName("管理员");
next.doHandler(member);
}
}
public class AuthHandler extends Handler {
public void doHandler(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.doHandler(new Member(loginName,loginPass));
}
}
public class Test {
public static void main(String[] args) {
MemberService memberService = new MemberService();
memberService.login("tom","666");
}
}
当责任链结构较长时,MemberService 的工作会非常繁琐,并且MemberService 代码相对臃肿,且后续更改处理者或消息类型时,都必须在MemberService 中进行修改,不符合开闭原则。产生这些问题的原因就是因为链式结构的组装过于复杂,而对于复杂结构的创建,很自然我们就会想到建造者模式。使用建造者模式,我们完全可以对MenberService指定的处理节点对象进行自动链式组装,客户只需指定处理节点对象,其他任何事情无需关心。
修改Handler
public abstract class Handler{ protected Handler next; public void next(Handler next){ this.next = next;} public abstract void doHandler(Member member); public static class Builder { private Handler head; private Handler tail; public Builder addHandler(Handler handler){ // do { if (this.head == null) { this.head = this.tail = handler; return this; } this.tail.next(handler); this.tail = handler; // }while (false);//真正框架中,如果是双向链表,会判断是否已经到了尾部 return this; } public Handler 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().doHandler(new Member(loginName,loginPass));
//用过Netty的人,肯定见过
}
}
优点和缺点
1将请求与处理解耦;
2请求处理者(节点对象)只需关注自己感兴趣的请求进行处理即可,对于不感兴趣的请求,直接转发给下一级节点对象;
3具备链式传递处理请求功能,请求发送者无需知晓链路结构,只需等待请求处理结果
4链路结构灵活,可以通过改变链路结构动态地新增或删除责任;
5易于扩展新的请求处理类,符合开闭原则
缺点:
1;链路太长或者处理时间过长,会影响整体性能
2,如果节点对象存在循环引用时,会造成死循环,导致系统崩溃;



