设计模式-职责链模式和迭代器模式
1.职责链模式
-
设计动机
客户端发出一个请求，职责链上的对象都可以处理这一请求，而客户端不需要知道是谁具体处理这一请求，这样就实现请求发送者和请求处理者的解耦，并且客户端可以实现动态的组合职责链。
-
常规场景及存在问题
请假manager类逻辑： if(请假天数 <= 1) { handler(小组长)； } else if(请假天数 <= 3 && 请假天数 > 1) { handler(分区经理); } else if(请假天数 <= 7 && 请假天数 > 3) { handler(总经理); } else { doOtherThing(); }考虑两种情况：
- if判断条件增多，假如100个—每次增加都需要增加manager类的判断逻辑
- 增加一种情况3<请假天数<5—修改manager类的判断逻辑
存在的问题：
- 违反了设计模式中的开闭原则
- 违反了设计模式中的单一职责原则
-
职责链模式参考实例
请求者类：
public class Request { private String name; private int days; public Request(String name, int days) { this.name = name; this.days = days; } public String getName() { return name; } public int getDays() { return days; } }
Handler抽象类:
public abstract class Handler{ protected Handler successor; public void setSuccessor(Handler successor) { this.successor = successor; } public abstract void handleRequest(Request request); }处理者类1：
public class LeaveHandler1 extends Handler { public void handleRequest(Request request) { if (request.getDays() <= 1) { System.out.println("小组长审批,请假天数为："+request.getDays()); } else { if (null != this.successor) { this.successor.handleRequest(request); } } } }处理者类2：
public class LeaveHandler2 extends Handler { public void handleRequest(Request request) { if (request.getDays() <= 3 && request.getDays() > 1) { System.out.println("分区经理审批,请假天数为："+request.getDays()); } else { if (null != this.successor) { this.successor.handleRequest(request); } } } }处理者类3：
public class LeaveHandler3 extends Handler { public void handleRequest(Request request) { if (request.getDays() <= 7 && request.getDays() > 3) { System.out.println("总经理审批,请假天数为："+request.getDays()); } else { if (null != this.successor) { this.successor.handleRequest(request); } } } }客户端主函数：
public class Main{ public static void main(String args[]) { Handler groupLeader = new LeaveHandler1(); Handler partManager = new LeaveHandler2(); Handler manager = new LeaveHandler3(); groupLeader.setSuccessor(partManager); partManager.setSuccessor(manager); Request req1 = new Request("李四",4); groupLeader.handleRequest(req1); } }职责链模式好处：
- 请求者和处理者都没有对方明确的信息，并且链中的对象不需要知道所有处理者的引用，只需要知道后继者的引用就行了。降低了模块和对象之间的耦合度
- 可以在链中随时增加或修改一个请求的结构，动态组合职责， 增加了灵活性
可能存在的问题：
- 请求在末端都得不到处理
- 避免链出现环，应该为链增加默认的处理
2. 迭代器模式
-
设计动机
提供一种方法顺序访问聚合对象中的各个元素，并且不暴露该对象中的内部表示。迭代器的作用就是把容器中的对象一个一个遍历出来。
-
迭代器核心
集合抽象类(Aggregate)：定义集合接口
具体集合类(ConcreteAggregate): 继承Aggregate接口，实现集合
迭代抽象类(Iterator): 定义迭代器接口-开始对象, 得到下一个对象, 当前对象, 判断是否到结尾
具体迭代器类(ConcreteIterator): 继承Iterator，实现迭代器接口
-
迭代器模式参考实例
集合抽象类：
interface Aggregate { Iterator createIterator(); }集合具体类：
public class ConcreteAggregate implements Aggregate { private List<Object> list; public ConcreteAggregate(List<Object> list) { this.list = list; } @Override public Iterator createIterator() { return new ConcreteIrerator(list); } }迭代抽象类：
interface Iterator { Object first(); Object next(); boolean isLast(); Object current(); }具体迭代器类：
class ConcreteIterator implements Iterator { private int cursor; private List<Object> list; public ConcreteIterator(List<Object> list) { this.list = list; } @Override public Object first() { return list.get(0); } @Override public Object next() { Object ret = null if (!isLast()) { ret = list.get(cursor); } cursor++; return ret; } @Override public boolean isLast() { return cursor >= list.size() ? true:false; } @Override public Object current() { return list.get(cursor); } }客户端代码：
public class client { public static void main(String[] args) { List<Object> list = new ArrayList<Object>(); list.add("zhangsan"); list.add("wangwu"); list.add("lisi"); Aggregate aggregate = new ConcreteAggregate(list); Iterator iterator = aggregate.createIterator(); while (!iterator.isLast()) { System.out.println(iterator.next()); } } }迭代器模式好处：
- 客户端只需要得到迭代器就可以遍历，不用关心遍历算法，封装性好
- 可以方便的提供多种遍历方式
- 不需要暴露容器集合的内部数据结构，又可以透明的访问集合内部的数据
参考：《大话设计模式》
