闲谈责任链模式
姓名：赵新春
学号；07770122
责任链模式概述：
责任链模式是使用多个对象处理用户请求的成熟模式，责任链模式的关键是将用户的请求分派给许多对象，这些对象被组织成一个责任链，即每个对象含有后继对象的引用，并要求责任链上的每个对象，如果能处理用户的请求，就做出处理，不再将用户的请求传递给责任链上的下一个对象，如果不能处理用户的请求，就必须将用户的请求传递给责任链上的下一个对象。
生活场景：
学校快放假了，学生想留校打工，他需要上交一个留校申请书，递交给处理这事情的部门处理。学校有学办、系办、教务处等部门。
不假思索的方式：
学生有个请求，但是他压根不知道到底是哪个部门处理这个请求，所以他要一个一个的询问各部门的主管人员，即定义一个学生类，一个学办类，一个系办类，一个教务处类。其中学生类中定义一个request的请求属性，声明了学办、系办、教务处类的对象引用，定义一个发送请求的方法，其中需要if判断到底是哪个部门处理的请求然后就该部门处理这个请求。
代码：
Public class Student{
Private String request=”留校”;
Private XiBan xiban;
Private XueBan xueban;
Private JiaoWuChu jwc;
Public Student (){}
Public Student(XiBan xiban , XueBan xueban , JiaoWuChu jwc){
This.xiban = xiban;
This.xueban = xueban;
This.jwc = jwc;
}
Public void send(String request){
If(request.equels(xueban.getNotice())){
Xueban.chuli();
}else if(request.equels(xiban.getNotice())){
Xiban.chuli();
}else if(request.equels(jwc.getNotice())){
Jwc.chuli()
}
Public void setRequest(String request){
This.request = request;
}
Public String getRequest(){
Return request;
}
}
Public static void main(String[] args){
XueBan xueban = new XueBan();
XiBan xiban = new XiBan();
JiaoWuChu jwc = new JiaoWuChu();
Student stu = new Student(xiban,xueban,jwc);
Stu.send(stu.getRequest());
}
}
Public class XueBan｛
Private String notice =”考试”;
Public void setNotice(String notice){
This.notice = notice;
}
Public String getNotice(){
Return notice;
}
Public void chuli(){
System.out.println(“我处理了”);
}
｝
Public class XiBan｛
Private String notice=”补考”;
Public void setNotice(String notice){
This.notice = notice;
}
Public String getNotice(){
Return notice;
}
Public void chuli(){
System.out.println(“我处理了”);
}
｝
Public class JiaoWuChu｛
Private String notice=”留校”;
Public void setNotice(String notice){
This.notice = notice;
}
Public String getNotice(){
Return notice;
}
Public void chuli(){
System.out.println(“我处理了”);
}
｝
思考：
- 各部门类之间重复的代码太多，看着繁杂，是否想法抽取出共同的部分封装到一个接口或者抽象类中？
- 学生类中引用了所有部门的对象实例，这样与各部门类的耦合性就大大提高，修改程序代码的工作就大大提高，能否想出一个方法使各个类之间的耦合性降低？
付诸实践后：
首先抽取出相同的方法封装到一个接口中，各部门都实现这个接口，然后学生类中只是引用了刚刚抽取出来的接口的引用。这种思路就是责任链模式的思想。
代码：
Public class Student{
Private String request=”留校”;
Private BuMen bm;
Public Student (){}
Public Student(BuMen bm){
This.bm = bm;
}
Public void send(String request){
bm.chuli(request);
}
Public void setRequest(String request){
This.request = request;
}
Public String getRequest(){
Return request;
}
Public static void main(String[] args){
XueBan xueban = new XueBan();
XiBan xiban = new XiBan();
JiaoWuChu jwc = new JiaoWuChu();
Xueban.setNext(xiban);
xiban.setNext(jwc)
Student stu = new Student(xueban);
Stu.send(stu.getRequest());
}
}
Public interface BuMen{
Public void chuli(String request);
Public void setNext(BuMen bm);
}
Public class XueBan implements BuMen｛
Private String notice =”考试”;
Private BuMen bm;
Public void setNotice(String notice){
This.notice = notice;
}
Public String getNotice(){
Return notice;
}
Public void chuli(String request){
If(requeset.equals(notice)){
System.out.println(“我处理了”);
}else{
System.out.println(“我处理不了”);
bm.chuli(request);
}
}
Public void setNext(BuMen bm){
This.bm = bm;
}
｝
Public class XiBan implements BuMen｛
Private String notice=”补考”;
Prvate BuMen bm;
Public void setNotice(String notice){
This.notice = notice;
}
Public String getNotice(){
Return notice;
}
Public void chuli(){
If(requeset.equals(notice)){
System.out.println(“我处理了”);
}else{
System.out.println(“我处理不了”);
bm.chuli(request);
}
}
Public void setNext(BuMen bm){
This.bm = bm;
}
｝
Public class JiaoWuChu｛
Private String notice=”留校”;
Prvate BuMen bm;
Public void setNotice(String notice){
This.notice = notice;
}
Public String getNotice(){
Return notice;
}
Public void chuli(){
If(requeset.equals(notice)){
System.out.println(“我处理了”);
}else{
System.out.println(“我处理不了”);
bm.chuli(request);
}
}
Public void setNext(BuMen bm){
This.bm = bm;
}
｝
责任链模式的优缺点：
- 责任链中的对象只和自己的后继是低耦合关系，和其他对象毫无关联，这使得编写处理者对象以及创建责任链变得非常容易。
- 可以根据需要自由组合工作流程。如工作流程发生变化，可以通过重新分配对象链便可适应新的工作流程。
- 责任链模式可能会带来一些额外的性能损耗，因为它要从链子开头开始遍历。
