责任链模式

定义：使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

link.png

    public class Request {
    private int level
         //请求的等级
         public int getRequestLevel(){
                 return level;
         }
    }

    public class Response {
         //处理者返回的数据
    }

    public class Handler {
        public final Response handleMessage(Request request){
            if(request.getRequestLevel() == 0){
                 // 一堆操作
                return response1;
            } else if(request.getRequestLevel() == 1){
                 // 另一堆操作
                return response2;
            } else if ......
        }
    }

使用责任链模式：

    public abstract class Handler {
         private Handler nextHandler;
         //每个处理者都必须对请求做出处理
         public final Response handleMessage(Request request){
                 Response response = null;
                 //判断是否是自己的处理级别
                 if(this.getHandlerLevel().equals(request.getRequestLevel())){
                        response = this.echo(request);
                 }else{  //不属于自己的处理级别
                        //判断是否有下一个处理者
                        if(this.nextHandler != null){
                                response = this.nextHandler.handleMessage(request);
                        }else{
                                //没有适当的处理者，业务自行处理
                        }
                 }
                 return response;
         }
         //设置下一个处理者是谁
         public void setNext(Handler _handler){
                 this.nextHandler = _handler;
         }
         //每个处理者都有一个处理级别
         protected abstract int getHandlerLevel();
         //每个处理者都必须实现处理任务
         protected abstract Response echo(Request request);
    }

    public class ConcreteHandler1 extends Handler {
         //定义自己的处理逻辑
         protected Response echo(Request request) {
                 //完成处理逻辑
                 return null;
         }
         //设置自己的处理级别
         protected int getHandlerLevel() {
                 //设置自己的处理级别
                 return 0;
         }
    }
    public class ConcreteHandler2 extends Handler {
         //定义自己的处理逻辑
         protected Response echo(Request request) {
                 //完成处理逻辑
                 return null;
         }
         //设置自己的处理级别
         protected int getHandlerLevel() {
                 //设置自己的处理级别
                 return 1;
         }
    }

    public class Client {
         public static void main(String[] args) {
                 //声明所有的处理节点
                 Handler handler1 = new ConcreteHandler1();
                 Handler handler2 = new ConcreteHandler2();
                 //设置链中的阶段顺序1-->2
                 handler1.setNext(handler2);
                 //提交请求，返回结果
                 Response response = handler1.handlerMessage(new Request());
         }
    }

关于责任链模式的应用：

责任链模式非常显著的优点是将请求和处理分开。请求者可以不用知道是谁处理的，处理者可以不用知道请求的全貌。

责任链模式的缺点:

性能影响。

调试不很方便，特别是链条比较长，环节比较多的时候，由于采用了类似递归的方式，调试的时候逻辑可能比较复杂。

链中节点数量需要控制，避免出现超长链的情况。

迭代器模式

目前已经是一个没落的模式，基本上没人会单独写一个迭代器，除非是产品性质的开发。

它提供一种方法访问一个容器对象中各个元素，而又不需暴露该对象的内部细节。

iterator.png

    // 抽象迭代器
    public interface Iterator {
         //遍历到下一个元素
         public Object next();
         //是否已经遍历到尾部
         public boolean hasNext();
         //删除当前指向的元素
         public boolean remove();
    }

    // 具体迭代器
    public class ConcreteIterator implements Iterator {
         private Vector vector = new Vector();
         //定义当前游标
         public int cursor = 0;
         @SuppressWarnings("unchecked")
         public ConcreteIterator(Vector _vector){
                 this.vector = _vector;
         }
         //判断是否到达尾部
         public boolean hasNext() {
                 if(this.cursor == this.vector.size()){
                        return false;
                 }else{
                        return true;
                 }
         }
         //返回下一个元素
         public Object next() {
                 Object result = null;
                 if(this.hasNext()){
                        result = this.vector.get(this.cursor++);
                 }else{
                        result = null;
                 }
                 return result;
         }
         //删除当前元素
         public boolean remove() {
                 this.vector.remove(this.cursor);
                 return true;
         }
    }

    public interface Aggregate {
         //是容器必然有元素的增加
         public void add(Object object);
         //减少元素
         public void remove(Object object);
         //由迭代器来遍历所有的元素
         public Iterator iterator();
    }

    public class ConcreteAggregate implements Aggregate {
         //容纳对象的容器
         private Vector vector = new Vector();
         //增加一个元素
         public void add(Object object) {
                 this.vector.add(object);
         }
         //返回迭代器对象
         public Iterator iterator() {
                 return new ConcreteIterator(this.vector);
         }
         //删除一个元素
         public void remove(Object object) {
                 this.vector.remove(object);
         }
    }

    public class Client {
         public static void main(String[] args) {
                 //声明出容器
                 Aggregate agg = new ConcreteAggregate();
                 //产生对象数据放进去
                 agg.add("abc");
                 agg.add("aaa");
                 agg.add("1234");
                 //遍历一下
                 Iterator iterator = agg.iterator();
                 while(iterator.hasNext()){
                         System.out.println(iterator.next());
                 }
         }
    }