介绍

责任链模式：为请求创建一个接收者对象的链，如果一个对象不能处理该请求，把相同请求转给下一个处理。

实现

场景：英雄杀中，当场上出一个群体锦囊，依次往下处理。
Demo:
模拟五个英雄

/**
* 抽象出一个英雄类
**/
@Data
@Slf4j
public abstract class Hero {
    /**
     * 英雄名称
     */
    private String heroName;

    /**
     * 英雄主动技能
     */
    private String accordSkill;

    /**
     * 英雄被动技能
     */
    private String passivity;

    /**
     * 拥有的手牌
     */
    private List<Card> cardList;

    /**
     * 下家英雄
     */
    protected Hero nextHero;

    /**
     * 主动技能或者出牌
     */
    public Card accord(Card card) {
        //出基础牌
        //出武器或者延时技能
        //群锦囊
        if (card.getCardName().equals(CardFactory.ARROWS.getCardName())) {
            return card;
        }
        //单锦囊
        return null;
    }

    /**
     * 被动技能或者被动出牌
     *
     * @param card
     */
    public void passivity(Card card) {
        if (card.getCardName().equals(CardFactory.ARROWS.getCardName())) {
            List<Card> cardList = this.getCardList();
            if (cardList.contains(CardFactory.FLASH)) {
                //闪
                log.info("{}出了一张闪", this.heroName);
            } else if (cardList.contains(CardFactory.UNASSAILABLE)) {
                //无懈可击
                log.info("{}出了一张无懈可击", this.heroName);
            } else {
                //掉一滴血
                log.info("{}掉了一滴血", this.heroName);
            }
            //让下一个英雄处理
        }

        if (getNextHero() != null) {
            getNextHero().passivity(card);
        }
    }
}

/**
*  具体英雄类，每个英雄有自己的被动和主动技能
**/
public class DiaoChan extends Hero{
}
public class GuanYu extends Hero{
}
public class LiuBang extends Hero{
}
public class SongJiang extends Hero{
}
public class ZhuGeLiang extends Hero{
}

/**
*  做一个英雄的简单工厂
**/
public class HeroFactory {

    /**
     * 获取英雄
     *
     * @param i
     * @return
     */
    public Hero getHero(int i) {
        switch (i) {
            case 1:
                DiaoChan diaoChan = new DiaoChan();
                diaoChan.setHeroName("貂蝉");
                return diaoChan;
            case 2:
                GuanYu guanYu = new GuanYu();
                guanYu.setHeroName("关羽");
                return guanYu;
            case 3:
                LiuBang liuBang = new LiuBang();
                liuBang.setHeroName("刘邦");
                return liuBang;
            case 4:
                SongJiang songJiang = new SongJiang();
                songJiang.setHeroName("宋江");
                return songJiang;
            case 5:
                ZhuGeLiang zhuGeLiang = new ZhuGeLiang();
                zhuGeLiang.setHeroName("诸葛亮");
                return zhuGeLiang;
            default:
                DiaoChan diaoChan1 = new DiaoChan();
                return diaoChan1;
        }
    }
}

模拟四张手牌：杀、闪、无懈可击、万箭齐发

@Data
public class Card {
    private String cardName;

    /**
     * 牌的类型： 基础、群锦囊、武器、延时锦囊、单体锦囊
     */
    private String type;

    public Card() {
    }

    public Card(String cardName, String type) {
        this.cardName = cardName;
        this.type = type;
    }

    @Override
    public String toString() {
        return cardName;
    }
}

/**
* 手牌的简单工厂
*/
public class CardFactory {
    public static final Card KILL = new Card("杀","base");
    public static final Card FLASH = new Card("闪","base");
    public static final Card ARROWS = new Card("万箭齐发","group");
    public static final Card UNASSAILABLE = new Card("无懈可击","single");;

    Card[] cardArr = {KILL, FLASH, ARROWS, UNASSAILABLE};

    /**
     * 随机获取一张牌
     * @return
     */
    public Card getCard() {
        Random random = new Random();
        return cardArr[random.nextInt(4)];
    }


    /**
     * 随机获取 <= 4 张牌
     * @return
     */
    public List<Card> getCards(){
        List<Card> cardList = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i <= random.nextInt(3) + 1; i++) {
            Card card = getCard();
            cardList.add(card);
        }
        return cardList;
    }
}

执行游戏

@Slf4j
public class HeroKillDemo {
    public static void main(String[] args) {
        /**
         * 场上有五位英雄,顺序为貂蝉、关羽、刘邦、宋江、诸葛亮
         */
        HeroFactory heroFactory = new HeroFactory();
        Hero diaoChan = heroFactory.getHero(1);
        Hero guanYu = heroFactory.getHero(2);
        Hero liuBang = heroFactory.getHero(3);
        Hero songJiang = heroFactory.getHero(4);
        Hero zhuGeLiang = heroFactory.getHero(5);
        diaoChan.setNextHero(guanYu);
        guanYu.setNextHero(liuBang);
        liuBang.setNextHero(songJiang);
        songJiang.setNextHero(zhuGeLiang);

        /**
         * 随机发牌
         */
        CardFactory cardFactory = new CardFactory();
        diaoChan.setCardList(cardFactory.getCards());
        log.info("hero :{} 拿到了{}张牌:{}", diaoChan.getHeroName(), diaoChan.getCardList().size(), diaoChan.getCardList());
        guanYu.setCardList(cardFactory.getCards());
        log.info("hero :{} 拿到了{}张牌:{}", guanYu.getHeroName(), guanYu.getCardList().size(), guanYu.getCardList());
        liuBang.setCardList(cardFactory.getCards());
        log.info("hero :{} 拿到了{}张牌:{}", liuBang.getHeroName(), liuBang.getCardList().size(), liuBang.getCardList());
        songJiang.setCardList(cardFactory.getCards());
        log.info("hero :{} 拿到了{}张牌:{}", songJiang.getHeroName(), songJiang.getCardList().size(), songJiang.getCardList());
        zhuGeLiang.setCardList(cardFactory.getCards());
        log.info("hero :{} 拿到了{}张牌:{}", zhuGeLiang.getHeroName(), zhuGeLiang.getCardList().size(), zhuGeLiang.getCardList());

        /**
         * 第一位英雄出牌，这里模拟貂蝉第一次出牌为万箭齐发
         */
        log.info("开始出牌......");

        Card accord = diaoChan.accord(CardFactory.ARROWS);
        log.info("貂蝉出了一张万箭齐发");
        guanYu.passivity(accord);

        log.info("回合结束......");
    }
}

执行效果：

image.png