设计模式-职责链模式和迭代器模式

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());
            }
        }
  }
  

  迭代器模式好处：

  • 客户端只需要得到迭代器就可以遍历，不用关心遍历算法，封装性好
  • 可以方便的提供多种遍历方式
  • 不需要暴露容器集合的内部数据结构，又可以透明的访问集合内部的数据

参考：《大话设计模式》
​