分享一个责任链模式通用写法

方式一

思路

1. 责任链模式，是一个单向链表结构，所以需要记录下一个责任链
2. 通过构造器的链式编程方便添加责任链
3. 每次添加责任链，都会将最新的责任链记录到构造器里，这里无法找到链首，所以，单独定义一个变量存储第一个责任链的地址。

代码

public abstract class Handler<T> {

    /**
     * 下一次责任链
     */
    protected Handler<T> next;

    private void next(Handler<T> next){
        this.next = next;
    }

    /**
     * 当前责任链的主要行为
     * @param t
     */
    public abstract void process( T t);

    /**
     * 责任链执行操作
     *  1.执行本次责任
     *  2.执行下次责任
     * @param t
     */
    public void doHandle(T t) {

        process( t );

        if (next != null) {
            next.doHandle(t);
        }

    }

    /**
     * 责任链构造器
     * @param <T>
     */
    public static class Builder<T> {

        /**
         * 记录责任链头部引用
         */
        private Handler<T> head;

        /**
         * 记录新的责任链引用，用于追加责任链使用
         */
        private Handler<T> tail;

         public Builder<T> addHandler(Handler<T> handler) {
            if (this.head == null) {
                this.head = this.tail = handler;
                return this;
            }
            this.tail.next(handler);
            this.tail = handler;

            return this;
        }

        public Handler<T> build() {
            return this.head;
        }
    }


}

使用示例

public class Member {
    private String loginName;
    private String loginPass;
    private String roleName;

    public Member(String loginName, String loginPass) {
        this.loginName = loginName;
        this.loginPass = loginPass;
    }

    // Getter and Setter ...

    @Override
    public String toString() {
        return "Member{" +
                "loginName='" + loginName + '\'' +
                ", loginPass='" + loginPass + '\'' +
                '}';
    }
}

public class ValidateHandler extends Handler<Member> {

    @Override
    public void process(Member member) {

        if(StringUtils.isEmpty(member.getLoginName()) ||
            StringUtils.isEmpty(member.getLoginPass())){
            System.out.println("用户名或者密码为空");
            return;
        }

        System.out.println("用户名和密码校验成功，可以往下执行");

    }

}

public class LoginHandler extends Handler<Member> {

    @Override
    public void process(Member member) {
        System.out.println("登录成功！");
        member.setRoleName("管理员");
    }
}

public class AuthHandler extends Handler<Member> {

    @Override
    public void process(Member member) {
        if(!"管理员".equals(member.getRoleName())){
            System.out.println("您不是管理员，没有操作权限");
            return;
        }
        System.out.println("您是管理员，允许操作");
    }

}

public class ChainMock {
    public static void login(String loginName,String loginPass){

        Handler<Member> handler = new Handler.Builder<Member>()
                .addHandler(new ValidateHandler())
                .addHandler(new LoginHandler())
                .addHandler(new AuthHandler())
                .build();

        handler.doHandle(new Member(loginName,loginPass));

    }

    public static void main(String[] args) {
        login( "admin", "123456");
    }

}

方式二

思路

1. 用数组存储所有的责任
2. 存储完成后依次执行责任

代码

public interface Handler<T> {

    /**
     * 责任链执行操作
     * @param t
     */
    void doHandle(T t);

}

public class HandlerChain<T> {

    private List<Handler<T>> handlers = new ArrayList<>();

    public HandlerChain addHandler(Handler<T> handler) {
        this.handlers.add( handler );
        return this;
    }

    public void doChain(T t) {
        for (Handler handler : handlers) {
            handler.doHandle( t );
        }
    }

}

参考

https://cloud.tencent.com/developer/article/1922345