前段时间写过一篇关于自定义拦截器实现权限过滤的文章，当时是用了自定义mybatis拦截器实现的：SpringBoot自定义Mybatis拦截器实现扩展功能(比如数据权限控制)。最近学习设计模式发现可以用责任链模式实现权限过滤，因此本篇采用责任链模式设计实现权限功能，算是抛砖引玉吧！

前言

项目采用Spring Boot 2.7.12 + JDK 8实现，权限认证就是一个拦截的过程，所以在实现的时候理论上可以做到任意的配置，对任意接口设置任意规则。考虑到鉴权是一系列顺序执行，所以使用了责任链模式进行设计和实现。

一、项目整体架构

项目下载地址，欢迎各位靓仔靓妹Star哦~~
permission

二、项目介绍

1.权限注解及权限处理器

Authority注解用于对controller层设置不同的读写类型

/**
 * 权限注解
 *
 * @author huahua
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Authority {

    /**
     * 方法描述
     */
    String description();

    /**
     * 权限名称
     */
    String permissionName() default "";

    /**
     * 权限类型，1读，2读写
     */
    int type() default 1;

    /**
     * 不允许访问的用户id
     */
    int notAllow() default 0;
}

AuthorityBeanPostProcess

/**
 * 权限处理器
 *
 * @author huahua
 */
@Component
public class AuthorityBeanPostProcess implements BeanPostProcessor {
    public static Map<String,Authority> map = new HashMap();
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Class<?> aClass = bean.getClass();
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for (Method method : declaredMethods) {
            if (method.isAnnotationPresent(Authority.class)) {
                String name = method.getName();
                Authority annotation = method.getAnnotation(Authority.class);
                map.put(name,annotation);
            }
        }
        return bean;
    }
}

2.自定义权限拦截器

AuthorityInterceptor
在springBoot项目启动时，把所有被@Authority注解注释的方法筛选出来，并且放入缓存中(这里直接放到了map中)备用。这里也可以将方法存入数据库中，字段就是权限的各种拦截方式，可以根据需要自己调整，并且配合责任链模式，扩展、调整都很方便。

/**
 * 自定义的权限拦截器
 *
 * @author huahua
 */
@Component
public class AuthorityInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            String name = handlerMethod.getMethod().getName();
            //拦截器想要获取容器中bean需要拿到bean工厂进行getBean()
            BeanFactory factory = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getServletContext());
            AuthorityHandlerProcess authorityProcess = factory.getBean("authorityProcess", AuthorityHandlerProcess.class);
            //从redis或者缓存中取得方法与权限关系
            Authority authority = AuthorityBeanPostProcess.map.get(name);
            if (authority != null) {
                //对当前用户进行权限校验
                //实际场景中，需要根据当前登录用户身份从数据库中查询其权限角色信息
                //获取用户信息。因为用户已经登录了，那么user的信息是保存在我们的缓存里的,token获取,这里写一个假数据。
                User user = new User();
                //模拟一个用户，设置其权限类型，1读，2读写
                user.setAuthority(1);
                user.setId(1);
                try {
                    //责任链调用,可以动态配置调用规则,即权限校验规则,
                    authorityProcess.process(user, authority);
                } catch (Exception e) {
                    //统一捕捉异常,返回错误信息
                    throw new BusinessException(ExceptionEnum.FORBIDDEN.getCode(),
                            ExceptionEnum.FORBIDDEN.getMsg(), "不允许的操作类型");
                }
            }
        }
        return true;
    }
}

3.抽象权限处理类及其handler实现

AbstractAuthorityHandler

/**
 * 抽象权限处理类
 *
 * @author huahua
 */
public abstract class AbstractAuthorityHandler {
    abstract void processHandler(User user, Authority authority) throws Exception;
}

AuthorityHandlerProcess

/**
 * 权限处理器
 *
 * @author huahua
 */
@Component("authorityProcess")
public class AuthorityHandlerProcess {
    //读取yaml配置文件配置的各个拦截器handler，可以自定义或者从其他地方读取
    @Value("#{'${requirement.handler}'.split(',')}")
    private List<String> handlers;

    public void process(User user, Authority authority) throws Exception{
        // 如果想要实时的进行顺序的调整或者是增减。那必须要使用配置中心进行配置。
        // 比如springcloud里边自带的config的配置中心,applo 配置中心。
        for(String handler : handlers) {
            //forName要包含包名和类名，不然就会报 ClassNotFoundException 错误，因为通过反射实例化类时传递的类名称必须是全路径名称
            AbstractAuthorityHandler handle =
                    (AbstractAuthorityHandler) Class.forName(handler).newInstance();
            handle.processHandler(user, authority);
        }
    }
}

AuthorityNotAllowHandler

/**
 * 不允许操作的handler
 *
 * @author huahua
 */
public class AuthorityNotAllowHandler extends AbstractAuthorityHandler {
    @Override
    void processHandler(User user, Authority authority){
        if (authority.notAllow() == user.getId()) {
            throw new BusinessException(ExceptionEnum.FORBIDDEN.getCode(),
                    ExceptionEnum.FORBIDDEN.getMsg(), "不允许的访问id");
        }
    }
}

AuthorityTypeHandler

/**
 * 不允许操作类型的handler
 *
 * @author huahua
 */
public class AuthorityTypeHandler extends AbstractAuthorityHandler{
    @Override
    void processHandler(User user, Authority authority) {
        if (authority.type() > user.getAuthority()) {
            throw new BusinessException(ExceptionEnum.FORBIDDEN.getCode(),
                    ExceptionEnum.FORBIDDEN.getMsg(), "不允许的操作类型");
        }
    }
}

4.统一响应结果封装类

ErrorCode错误码

/**
 * 错误码
 *
 * @author huahua
 */
@Data
public class ErrorCode {
    private final Integer code;

    private final String msg;

    public ErrorCode(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }
}

R响应结果

/**
 * 统一响应结果封装类
 *
 * @author huahua
 */
@Data
@Accessors(chain = true)
public class R<T> {

    /**
     * 状态码
     */
    private Integer code;

    /**
     * 响应信息
     */
    private String msg;

    /**
     * 数据
     */
    private T data;

    /**
     * 状态码200 + 固定成功信息提示（’success‘）
     *
     * @return 实例R
     */
    public static R success() {
        return new R()
                .setCode(HttpStatus.OK.value())
                .setMsg("success");
    }

    /**
     * 状态码200 + 固定成功信息提示（’success‘）+ 自定义数据
     *
     * @param data 数据
     * @param <T>  回显数据泛型
     * @return 实例R
     */
    public static <T> R success(T data) {
        return success().setData(data);
    }

    /**
     * 状态码500 + 固定错误信息提示（'fail'）的失败响应
     *
     * @return 实例R
     */
    public static R fail() {
        return new R()
                .setCode(HttpStatus.INTERNAL_SERVER_ERROR.value())
                .setMsg("fail");
    }

    /**
     * 状态码500 + 自定义错误信息的失败响应
     *
     * @param msg  错误信息
     * @return 实例R
     */
    public static <T> R fail(String msg) {
        return new R()
                .setCode(HttpStatus.INTERNAL_SERVER_ERROR.value())
                .setMsg(msg);
    }

    /**
     * 状态码自定义 + 错误信息自定义的失败响应
     * {@link GlobalErrorCodeConstants}
     *
     * @param data 数据
     * @param msg  错误信息
     * @return 实例R
     */
    public static R fail(Integer errorCode, String msg) {
        return fail()
                .setCode(errorCode)
                .setMsg(msg);
    }

    /**
     * 自定义错误类封装的失败响应
     *
     * @param error 自定义错误类
     * @return 实例R
     * @see ErrorCode
     */
    public static R fail(ErrorCode error) {
        return fail()
                .setCode(error.getCode())
                .setMsg(error.getMsg());
    }
}

5.统一异常处理

关于统一异常处理，可以参考Spring、SpringBoot统一异常处理的3种方法。
通过 Spring 的 AOP 特性就可以很方便的实现异常的统一处理：使用@ControllerAdvice、@RestControllerAdvice捕获运行时异常。
ExceptionEnum异常枚举类

/**
 * 异常枚举类
 *
 * @author huahua
 */
public enum ExceptionEnum {
    // 400
    BAD_REQUEST("400", "请求数据格式不正确!"),
    UNAUTHORIZED("401", "登录凭证过期!"),
    FORBIDDEN("403", "没有访问权限!"),
    NOT_FOUND("404", "请求的资源找不到!"),

    // 500
    INTERNAL_SERVER_ERROR("500", "服务器内部错误!"),
    SERVICE_UNAVAILABLE("503", "服务器正忙，请稍后再试!"),

    // 未知异常
    UNKNOWN("10000", "未知异常!"),

    // 自定义
    IS_NOT_NULL("10001","%s不能为空");

    /**
     * 错误码
     */
    private String code;

    /**
     * 错误描述
     */
    private String msg;

    ExceptionEnum(String code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public String getCode() {
        return code;
    }

    public String getMsg() {
        return msg;
    }
}

BusinessException自定义业务异常类

/**
 * 自定义业务异常类
 *
 * @author huahua
 */
public class BusinessException extends RuntimeException {

    private ExceptionEnum exceptionEnum;
    private String code;
    private String errorMsg;

    public BusinessException() {
        super();
    }

    public BusinessException(ExceptionEnum exceptionEnum) {
        super("{code:" + exceptionEnum.getCode() + ",errorMsg:" + exceptionEnum.getMsg() + "}");
        this.exceptionEnum = exceptionEnum;
        this.code = exceptionEnum.getCode();
        this.errorMsg = exceptionEnum.getMsg();
    }

    public BusinessException(String code, String errorMsg) {
        super("{code:" + code + ",errorMsg:" + errorMsg + "}");
        this.code = code;
        this.errorMsg = errorMsg;
    }

    public BusinessException(String code, String errorMsg, Object... args) {
        super("{code:" + code + ",errorMsg:" + String.format(errorMsg, args) + "}");
        this.code = code;
        this.errorMsg = String.format(errorMsg, args);
    }

    public ExceptionEnum getExceptionEnum() {
        return exceptionEnum;
    }

    public String getErrorMsg() {
        return errorMsg;
    }

    public void setErrorMsg(String errorMsg) {
        this.errorMsg = errorMsg;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

RestControllerAdvice统一异常处理

/**
 * RestControllerAdvice，统一异常处理
 *
 * @author huahua
 */
@Slf4j
@RestControllerAdvice
public class ExceptionHandlerConfig {

    /**
     * 业务异常处理
     *
     * @param e 业务异常
     * @return
     */
    @ExceptionHandler(value = BusinessException.class)
    @ResponseBody
    public R exceptionHandler(BusinessException e) {
        return R.fail(Integer.valueOf(e.getCode()), e.getErrorMsg());
    }

    /**
     * 未知异常处理
     */
    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public R exceptionHandler(Exception e) {
        return R.fail(Integer.valueOf(ExceptionEnum.UNKNOWN.getCode()),
                ExceptionEnum.UNKNOWN.getMsg());
    }

    /**
     * 空指针异常
     */
    @ExceptionHandler(value = NullPointerException.class)
    @ResponseBody
    public R exceptionHandler(NullPointerException e) {
        return R.fail(Integer.valueOf(ExceptionEnum.INTERNAL_SERVER_ERROR.getCode()),
                ExceptionEnum.INTERNAL_SERVER_ERROR.getMsg());
    }
}

6.将自定义拦截器加入到SpringBoot 的拦截器列表中

如果不加入Spring Boot拦截器列表，自定义拦截器不会生效。
WebConfig

/**
 * 将自定义拦截器加入到SpringBoot 的拦截器列表中
 *
 * @author huahua
 */
@Configuration
@Component
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private AuthorityInterceptor authorityInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(this.authorityInterceptor).addPathPatterns("/**");
    }
}

7.Controller层

UserController

@RestController
@RequestMapping("user")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping("/getUser/{id}")
    @Authority(description = "获得用户信息",permissionName = "user:getUser",type = 1)
    R getUser(@PathVariable("id") Integer id) {
        return R.success(userService.queryUser(id));
    }

    @DeleteMapping("deleteUser/{id}")
    @Authority(description = "删除用户信息",permissionName = "user:deleteUser",type = 2,notAllow = 2)
    R deleteUser(@PathVariable("id") Integer id) {
        return R.success(userService.deleteUser(id));
    }
}

8.Service层

@Service
public class UserService {

    /**
     * 查询
     *
     * @param id 用户id
     * @return User
     */
    public User queryUser(Integer id) {
        return User.builder().id(id).age(20).address("武当山").name("三丰啊").authority(1).build();
    }

    /**
     * 删除
     *
     * @param id 用户id
     * @return int
     */
    public int deleteUser(Integer id) {
        return 1;
    }
}

三、测试

1.设置模拟用户读权限

AuthorityInterceptor自定义拦截器，模拟设置用户只有读权限即 user.setAuthority(1)

测试查询接口，可以发现该用户拥有查询权限！


测试删除接口，可以发现该用户没有删除权限！

2.设置模拟用户读写权限

AuthorityInterceptor自定义拦截器，模拟设置用户有读写权限即 user.setAuthority(2).
测试查询接口，可以发现该用户拥有查询权限！

测试删除接口，可以发现该用户拥有删除权限！

总结

通过责任链模式实现了权限校验功能，此项目还有好多地方功能不完美或者说是不完善，需要迭代扩展和优化，后续会及时更新优化。

参考资料
SpringBoot —— 统一异常处理
SpringBoot 自定义拦截器 HandlerInterceptor 方法没有生效
Class.forName()报 classnotfoundexception 错误解决办法
权限认证实现(责任链模式)
浅谈（chain of responsibility）责任链模式
责任链设计模式及其典型应用场景剖析