设计模式之责任链模式

• 责任链模式

用来按责任顺序来处理一系列的事务，由多个节点组成的一条执行链。一个节点处理完业务逻辑后，会根据实际的需求，去传递给下一个节点。如果符合业务处理条件，则会一直执行至最后一个节点处理完成。

下面是两种方式实现：

（1）给每个节点都设置下一个节点处理类，如果最后一个节点没有设置下一节点，则结束。

（2）使用List，将所有的任务节点按顺序放入list中，循环执行调用即可。

• 方式一

/**
 * 责任链抽象处理类
 */
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);
        
    }
}

•  方式二

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

    protected abstract void handle();

    public void execute(Chain successor) {
        handle();
        successor.execute();
    }

}

public class HandlerChain1 extends AbstractHandlerChain {

    @Override
    protected void handle() {
        System.out.println(1);
    }
    
}

public class HandlerChain2 extends AbstractHandlerChain {

    @Override
    protected void handle() {
        System.out.println(2);
    }
    
}

public class HandlerChain3 extends AbstractHandlerChain {

    @Override
    protected void handle() {
        System.out.println(3);
    }
    
}

/**
 * 责任链入口
 */
public class Chain {
    
    private int index = 0;

    /** 所有的链路节点 */
    private List<AbstractHandlerChain> handlers;
    
    /**
     * 责任链入口，拥有所有的链路节点
     * @param handlers
     */
    public Chain(List<AbstractHandlerChain> handlers) {
        super();
        this.handlers = handlers;
    }

    /**
     * 处理每个请求，并执行下一执行节点，直至结束
     * @param request
     * @return
     */
    public final void execute() {
        if(index < handlers.size()){
            handlers.get(index++).execute(this);
        }
    }
}

public class Main {

    public static void main(String[] args) {
        List<AbstractHandlerChain> list = new ArrayList<AbstractHandlerChain>();
        list.add(new HandlerChain1());
        list.add(new HandlerChain2());
        list.add(new HandlerChain3());
        
        Chain chain = new Chain(list);
        
        chain.execute();
    }
}