责任链模式

---

责任链模式一般分为处理者与请求者。具体的处理者分别处理请求者的行为。

Android中的时间分发机制就属于一种责任链模式,父View包含N个子View,如果父View不处理的内容就会分发到具体的子View上进行,直到处理为止。

应用场景

• 处理者不明确的情况下,提交了一条任务
• 多个请求者请求行为一样,交由处理中处理

代码示例

列如小说中经常有一系列赏金任务,分为普通难度,中等难度,高等难度的任务,对应的任务有具体的普通难度处理人,中等难度处理人,高等难度处理人那么问题来了。

（1）不清楚任务难度的情况要交由对应处理者应该如何处理

（2）当接受了高等难度的任务时向普通难度的人提交,但普通难度处理者并不能处理,应该向上级提交到高等难度处理者

（一）抽象的任务处理者

public abstract class TaskLeader {
    public TaskLeader companyLeader;

    public abstract int getType();

    public abstract void handle(TaskRequest type);


    public void handleRequest(TaskRequest companyRequest) {
        //请求者的状态与处理者的状态一致直接处理
        if (companyRequest.getRequestType() == getType()) {
            handle(companyRequest);
        } else {
            if (companyLeader != null) {//交给上级处理
                companyLeader.handleRequest(companyRequest);
            } else {
                System.out.println("没有人能处理");
            }


        }

    }
}

TaskRequest:抽象的任务请求者
getType():请求者状态或者说标识

（二）抽象的任务请求者

public abstract class TaskRequest {
    private Object obj;

    public TaskRequest(Object obj) {
        this.obj = obj;
    }

    public Object getContent() {
        return obj;
    }

    public abstract int getRequestType();


}

(三)具体难度的任务请求者

• 普通难度

public class NormalRequest extends TaskRequest {
    public NormalRequest(Object obj) {
        super(obj);
    }

    @Override
    public int getRequestType() {
        return return (int) getContent();
    }
}

• 中等难度

public class MiddleRequest extends TaskRequest {

    public MiddleRequest(Object obj) {
        super(obj);
    }

    @Override
    public int getRequestType() {
        return return (int) getContent();
    }
}

• 高等难度

public class HardRequest extends TaskRequest {

    public HardRequest(Object obj) {
        super(obj);
    }

    @Override
    public int getRequestType() {
        return return (int) getContent();
    }
}

(三)具体难度的任务处理者

• 普通难度

public class NormalHandle extends TaskLeader {
    @Override
    public int getType() {
        return TypeConfig.NORMAL;
    }

    @Override
    public void handle(TaskRequest type) {
        System.out.println("普通难度请求");
    }
}

• 中等难度

public class MiddleHandle extends TaskLeader {
    @Override
    public int getType() {
        return TypeConfig.MIDDEL;
    }

    @Override
    public void handle(TaskRequest type) {
        System.out.println("中等难度请求");

    }
}

• 高等难度

public class HardHandle  extends TaskLeader {
    @Override
    public int getType() {
        return TypeConfig.HARD;
    }

    @Override
    public void handle(TaskRequest type) {
        System.out.println("高等难度请求");
    }
}

（四）调用方式

 //构造三个处理对象
 NormalHandle handler1 = new NormalHandle();
 MiddleHandle handler2 = new MiddleHandle();
 HardHandle handler3 = new HardHandle();
 //串成一个责任链
 handler1.companyLeader=handler2;
 handler2.companyLeader=handler3;
 //构造三个请求
 NormalRequest request1 = new NormalRequest(TypeConfig.NORMAL);
 MiddleRequest request2 = new MiddleRequest(TypeConfig.MIDDEL);
 HardRequest request3 = new HardRequest(TypeConfig.HARD);

 handler1.handleRequest(request1);
 handler1.handleRequest(request2);
 handler1.handleRequest(request3);

（五）显示结果

普通难度请求
中等难度请求
高等难度请求

三个请求分别都交到了对应的处理者身上。

总结

优点:责任链模式耦合低，利于维护扩展。责任链相互连接,只用顶层发送请求

缺点:责任链判断需要时间,复杂的请求判断一定程度损失性能

github代码地址