面向对象的设计模式（八），责任链模式

废话不多说，最近要期末考试了，还没预习呢，下面直接进入正题。

定义：定义多个可以处理请求（承担责任）的类，并将它们连成一条链，沿着该链向下传递请求（责任），直到有能力解决问题（承担责任）的类处理之。这使得它们都有机会（看能力大小咯）处理请求。

使用场景：

1. 一个请求有多个类可以处理，但具体由那个类处理要在运行时刻确定；
2. 在请求不知道由谁来处理的时候，可以沿着责任链传递请求；
3. 需要动态指定一组对象处理请求。

优点：

• 使得请求者和处理者之前关系解耦，提高了代码灵活性。

缺点：

• 影响程序的性能，尤其在递归调用中更为明显，因为势必要对链中的处理者遍历，直到找到合适的处理者。

以游戏BOSS悬赏为例，发布一个悬赏，招能人义士消灭BOSS。

代码实现：

悬赏 （请求）

/**
 * 悬赏 ----->请求
 * @author lt
 *
 */
public class Reward {
    /**
     * BOSS战斗力
     */
    public int bossFightingCapacity;
}

游戏角色（处理者Handler）

/**
 * 游戏角色  ---> 可以处理请求的处理者Handler
 * @author lt
 *
 */
public abstract class Role {

    public Role nextPlayer; // 下一个领了悬赏的玩家
    protected String roleName;

    public Role(String roleName){
        this.roleName = roleName;
    }

    /**
     * 得到玩家角色的战斗力
     * @return 战斗力
     */
    public abstract int getFightingCapacity();

    /**
     * 处理请求或者传递  -- 这里为领取悬赏任务，完成不了（战斗力不够）就下个领了悬赏的玩家完成（传递）
     * @param bossFightingCapacity,悬赏榜的BOSS的战斗力
     */
    public final void handleRequest(int bossFightingCapacity){
        if(bossFightingCapacity<=getFightingCapacity()){
            // BOSS战斗力不高于玩家，玩家就可以杀死BOSS
            killBOSS();
        }else{
            // BOSS太厉害了，由高手解决吧，自己泪闪了
            if(nextPlayer!=null){
                // 让下个玩家领取悬赏
                nextPlayer.handleRequest(bossFightingCapacity);
            }else{
                // 没人领悬赏
                System.out.println("这个BOSS为无敌BOSS,屌炸天!");
            }
        }
    }

    /**
     * 具体的处理方法 -- 这里为每个玩家怎么杀死BOSS的
     */
    public abstract void killBOSS();
}

?说明：每个具体的角色为一个玩家。

骑士小明

/**
 * 骑士小明
 * @author lt
 *
 */
public class XiaoMing extends Role {

    public XiaoMing(String roleName) {
        super(roleName);
    }

    @Override
    public int getFightingCapacity() {
        return 2000;
    }

    @Override
    public void killBOSS() {
        System.out.println("我是"+roleName+",我的大刀早已饥渴难耐了！BOSS被大刀砍杀了");
    }
}

法师小丽

/**
 * 法师小丽
 * @author lt
 *
 */
public class XiaoLi extends Role {

    public XiaoLi(String roleName) {
        super(roleName);
    }

    @Override
    public int getFightingCapacity() {
        return 1000;
    }

    @Override
    public void killBOSS() {
        System.out.println("我是"+roleName+",我的新魔杖，代表月亮消灭了BOSS!");
    }
}

猎手小华

/**
 * 猎手小华
 * @author lt
 *
 */
public class XiaoHua extends Role{

    public XiaoHua(String roleName) {
        super(roleName);
    }

    @Override
    public int getFightingCapacity() {
        return 3000;
    }

    @Override
    public void killBOSS() {
        System.out.println("我是"+roleName+",我的弓箭早已暗藏不住了！BOSS被射杀了");
    }
}

测试：

悬赏一个2900战力的BOSS

public class Test {

    public static void main(String[] args) {
        Role xm = new XiaoMing("血魂骑士");
        Role xh = new XiaoHua("狙魔猎手");
        Role xl = new XiaoLi("秘法游侠");

        xl.nextPlayer = xm;
        // 通常高手都是最后一个出现的
        xm.nextPlayer = xh;

        // 今有一个2900战斗力的BOSS,需要能人义士来消灭
        Reward reward = new Reward();
        reward.bossFightingCapacity = 2900;

        // 小丽太激动了，第一个领了悬赏任务
        xl.handleRequest(reward.bossFightingCapacity);
    }
}

结果：

悬赏一个1900战力的BOSS

悬赏一个900战力的BOSS

总结：

?通过上面的BOSS悬赏测试，我们看到了当领取了悬赏任务的所有玩家中，当最先领取的玩家完成不了时会交给下面的玩家来完成否则自己来完成，直到有玩家可以杀死BOSS。这些领取了悬赏的所有玩家都在一条责任链中（杀死BOSS），使得他们都有机会去杀死BOSS，这就是责任链模式的简单实现。当然，责任链中的处理顺序也不是固定的，可以改变，如小丽完成不了可以直接交给小华，而不用先交给小明。

?责任链模式是为了处理某种请求而生的，当我们有这样的请求的时候可以考虑使用该模式，具体可以参考使用场景。好吧，该预习了，不能挂科了。