责任链模式

责任链模式

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

责任链模式的使用场景

对个对象可以处理同一请求，但具体由哪个对象处理则在运行时动态决定。
在请求处理者不明确的情况下向多个对象中的一个提交一个请求。
需要动态指定一组对象处理请求

通过一个简单的例子来看看责任链模式的简单实现

我们在公司出差的时候产生的费用回去的时候呢 需要报销的 但是每个级别的领导处理报销的额度又是不一样的
这时我们就可以使用责任链模式  将这些人连成一条线  一个接一个的传递直到有人能给我们报销为止

//抽象请求类  主要是返回需要报销多少钱
public abstract class AbstractMoney {
    private int totalMoney;

    public AbstractMoney(int totalMoney) {
        this.totalMoney = totalMoney;
    }

    public int getTotalMoney() {
        return totalMoney;
    }
}   


//抽象领导类  主要是处理报销

public abstract class AbstractManager {
    public AbstractManager abstractManager;

    //抽象类中实现  判断当前领导能不能去处理
    public void handleMonry(AbstractMoney abstractMoney){
        if(getManagerTotalMoney() >= abstractMoney.getTotalMoney()) {
            handle(abstractMoney);
        }else {
            /**
             * 如果不能处理且abstractManager不为空则交给下一个经理去处理
             * 否则返回信息 不能处理
             */
            if(abstractManager != null) {
                abstractManager.handleMonry(abstractMoney);
            }else {
                System.out.println("抱歉,您的问题无人能处理，我们正在上报,请您耐心等候,谢谢");
            }

        }
    }

    /**
     * 获取经理的处理能力
     * @return
     */
    public abstract int getManagerTotalMoney();

    /**
     * 处理事情  （子类自己去实现）
     * @return
     */
    public abstract int handle(AbstractMoney abstractMoney); 
}

//具体 组长类 最低级的领导 处理额度只有 5000

public class GroupManager extends AbstractManager {

    @Override
    public int getManagerTotalMoney() {
        // TODO Auto-generated method stub
        return 5000;
    }

    @Override
    public int handle(AbstractMoney abstractMoney) {
        // TODO Auto-generated method stub
        System.out.println(this.getClass().getSimpleName().toString()+"已经处理了您的请求");
        return abstractMoney.getTotalMoney();
    }

}

//部门经理  中级领导吧   处理额度 20000


public class AndroidManager extends AbstractManager {

    @Override
    public int getManagerTotalMoney() {
        // TODO Auto-generated method stub
        return 20000;
    }

    @Override
    public int handle(AbstractMoney abstractMoney) {
        // TODO Auto-generated method stub
        System.out.println(this.getClass().getSimpleName().toString()+"已经处理了您的请求");
        return abstractMoney.getTotalMoney();
    }

}

//技术老大  高级领导  处理额度 50000

public class TechnologyManager extends AbstractManager {

    @Override
    public int getManagerTotalMoney() {
        // TODO Auto-generated method stub
        return 50000;
    }

    @Override
    public int handle(AbstractMoney abstractMoney) {
        // TODO Auto-generated method stub
        System.out.println(this.getClass().getSimpleName().toString()+"已经处理了您的请求");
        return abstractMoney.getTotalMoney();
    }

}

//实际请求类  （这么简单的逻辑这个类其实并不需要）

public class TripMoney extends AbstractMoney {

    /**
     * @param totalMoney
     */
    public TripMoney(int totalMoney) {
        super(totalMoney);
    }

}   


//这个类实现主要的操作 将领导们连城一条线
public class EngineMoney {
    private AbstractMoney abstractMoney;
    private int money;
    private AbstractManager groupManager;
    private AbstractManager androidManager;
    private AbstractManager technologyManager;
    /**
     * @param money
     */
    public EngineMoney(int money) {
        super();
        this.money = money;
        abstractMoney = new TripMoney(money);
        init();
    }
    /**
     * 初始化领导
     */
    private void init() {
        // TODO Auto-generated method stub
        groupManager = new GroupManager();
        androidManager = new AndroidManager();
        technologyManager = new TechnologyManager();
        groupManager.abstractManager = androidManager;
        androidManager.abstractManager = technologyManager;
    }

    public void startHandle() {
        groupManager.handleMonry(abstractMoney);
    }

}   

//员工类

public class Worker {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        EngineMoney engineMoney = new EngineMoney(60000);
        engineMoney.startHandle();
    }

}

总结一下 

     优点: 可以对请求者和处理者关系解耦 提高代码的灵活性

 缺点: 对链中的请求处理者要进行遍历 如果处理者太多那么遍历必定会影响性能