设计模式(10)---责任链模式

本文主要是介绍设计模式(10)---责任链模式，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

  定义: 使多个对象都有机会处理请求，从而避免了发送者和接收者之间的耦合关系。
  将这些对象连成一条链，并沿着这条连传递该请求，直到有对象处理该请求为止。
 
  一个例子:
  古代女子讲究“三从四德”，当女子去做一件事情时，如果该女子未出嫁，首先要向父亲请求。

  出嫁，就要像丈夫请求；夫死，就要向儿子请求。模拟这个女子发送请求的链式关系。

 抽象的处理者实现三个职责:
   ---|定义一个请求的处理方法handlerMessage，唯一开发的方法。
   ---|定义一个编排方法setNext，设置下一个处理者。
   ---|定义了具体的请求者必须实现的方法。
  处理者中完成的操作
   ---|定义自身的责任等级
   ---|实现抽象方法，对请求者进行封装，并作出响应。
  请求者完成的操作
   ---|负责定义自身的请求等级。
   ---|发出请求实体。

public class ResponseTest {public static void main(String[] args) {//创建一个女子，发送自己的类型与请求IWoman woman = new Woman(2,"我想出去购物..");//创建责任链ResponseHandler farther = new Farther();ResponseHandler husband = new Husband();ResponseHandler son = new Son();//设置下一责任人。farther.setNext(husband);husband.setNext(son);//设置责任链入口，处理内容farther.handleMessage(woman);}
}
interface IWoman{//女子发送请求。String sendRequire();//获取当前状态，出嫁、未嫁、夫死。int getType();
}
class Woman implements IWoman{/*** 1、表示未嫁* 2、出嫁* 3、夫死*/private int type = 0;private String request;//构造函数，设置女子的信息。public Woman(int type,String require) {this.type = type;this.request = require;}//获得请求内容@Overridepublic String sendRequire() {return this.request;}//获取该女子当前的状态。@Overridepublic int getType() {System.out.println("-------"+this.type);return this.type;}
}
//责任链接口，定义一些方法，让子类去实现。
abstract class ResponseHandler{//父亲处理等级public static final int FARTHER_LEVEL_RESPONSE = 1;//丈夫处理等级public static final int HUSBAND_LEVEL_RESPONSE = 2;//儿子处理等级public static final int SON_LEVEL_RESPONSE = 3;//当前等级private int level = 0;//设置下一个责任人是谁。private ResponseHandler nextHandler;public ResponseHandler(int level) {this.level = level;}public void setNext(ResponseHandler handler){this.nextHandler = handler;}public void handleMessage(IWoman woman){System.out.println(this.level+"!!!!!!!-----!!!!!"+woman.getType());if(this.level == woman.getType()){//如果女子的当前等级与定义的等级相同，那么就做出回应this.response(woman);}else{//不满足当前等级，寻找下一个责任人if(nextHandler != null){//类似于 递归回调。this.nextHandler.response(woman);}else{ //没有后继责任人，就停止回调。System.out.println("----------找不到责任人了，你自由了....");}}}//回应方式，具体实现由子类来实现。protected abstract void response(IWoman woman);
}
/*** * @author admin**/
class Farther extends ResponseHandler{public Farther() {super(ResponseHandler.FARTHER_LEVEL_RESPONSE);}@Overridepublic void response(IWoman woman) {System.out.println("----------女儿向父亲请求-------");System.out.println("------"+woman.sendRequire());System.out.println("我是父亲，我统一你的请求...");}
}
class Husband extends ResponseHandler{public Husband() {super(ResponseHandler.HUSBAND_LEVEL_RESPONSE);}@Overridepublic void response(IWoman woman) {System.out.println("----------妻子向丈夫请求-------");System.out.println("------"+woman.sendRequire());System.out.println("我是丈夫，我限制你的自由....");}
}
class Son extends ResponseHandler{public Son() {super(ResponseHandler.SON_LEVEL_RESPONSE);}@Overridepublic void response(IWoman woman) {System.out.println("----------母亲向儿子请求-------");System.out.println("------"+woman.sendRequire());System.out.println("我是儿子，我一切都听你的....");}
}

 一个例子
  用户注册信息，用户分为普通用户和VIP用户。但是同时公用一个界面。
  我们需要一个处理者，来区分不同的注册用户。这里可以用到责任链模式，来完成。

public class ResponseEx {public static void main(String[] args) {//定义一些登录者HashMap<String, Integer> hashMap = new HashMap<String, Integer>();hashMap.put("lzl", 1);hashMap.put("xy", 2);hashMap.put("ht", 2);hashMap.put("hj", 2);hashMap.put("zl",1);//创建登录Registe register = new Registe();register.setHashMap(hashMap);//通过Handler处理登录信息,并通过责任链入口、RegisteHandler CommonHandler = new CommonRegiste();RegisteHandler VIPHandler = new VIPRegiste();//设置下一个责任人..CommonHandler.setHandler(VIPHandler);CommonHandler.HandleMessage(hashMap);}
}
abstract class RegisteHandler{//VIP等级用户注册public static final int VIP_LEVEL = 2;//普通用户注册public static final int COMMON_LEVEL = 1;//设置hashMap存储登录信息private HashMap<String, Integer> infoMap = new HashMap<String, Integer>();//定义当前的等级private int level ;//定义下一个责任链private RegisteHandler nextHandler;//构造方法，设置责任人等级。public RegisteHandler(int level){this.level = level;}//处理信息public void HandleMessage(HashMap<String, Integer> hashInfo){//遍历hash表中的所用信息。Set<String> set = hashInfo.keySet();Iterator<String> it = set.iterator();while(it.hasNext()){String name = it.next();//通过name获得 他的注册类型。int type = hashInfo.get(name);if(this.level == type){this.infoMap.clear();this.infoMap.put(name, type);System.out.println("---------普通用户--------------");//如果当前类型与注册类型相同，则执行方法。this.response(infoMap);}else{//如果没有找到责任人，继续查找if(nextHandler != null){this.infoMap.clear();this.infoMap.put(name, type);System.out.println("---------VIP用户--------------");this.nextHandler.response(infoMap);}else{//如果找不到责任人。System.out.println("没有您选择的注册类型，请重新注册....");}}}}public void setHandler(RegisteHandler handler){this.nextHandler = handler;}//定义请求的信息。protected abstract void response(HashMap<String, Integer> hashMap);
}
class CommonRegiste extends RegisteHandler{//构造函数设置普通用户的等级。public CommonRegiste() {super(RegisteHandler.COMMON_LEVEL);}@Overrideprotected void response(HashMap<String, Integer> hashMap) {Set<Map.Entry<String, Integer>> set = hashMap.entrySet();Iterator<Map.Entry<String, Integer>> it = set.iterator();while(it.hasNext()){Map.Entry<String, Integer> map = it.next();String name = map.getKey();System.out.println("普通用户:"+name+"\t注册成功！");}}
}
class VIPRegiste extends RegisteHandler{//构造函数设置普通用户的等级。public VIPRegiste() {super(RegisteHandler.VIP_LEVEL);}@Overrideprotected void response(HashMap<String, Integer> hashMap) {Set<Map.Entry<String, Integer>> set = hashMap.entrySet();Iterator<Map.Entry<String, Integer>> it = set.iterator();while(it.hasNext()){Map.Entry<String, Integer> map = it.next();String name = map.getKey();System.out.println("VIP用户:  "+name+"\t注册成功！");}}
}
class Registe{/*** 1 表示普通用户* 2 表示VIP用户*/private HashMap<String, Integer> hashInfo = new HashMap<String, Integer>();public void setHashMap(HashMap<String, Integer> hashMap){this.hashInfo = hashMap;}public HashMap<String, Integer> getHashInfo() {return this.hashInfo;}
}

责任链式的优点：

1、请求和处理分开，请求者可以不用知道是谁处理，处理者可以不用知道请求的全貌。

2、两者解耦，提高系统的灵活性

责任链式的缺点

1、性能问题

2、调试不方便

这篇关于设计模式(10)---责任链模式的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---