迭代器模式

迭代器（Iterator）模式：提供一个对象(迭代器)来顺序访问聚合对象(迭代数据)中的一系列数据，而不暴露聚合对象的内部表示。对象行为型模式

抽象聚合（Aggregate）角色：
定义存储、添加、删除聚合对象以及创建迭代器对象的接口。
具体聚合（ConcreteAggregate）角色：
实现抽象聚合类，返回一个具体迭代器的实例。
抽象迭代器（Iterator）角色：
定义访问和遍历聚合元素的接口，通常包含 hasNext()、first()、next() 等方法。
具体迭代器（Concretelterator）角色：
实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

行为型-迭代器 - 图1

  2. /**
  3.  * 抽象聚合类
  4.  */
  5. public abstract class BeautifulMan {
  7.     //不方便暴露给外界的集合。只允许外界获取而不可以操作
  8.     private List<String> girlFriends = new ArrayList<>();
  10.     abstract void likeYou(String name);
  11.     abstract void sayBye(String name);
  13.     /**
  14.      * 获取迭代器
  15.      * @return
  16.      */
  17.     public Itr getIterator(){
  18.         return new Iterator();
  19.     }
  21.     /**
  22.      * 具体迭代器
  23.      */
  24.     class Iterator implements Itr{
  25.        private int cursor = 0; //当前指针
  26.        public boolean hasNext(){
  27.            return girlFriends.size()!=cursor;
  28.        }
  30.        public String next(){
  31.            return girlFriends.get(++cursor);
  32.        }
  33.     }
  36.     /**
  37.      * 抽象迭代器，写在了内部，外部也可以
  38.      */
  39.     interface Itr {
  40.         boolean hasNext();
  41.         String next();
  42.     }
  44. }

使用场景

什么场景用到？
jdk容器接口的Iterator定义
现实开发中，我们几乎无需编写迭代器，基本数据结构链表、树、图的迭代器已经都有了。除非要重写迭代逻辑
……

责任链模式

责任链（Chain of Responsibility）模式：为了避免请求发送者与多个请求处理者耦合在一起，于是将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。属于对象行为型模式

  1. 简单责任链：
  1. //此时模拟一个找老师请假的流程
  2. public class Teacher {
  3.     private Teacher next; //此时就是这个链，如果换成List<Teacher> 就是组合模式
  4.     private String  name;
  6.     public void handleRequest(){
  7.         System.out.println(this.name+"正在处理");
  8.         if (next!=null){
  9.             next.handleRequest();
  10.         }
  11.     }
  12. }
  1. 完整责任链:

模拟Filter执行

  1. public interface Filter {
  2.     public void doFilter(Request request,Response response,FilterChain filterChain);
  3. }
  1. public class FilterChain implements Filter {
  2.     private List<Filter> list=new ArrayList<>(); //包含了所有链
  4.     private int cursor; //定义一个游标，判断当前执行的位置
  6.     private MyFunc target; //保存要执行方法的对象
  8.     public List<Filter> getList() {
  9.         return list;
  10.     }
  12.     public void addList(Filter filter) {
  13.         this.list.add(filter);
  14.     }
  16.     public void setTarget(MyFunc target) {
  17.         this.target = target;
  18.     }
  20.     public MyFunc getTarget() {
  21.         return target;
  22.     }
  24.     @Override
  25.     public void doFilter(Request request, Response response, FilterChain filterChain) {
  27.         if (cursor<list.size()){
  28.             Filter filter = list.get(cursor); //获取当前链执行
  29.             cursor++;//游标+1，下一次执行下一个链
  30.             filter.doFilter(request,response,filterChain);
  31.         }else {//当filter链结束后调用自己的方法
  32.             target.my(); 
  33.         }
  36.     }
  37. }
  1. public class HttpFilter implements Filter{
  2.     @Override
  3.     public void doFilter(Request request, Response response, FilterChain filterChain) {
  4.         System.out.println(">>>HttpFilter开始");
  5.         filterChain.doFilter(request,response,filterChain);
  6.         System.out.println(">>>HttpFilter结束");
  9.     }
  10. }
  1. public class EncodingFilter implements  Filter{
  3.     @Override
  4.     public void doFilter(Request request, Response response, FilterChain filterChain) {
  6.         System.out.println(">>>EncodingFilter开始");
  7.         filterChain.doFilter(request,response,filterChain);
  8.         System.out.println(">>>EncodingFilter结束");
  9.     }
  10. }
  1. @Data
  2. public class Request {
  3.     private String msg;
  5. }
  7. @Data
  8. public class Response {
  9.     private  String msg;
  11. }
  1. public class MyFunc {
  3.     public void my(){
  4.         System.out.println("my function");
  5.     }
  6. }

行为型-迭代器 - 图2

场景

什么场景用到？
Tomcat的Pipeline、Valve
Filter链
Aop责任链
……