责任链模式

定义

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

优点

请求发送者只需要知道链中的第一个节点，从而弱化发送者和接收者之间的强耦合关系。
链中的节点对象可以灵活组合。可以动态地改变链中的节点顺序，也可以动态地新增或删除节点。

缺点

责任链过长，可能影响性能。
调试不方便，一旦链中出现循环，就可能导致死循环。

代码示例

java

public class Role {
    private String name;
    private int health;
    private int attack;
    private int defense;
    private StateType stateType;

    public Role(String name, int health, int attack, int defense) {
        this.name = name;
        this.health = health;
        this.attack = attack;
        this.defense = defense;
        this.stateType = StateType.Normal;
    }

    public StateType getStateType() {
        return stateType;
    }

    public void setStateType(StateType stateType) {
        this.stateType = stateType;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getAttack() {
        return attack;
    }

    public void setAttack(int attack) {
        this.attack = attack;
    }

    public int getDefense() {
        return defense;
    }

    public void setDefense(int defense) {
        this.defense = defense;
    }

    @Override
    public String toString() {
        String format = "╭───────────────────────────────\n"+
                "├角色名称:%s\n"+
                "├角色生命值：%d\n"+
                "├角色攻击力：%d\n"+
                "├角色防御力：%d\n"+
                "├角色状态：%s\n"+
                "╰───────────────────────────────";
        return String.format(format,
                this.name,
                this.health,
                this.attack,
                this.defense,
                this.stateType.getName());
    }
}

java

public class EventRequest {
    private Role source;
    private Role target;
    private EventType eventType;

    private Map<String, Object> params;

    public EventRequest(Role source, Role target, EventType eventType, Map<String, Object> params) {
        this.source = source;
        this.target = target;
        this.eventType = eventType;
        this.params = params;
    }

    public Role getTarget() {
        return target;
    }

    public void setTarget(Role target) {
        this.target = target;
    }

    public Role getSource() {
        return source;
    }

    public void setSource(Role source) {
        this.source = source;
    }

    public EventType getEventType() {
        return eventType;
    }

    public void setEventType(EventType eventType) {
        this.eventType = eventType;
    }

    public Map<String, Object> getParams() {
        return params;
    }

    public void setParams(Map<String, Object> params) {
        this.params = params;
    }
}

java

public enum EventType {
    FlyAttack,
    VertigoAttack,
    MethysisAttack
    ;
}

java

public enum StateType {
    Fly("击飞"),
    Vertigo("眩晕"),
    Methysis("中毒"),
    Normal("正常")
    ;
    private final String name;

    StateType(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

java

public abstract class EventHandler {
    protected EventHandler next;

    public EventHandler(EventHandler next) {
        this.next = next;
    }

    public EventHandler() {
        super();
    }

    public EventHandler getNext() {
        return next;
    }

    public void setNext(EventHandler next) {
        this.next = next;
    }

    public abstract void handleEvent(EventRequest eventRequest);
}

java

public class FlyAttackEventHandler extends EventHandler{
    public FlyAttackEventHandler() {
        super();
    }

    public FlyAttackEventHandler(EventHandler next) {
        super(next);
    }

    @Override
    public void handleEvent(EventRequest eventRequest) {
        EventType eventType = eventRequest.getEventType();
        if (eventType == EventType.FlyAttack) {
            System.out.println("处理击飞攻击事件");
            eventRequest.getTarget().setStateType(StateType.Fly);
            return;
        }
        if (next == null) {
            System.out.println("未知的事件类型");
            return;
        }
        // 处理不了进入下一个处理器
        next.handleEvent(eventRequest);
    }
}

java

public class MethysisAttackEventHandler extends EventHandler{
    public MethysisAttackEventHandler() {
        super();
    }

    public MethysisAttackEventHandler(EventHandler next) {
        super(next);
    }

    @Override
    public void handleEvent(EventRequest eventRequest) {
        EventType eventType = eventRequest.getEventType();
        if (eventType == EventType.MethysisAttack) {
            System.out.println("处理毒属性攻击事件");
            eventRequest.getTarget().setStateType(StateType.Methysis);
            return;
        }
        if (next == null) {
            System.out.println("未知的事件类型");
            return;
        }
        // 处理不了进入下一个处理器
        next.handleEvent(eventRequest);
    }
}

java

public class VertigoAttackEventHandler extends EventHandler{
    public VertigoAttackEventHandler() {
        super();
    }

    public VertigoAttackEventHandler(EventHandler next) {
        super(next);
    }

    @Override
    public void handleEvent(EventRequest eventRequest) {
        EventType eventType = eventRequest.getEventType();
        if (eventType == EventType.VertigoAttack) {
            System.out.println("处理眩晕攻击事件");
            eventRequest.getTarget().setStateType(StateType.Vertigo);
            return;
        }
        if (next == null) {
            System.out.println("未知的事件类型");
            return;
        }
        // 处理不了进入下一个处理器
        next.handleEvent(eventRequest);
    }
}

java

public class Client {
    public static void main(String[] args) {
        EventHandler eventHandler = new FlyAttackEventHandler();
        MethysisAttackEventHandler methysisAttackEventHandler = new MethysisAttackEventHandler();
        VertigoAttackEventHandler vertigoAttackEventHandler = new VertigoAttackEventHandler();
        eventHandler.setNext(methysisAttackEventHandler);
        methysisAttackEventHandler.setNext(vertigoAttackEventHandler);

        Role zhangSan = new Role("张三", 100, 10, 8);
        Role liSi = new Role("李四", 100, 10, 8);

        // 模拟张三攻击李四
        EventRequest eventRequest = new EventRequest(zhangSan, liSi, EventType.FlyAttack, new HashMap<>());
        eventHandler.handleEvent(eventRequest);


        // 模拟李四攻击张三
        eventRequest = new EventRequest(zhangSan, liSi, EventType.VertigoAttack, new HashMap<>());
        eventHandler.handleEvent(eventRequest);

        System.out.println(zhangSan);
        System.out.println(liSi);

    }
}

结果：

txt

处理击飞攻击事件
处理眩晕攻击事件
╭───────────────────────────────
├角色名称:张三
├角色生命值：100
├角色攻击力：10
├角色防御力：8
├角色状态：正常
╰───────────────────────────────
╭───────────────────────────────
├角色名称:李四
├角色生命值：100
├角色攻击力：10
├角色防御力：8
├角色状态：眩晕
╰───────────────────────────────

责任链模式 ​

定义 ​

优点 ​

缺点 ​

代码示例 ​

责任链模式

定义

优点

缺点

代码示例