设计模式（十三）：责任链模式

介绍

责任链模式（Chain of Responsibility Pattern）属于行为型模式。它为请求创建了一个接收者对象的链。每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

优点

• 降低耦合度。将请求的发送者和接收者解耦
• 简化了对象。使得对象不需要知道链的结构
• 增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任
• 增加新的请求处理类很方便

缺点

• 每个请求都是从链头遍历到链尾,特别是在链比较长的时候,性能是一个非常大的问题

应用

OkHttp核心就是多个拦截器构成责任链模式

实现

关键代码：关键在于在抽象类中判断是否合适，不合适则向下传递

//定义一个抽象过滤器类，大中小号过滤器都继承于它
abstract class AbstractFilter {
    public static int Small = 1;
    public static int Medium = 2;
    public static int Large = 3;

    protected int gap;

    //责任链中的下一个元素
    protected AbstractFilter nextFilter;

    public void setNextLogger(AbstractFilter nextLogger){
       this.nextFilter = nextLogger;
    }
  
    public void filtering(int gap){
       if(this.gap >= gap){
          getAddress();
       }
       if(nextFilter !=null){
          nextFilter.filtering(gap);
       }
    }
  
    abstract protected void getAddress();
    
 }

 class LargeFilter extends AbstractFilter {
 
    public LargeFilter(int gap){
       this.gap = gap;
    }

    @Override
    protected void getAddress() {    
       System.out.println("fall to large gap filter");
    }
 }

 class MediumFilter extends AbstractFilter {
 
    public MediumFilter(int gap){
       this.gap = gap;
    }

    @Override
    protected void getAddress() {    
       System.out.println("fall to medium gap filter" );
    }
 }

 class SmallFilter extends AbstractFilter {
 
    public SmallFilter(int gap){
       this.gap = gap;
    }
  
    @Override
    protected void getAddress() {    
       System.out.println("fall to small gap filter" );
    }
 }

// 动态的定义责任链，也方便增删改
 class ChainPatternDemo {
   
    private static AbstractFilter getChainOfLoggers(){

        AbstractFilter largefilter = new LargeFilter(AbstractFilter.Large);
        AbstractFilter mediumfilter = new MediumFilter(AbstractFilter.Medium);
        AbstractFilter smallfilter = new SmallFilter(AbstractFilter.Small);
  
       largefilter.setNextLogger(mediumfilter);
       mediumfilter.setNextLogger(smallfilter);
  
       return largefilter;  
    }

    public static void main(String[] args) {
        AbstractFilter loggerChain = getChainOfLoggers();
  
        System.out.println("Put small particles.");
        loggerChain.filtering(AbstractFilter.Small);
        System.out.println("Put medium particles.");
        loggerChain.filtering(AbstractFilter.Medium);
        System.out.println("Put large particles.");
        loggerChain.filtering(AbstractFilter.Large);
    }
 }

Put small particles.
fall to large gap filter
fall to medium gap filter
fall to small gap filter
Put medium particles.
fall to large gap filter
fall to medium gap filter
Put large particles.
fall to large gap filter