设计模式之责任链模式

/**
 * 责任链抽象处理类
 */
public abstract class AbstractHandler {

    /** 下一个处理者 */
    private AbstractHandler nextHandler;
    
    /**
     * 处理每个请求，返回响应
     * @param request
     * @return
     */
    public final void handlerMessage(EventRequest request) {
        
        // 判断是否为达到处理条件，未达到，则中断处理
        if(!isCureentLevel(request)) {
            System.out.println("级别不符合，exit:" + this.getClass());
            return;
        }
        
        // 执行当前处理逻辑
        this.execute(request);
                
        // 判断是否有下一个处理类
        if(hasNextHandler()) {
            this.nextHandler.handlerMessage(request);
        } else {
            System.out.println("没有下一个处理类，exit:" + this.getClass());
        }
    }
    
    /**
     * 判断是否为达到处理条件，自定义满足条件
     * @param request
     * @return
     */
    protected abstract boolean isCureentLevel(EventRequest request);

    /**
     * 判断是否有下一个处理者
     * @return true-存在下个处理者；false-不存在
     */
    public boolean hasNextHandler() {
        return this.nextHandler != null;
    }
    
    /**
     * 定义处理逻辑
     * @param request
     * @return
     */
    protected abstract void execute(EventRequest request);

    /**
     * 设置下一个处理者
     * @param nextHandler
     */
    public void setNextHandler(AbstractHandler nextHandler) {
        this.nextHandler = nextHandler;
    }
    
}

public class EventRequest {
    
    private int level;

    public void setLevel(int level) {
        this.level = level;
    }

    public int getLevel() {
        return this.level;
    }
}

public class HeadHandler extends AbstractHandler {

    @Override
    protected void execute(EventRequest request) {
        System.out.println("head");
    }

    @Override
    protected boolean isCureentLevel(EventRequest request) {
        // 表示第一个节点，必须执行
        return true;
    }

}

public class Handler1 extends AbstractHandler {

    @Override
    protected void execute(EventRequest request) {
        System.out.println(1);
    }

    @Override
    protected boolean isCureentLevel(EventRequest request) {
        if (request.getLevel() >= 1) {
            return true;
        }
        return false;
    }
    
}

public class Handler2 extends AbstractHandler {

    @Override
    protected void execute(EventRequest request) {
        System.out.println(2);
    }

    @Override
    protected boolean isCureentLevel(EventRequest request) {
        if (request.getLevel() >= 2) {
            return true;
        }
        return false;
    }

}

public class Handler3 extends AbstractHandler {

    @Override
    protected void execute(EventRequest request) {
        System.out.println(3);
    }

    @Override
    protected boolean isCureentLevel(EventRequest request) {
        if (request.getLevel() >= 3) {
            return true;
        }
        return false;
    }

}

public class Main {

    public static void main(String[] args) {
        AbstractHandler headHandler = new HeadHandler();
        AbstractHandler handler1 = new Handler1();
        AbstractHandler handler2 = new Handler2();
        AbstractHandler handler3 = new Handler3();
        
        headHandler.setNextHandler(handler1);
        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);
        
        EventRequest request = new EventRequest();
        request.setLevel(2); // 设置处理级别
        headHandler.handlerMessage(request);
        
    }
}