责任链模式的使用

一、模式介绍

责任链模式是将链中的每一个节点看作一个处理器，每个处理器拥有自己独立的处理逻辑，且保持有下一个处理器的引用。在处理逻辑的最后，调用下一个处理器。当一个请求进入责任链的时候，会沿着预设的责任链路径将请求依次往后传递，直至被中间某个处理节点终止或者完成整个责任链的处理。

我们以一个多步骤权限验证为例进行讲解。

@NoArgsConstructor
@AllArgsConstructor
@Data
public class User {
    private String username;
    private String password;
    private String role;
}

@Slf4j
public class UserCheckService {
    public void login(String username, String password){
        // 第一步，判断非空
        if(ObjectUtils.isEmpty(username) || ObjectUtils.isEmpty(password)){
            log.error("用户名或密码不能为空！");
            return;
        }

        // 第二步，检查用户是否存在
        // 模拟从数据库中查询用户的信息及角色
        User user = new User();
        user.setUsername("zhangsan");
        user.setRole("admin");
        if(ObjectUtils.isEmpty(user.getUsername()) || ObjectUtils.isEmpty(user.getRole())){
            log.error("查无此用户或该用户无角色！");
            return;
        }

        //第三步，角色校验
        if(!"admin".equals(user.getRole())){
            log.error("非管理员角色无法操作！");
            return;
        }

        log.info("允许您的操作！");
    }
}

public class Main {
    public static void main(String[] args) {
        UserCheckService userCheckService = new UserCheckService();
        userCheckService.login("zhangsan", "123");
    }
}

如上案例中，一个请求会经过三个步骤的验证，这些验证如果很复杂，都写在一起就显得臃肿，不好扩展。我们使用责任链模式来进行重构。

public abstract class PermissionHandler {
    protected PermissionHandler nextHandler;

    public void nextHandler(PermissionHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void doHandle(User user);
}

@Slf4j
public class InputNotEmptyHandler extends PermissionHandler{
    @Override
    public void doHandle(User user) {
        if(ObjectUtils.isEmpty(user.getUsername()) || ObjectUtils.isEmpty(user.getPassword())){
            log.error("用户名或密码不能为空！");
            return;
        }

        log.info("InputNotEmptyHandler校验通过！");
        nextHandler.doHandle(user);
    }
}

@Slf4j
public class ExistHandler extends PermissionHandler{
    @Override
    public void doHandle(User user) {
        // 模拟从数据库中查询用户的信息及角色
        user.setUsername("zhangsan");
        user.setRole("admin");
        if(ObjectUtils.isEmpty(user.getUsername()) || ObjectUtils.isEmpty(user.getRole())){
            log.error("查无此用户或该用户无角色！");
            return;
        }

        log.info("ExistHandler校验通过！");
        nextHandler.doHandle(user);
    }
}

@Slf4j
public class RoleCheckHandler extends PermissionHandler{
    @Override
    public void doHandle(User user) {
        if(!"admin".equals(user.getRole())){
            log.error("非管理员角色无法操作！");
            return;
        }

        log.info("RoleCheckHandler校验通过");
    }
}

public class Main {
    public static void main(String[] args) {
        PermissionHandler inputNotEmptyHandler = new InputNotEmptyHandler();
        PermissionHandler existHandler = new ExistHandler();
        PermissionHandler roleCheckHandler = new RoleCheckHandler();
        inputNotEmptyHandler.nextHandler(existHandler);
        existHandler.nextHandler(roleCheckHandler);

        User zhangsan = new User();
        zhangsan.setUsername("zhangsan");
        zhangsan.setPassword("123");
        inputNotEmptyHandler.doHandle(zhangsan);
    }
}

我们预设了责任链：InputNotEmptyHandler——>ExistHandler——>RoleCheckHandler，那么一个请求就会验证这个责任链一步步往后传递，要么被某个节点return终止，要么直至最后处理完成。

二、使用案例

• JDK中的Filter，它是一个接口，类似我们的抽象Handler，它的子类实现其中的doFilter方法；

三、模式总结

3.1 优点

• 将请求和处理进行解耦；请求处理者只关注自己感兴趣的请求进行处理，对于不感兴趣的交给下一个节点处理；
• 具备链式传递处理能力，请求发送者不需要知道全局链路，符合迪米特法则（最少只是原则）；
• 链路结构灵活，可以通过改变链路结构动态地增减责任，符合开闭原则；

3.2 缺点

• 责任链太长或者某个处理节点处理时间过长，会影响整体的性能；
• 如果处理节点存在循环引用，会造成死循环；