设计模式-工具链模式和迭代器模式

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

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