责任链模式：来自玩家的投诉

一、模式定义

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

1. Handler：抽象处理器，对处理请求的方法进行抽象，并定义一个方法来返回对下一个处理者的引用。
2. ConcreteHandler：具体处理者，持有下一个处理者的引用。接到请求后，可以选择将请求处理掉，或者将请求传给下一个处理者。
3. Request：交由责任链处理的请求。

二、举例说明

• 场景：当一个请求需要通过一系列的处理工作，而且可能调整处理的顺序或者增加、删除某处理的工作时。
• 需求：最近收到很多玩家的恶意投诉，比如比赛中某位玩家只是技术不行，却被其他投诉为说脏话；再比如投诉建议中没有一句话。导致我们收到大量的无用消息。先需要设计一个过滤器，由程序先过滤一部分无用消息。

三、代码实现

1. 创建投诉类（Request）

public class Complain {
    private String type;
    private String message;

    public Complain(String type, String message) {
        this.type = type;
        this.message = message;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

2. 创建抽象的投诉处理器

public abstract class AbstractComplaintHandler {
    private AbstractComplaintHandler nextHandler;

    public AbstractComplaintHandler(AbstractComplaintHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public AbstractComplaintHandler getNextHandler() {
        return nextHandler;
    }

    public abstract void handlerRequest(Complain complain);
}

3. 三种处理器：脏话处理器、建议处理器、人工处理器

/**
 * 脏话处理器
 *
 * @author: jsk
 * @date: 2019/8/11 13:12
 */
public class BadLanguageHandler extends AbstractComplaintHandler {
    public BadLanguageHandler(AbstractComplaintHandler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handlerRequest(Complain complain) {
        System.out.println("【脏话】处理器开始处理...");
        if ("脏话".equals(complain.getType())) {
            // 模拟检测脏话
            if (new Double(Math.random() * 100).intValue() % 2 == 0) {
                System.out.println("系统检测到本场比赛,没有玩家脏话！");
                System.out.println("-------------------------------------");
                return;
            } else {
                System.out.println("本场游戏确实存在辱骂行为,交由后面人工审核！");
            }
        } else {
            System.out.println("投诉类型不是【脏话】,交由后面的处理器处理！");
        }
        this.getNextHandler().handlerRequest(complain);
        System.out.println("-------------------------------------");
    }
}

/**
 * 玩家建议处理器
 *
 * @author: jsk
 * @date: 2019/8/11 13:24
 */
public class SuggestHandler extends AbstractComplaintHandler {
    public SuggestHandler(AbstractComplaintHandler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handlerRequest(Complain complain) {
        System.out.println("【玩家建议】处理器开始处理...");
        if ("玩家建议".equals(complain.getType())) {
            if (complain.getMessage() == null || "".equals(complain.getMessage())) {
                System.out.println("建议为空,无需处理！");
                return;
            }
        } else {
            System.out.println("投诉类型不是【玩家建议】,交由后面的处理器处理！");
        }
        this.getNextHandler().handlerRequest(complain);
    }
}

/**
 * 人工处理器
 *
 * @author: jsk
 * @date: 2019/8/11 13:24
 */
public class ArtificialHandler extends AbstractComplaintHandler {
    public ArtificialHandler(AbstractComplaintHandler nextHandler) {
        super(nextHandler);
    }

    @Override
    public void handlerRequest(Complain complain) {
        System.out.println("【人工】处理器处理玩家的投诉...");
        System.out.println("【人工】处理器处理结束");
    }
}

4. 客户端执行

public static void main(String[] args) {
    // 1.构造处理器链
    AbstractComplaintHandler artificialHandler = new ArtificialHandler(null);
    AbstractComplaintHandler suggestHandler = new SuggestHandler(artificialHandler);
    AbstractComplaintHandler badLanguageHandler = new BadLanguageHandler(suggestHandler);

    // 2.创建玩家的投诉,并交给处理器链处理
    Complain complain = new Complain("脏话", null);
    badLanguageHandler.handlerRequest(complain);

    complain = new Complain("玩家建议", null);
    badLanguageHandler.handlerRequest(complain);

    complain = new Complain("玩家建议", "我们队伍的提莫,不但故意送人头还骂人,请官方严肃处理。");
    badLanguageHandler.handlerRequest(complain);
}

执行结果