设计模式之责任链模式简介说明

责任链模式简介

责任链模式(Chain of Responsibility Pattern)
责任链模式将链中每一个节点都看作一个对象
     每个节点处理的请求均不同
     且内部自动维护下一个节点对象
 
当一个请求从链式的首端发出时
     会沿着责任链预设的路径依次传递到每一个节点对象
     直至被链中的某个对象处理为止

责任链模式的优点
     职责链模式使多个对象都有机会处理请求
     从而避免请求的发送者和接收者之间的耦合关系

责任链模式中两个角色

责任链模式中两个角色
   1.抽象处理者(Handler):
         定义处理请求的方法
         并维护一个下一处理节点Handler对象的引用
   2.具体处理者(ConcreteHandler):
        对请求进行处理

public abstract class AbstractHandler {

    protected AbstractHandler successor;
    /**
     * 设置继任者
     */
    public void setSuccessor(AbstractHandler successor) {
        this.successor = successor;
    }

    protected abstract void doHandle(String request);
}
public class ConcreteHandlerA extends AbstractHandler {
    @Override
    protected void doHandle(String request) {
        if (request.startsWith("handlerA")) {
            System.out.println("ConcreteHandlerA execute: " + request);
        } else {
            // 请求向下传递
            successor.doHandle(request);
        }
    }
}

public class ConcreteHandlerB extends AbstractHandler {
    @Override
    public void doHandle(String request) {
        if (request.startsWith("handlerB")) {
            System.out.println("ConcreteHandlerB execute: " + request);
        } else {
            successor.doHandle(request);
        }
    }
}

public class ConcreteHandlerC extends AbstractHandler {
    @Override
    protected void doHandle(String request) {
        if (request.startsWith("handlerC")) {
            System.out.println("ConcreteHandlerC execute: " + request);
        } else {
            successor.doHandle(request);
        }
    }
}

测试

@Test
public void test() {
    AbstractHandler handlerA = new ConcreteHandlerA();
    AbstractHandler handlerB = new ConcreteHandlerB();
    AbstractHandler handlerC = new ConcreteHandlerC();
    handlerA.setSuccessor(handlerB);
    handlerB.setSuccessor(handlerC);

    list<String> list = Arrays.asList("handlerA000", "handlerB111", "handlerC222");
    for (String str : list) {
        handlerA.doHandle(str);
    }
}

3. 其他

public abstract class AbstractHandle {

    public static void main(String[] args) {
        AbstractHandle handle = Builder.create()
                .addHandler(new ValidateHandle())
                .addHandler(new LoginHandle())
                .addHandler(new AuthHandle())
                .build();
        handle.doHandle("111");
    }

    protected AbstractHandle chain;

    public void next(AbstractHandle handle) {
        this.chain = handle;
    }

    /**
     * 抽象方法
     * @param request
     */
    public abstract void doHandle(String request);

    public static class Builder {
        private AbstractHandle head;
        private AbstractHandle tail;

        public Builder addHandler(AbstractHandle handle) {
            if (this.head == null) {
                this.head = this.tail = handle;
                return this;
            }
            this.tail.next(handle);
            this.tail = handle;
            return this;
        }

        public AbstractHandle build() {
            return this.head;
        }

        public static Builder create() {
            return new Builder();
        }
    }
}

class ValidateHandle extends AbstractHandle {
    @Override
    public void doHandle(String request) {
        System.out.println("ValidateHandle start");
        if (chain != null) {
            chain.doHandle(request);
        }
    }
}

class LoginHandle extends AbstractHandle {
    @Override
    public void doHandle(String request) {
        System.out.println("LoginHandle start");
        if (chain != null) {
            chain.doHandle(request);
        }
    }
}

class AuthHandle extends AbstractHandle {
    @Override
    public void doHandle(String request) {
        System.out.println("AuthHandle start");
        // 若还有下一级，请求继续传递
        if (chain != null) {
            chain.doHandle(request);
        }
    }
}