学习笔记——JAVA设计模式<12>责任链模式

• 创建型模式 关注对象的创建过程
• 结构型模式 关注对象和类的组织
• 行为型模式 关注系统中对象之间的相互交互，研究系统在运行时对象之间的相互通信和协作，进一步明确对象的职责，共有11种模式

---

行为型模式
1. 责任链模式
2. 命令模式
3. 解释器模式
4. 迭代器模式
5. 中介者模式
6. 备忘录模式
7. 观察者模式
8. 状态模式
9. 策略模式
10. 模板方法模式
11. 访问者模式

---

责任链模式 chain of responsibility

---

• 定义
  
  • 将能够处理同一类请求的对象连成一条链，所提交的请求沿着链传递，链上的对象逐个判断知否有能力处理该请求，如果能则处理，如果不能则传递给链上的下一个对象
• 场景
  
  • 打牌时，轮流出牌
  • 接力赛跑
  • 奖金审批
  • 公文审批

责任链模式处理公司请假

package studyGFO;
/**
 * 封装请假的基本信息
 * @author http://blog.csdn.net/thewaiting
 *
 */
public class LeaveRequest {
    private String empName;
    private int leaveDays;
    private String reason;

    public LeaveRequest(String empName, int leaveDays, String reason) {
        super();
        this.empName = empName;
        this.leaveDays = leaveDays;
        this.reason = reason;
    }
    public String getEmpName() {
        return empName;
    }
    public void setEmpName(String empName) {
        this.empName = empName;
    }
    public int getLeaveDays() {
        return leaveDays;
    }
    public void setLeaveDays(int leaveDays) {
        this.leaveDays = leaveDays;
    }
    public String getReason() {
        return reason;
    }
    public void setReason(String reason) {
        this.reason = reason;
    }
}

package studyGFO;
/**
 * 抽象类
 * @author http://blog.csdn.net/thewaiting
 *
 */
public abstract class Leader {

    protected String name;
    //责任链上的下一个对象
    protected Leader nextLeader;
    public Leader(String name) {
        super();
        this.name = name;
    }
    //设置责任链上的下一个对象
    public void setNextLeader(Leader nextLeader) {
        this.nextLeader = nextLeader;
    }
    /**
     * 处理请求的核心业务方法
     */
    public abstract void handleRequest(LeaveRequest request);
}

package studyGFO;
/**
 * 主任
 * @author http://blog.csdn.net/thewaiting
 *
 */
public class Director extends Leader{

    public Director(String name) {
        super(name);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getLeaveDays()<3) {
            System.out.println("员工："+request.getEmpName()+"请假："
        +request.getLeaveDays()+"理由："+request.getReason());
            System.out.println("主任："+this.name+"通过");
        }else {
            if (this.nextLeader !=null) {
                this.nextLeader.handleRequest(request);
            }
        }
    }

}

package studyGFO;
/**
 * 经理
 * @author http://blog.csdn.net/thewaiting
 *
 */
public class Manger extends Leader{

    public Manger(String name) {
        super(name);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getLeaveDays()<10) {
            System.out.println("员工："+request.getEmpName()+"请假："
        +request.getLeaveDays()+"理由："+request.getReason());
            System.out.println("经理："+this.name+"通过");
        }else {
            if (this.nextLeader !=null) {
                this.nextLeader.handleRequest(request);
            }
        }
    }

}

package studyGFO;
/**
 * 总经理
 * @author http://blog.csdn.net/thewaiting
 *
 */
public class GeneralManger extends Leader{

    public GeneralManger(String name) {
        super(name);
    }

    @Override
    public void handleRequest(LeaveRequest request) {
        if (request.getLeaveDays()<30) {
            System.out.println("员工："+request.getEmpName()+"请假："
        +request.getLeaveDays()+"理由："+request.getReason());
            System.out.println("总经理："+this.name+"通过");
        }else {
            System.out.println("不行！");
        }
    }

}

package studyGFO;

public class Client {

    public static void main(String[] args) {
        Leader a = new Director("张三");
        Leader b = new Manger("李四");
        Leader c = new GeneralManger("王五");     
        //组织责任链的关系
        //组织领导关系
        //关系在使用的时候配置
        a.setNextLeader(b);
        b.setNextLeader(c);     
        //请假操作
        LeaveRequest req1 = new LeaveRequest("Jack", 20, "生病");
        a.handleRequest(req1);
    }
}

链表方式定义责任链
非链表方式实现责任链
通过集合，数组生成职责链更加实用。实际上，很多项目中，每个具体的Handler并不是由开团队定义的，而是项目上线后由外部单位追加的，所以使用链表的方式定义COR链就很困难

• 开发中场景
  
  • java中，异常机制就是一种责任链模式。一个try可以对应多个catch，当第一个catch不匹配类型，自动跳到第二个
  • javascript语言中，事件的冒泡和捕获机制。java语言中，事件的处理采用观察者模式
  • Servlet开发中，过滤器的链式处理
  • Struts2，拦截器的调用也是典型的责任链模式