使用【注解】加【拦截器】实现权限控制

前面介绍了使用 SpringSecurity 进行权限控制，其中一个非常方便的特点就是：可以在类和方法上使用注解，从而实现对资源访问的权限控制。但是 Spring Security 具有一定的学习成本和复杂度，想要灵活驾驭并用好框架并非一件容易的事情，比如跟其它系统进行单点登录集成等等。

本篇博客介绍注解加拦截器的自定义权限控制方案，所有代码完全由自己掌控，而且实现了在在类和方法上使用注解实现对资源访问的权限控制。在绝大多数项目中，该方案完全可以满足需求。在本篇博客的最后会提供源代码下载。

需要注意的是：由于本篇博客只是进行 Demo 代码演示，所以使用了 Session 的方案。在实际项目中，可以参考该 Demo 进行方案改造，采用 Token 加 Redis 的方式进行用户信息存储，确保后端服务接口的无状态，从而能够满足负载均衡的需求。

一、搭建工程

搭建一个 SpringBoot 工程，其结构如下所示：

CheckPower 是自定义的注解，用来配置访问资源所需要的权限信息

Result 是自定义的返回结果类，统一使用该类的实例对象生成 json 返回给前端

WebMvcConfig 是对网站相关的配置，包括：拦截器配置、静态资源放行、knife4j 接口文档配置等

controller 下面的类都是对外提供的接口，我们会在这里的类和方法上使用注解配置访问权限

CheckPowerInterceptor 是自定义的拦截器，用于对 controller 类和方法上的注解进行解析，控制用户访问权限

先看一下 pom 文件引入的依赖包：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>com.jobs</groupId>
    <artifactId>springboot_annotion1</artifactId>
    <version>1.0</version>
 
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.8</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <!--引入 knife4j 接口文档，用于测试接口-->
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-spring-boot-starter</artifactId>
            <version>3.0.3</version>
        </dependency>
        <!--里面有很多非常实用的工具类-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.4.3</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.4.5</version>
            </plugin>
        </plugins>
    </build>
</project>

我们不使用相关的 web 页面进行测试，这里引入 knife4j 依赖包，使用接口文档进行接口测试，非常方便。

然后看一下 application.yml 文件内容，我们没有连接数据库去验证用户登录，这里直接配置了测试用户信息：

server:
  port: 8888
  servlet:
    session:
      # 设置 session 有效期为 10 分钟
      timeout: 10m
 
knife4j:
  # 是否启用增强版功能
  enable: true
  # 如果是生产环境，将此设置为 true，然后就能够禁用了 knife4j 的页面
  production: false
 
# 自定义的用户配置
user:
  username: jobs
  password: 123
  powerlist: delorder,adduser,admin

最后再看一下 Result 类，统一使用该类的实例对象生成 json 返回给前端：

package com.jobs.common;
 
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
 
@ApiModel("返回结果")
@Data
public class Result<T> implements Serializable {
 
    @ApiModelProperty("状态码")
    private Integer status;
 
    @ApiModelProperty("状态消息")
    private String msg;
 
    @ApiModelProperty("返回的数据")
    private T data;
 
    public static <T> Result<T> success(T object) {
        Result<T> r = new Result<T>();
        r.status = 0;
        r.msg = "success";
        r.data = object;
        return r;
    }
 
    public static <T> Result<T> fail(Integer status, String msg) {
        Result r = new Result();
        r.status = status;
        r.msg = msg;
        return r;
    }
 
    public static <T> Result<T> error(String msg) {
        Result r = new Result();
        r.status = 500;
        r.msg = msg;
        return r;
    }
}

二、注解和拦截器

创建自定义注解 CheckPower ，可以配置在 controller 类以及其内部的方法上，其内容如下：

package com.jobs.annotation;
 
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface CheckPower {
 
    //需要具备的权限列表，默认情况下数据组只有一个空字符串元素，表示登录后不需要验证权限就可以访问
    String[] power() default "";
 
    //如果配置了多个权限，之间是 and 关系，还是 or 关系
    //如果是 and 关系，则表示登录的用户，必须同时具备所配置的多个权限，才能访问
    //如果是 or 关系，则表示登录的用户，只要具备所配置的权限列表中的任意一个权限，就可以访问
    String loggic() default "or";
}

power 属性是个数组，可以为资源配置多个访问权限，其默认值是空字符串。如果没有对 power 属性进行配置，power 属性就是拥有一个空字符串元素的数组。

loggic 属性表示 power 数组中配置的多个权限值的验证关系，如果是 and 表示需要用户必须同时拥有 power 数组中配置的所有权限值才可以访问资源，如果是 or 表示只要用户只需要拥有 power 数组中任意一个权限值就可以访问资源。

下面列出拦截器的内容，其功能就是解析 controller 以及其内部的方法上的 CheckPower 注解，通过比对用户本身的权限，判断用户是否满足资源所配置的权限，如果不满足则直接将没有访问权限的提示信息返回给前端。

 package com.jobs.interceptor;
 
import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.jobs.annotation.CheckPower;
import com.jobs.common.Result;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Arrays;
 
//执行顺序：过滤器 > 拦截器 > AOP
//本 Demo 只使用了拦截器，进行 controloler 和 method 上的 @CheckPower 注解解析和权限判断
//本 Demo 没有使用到【过滤器】和【AOP】
@Component
public class CheckPowerInterceptor implements HandlerInterceptor {
 
    //拦截请求，在请求执行前，执行该方法，
    //这里判断 ontrololer 和 method 上是否有 @CheckPower 注解，
    //如果有的话，则判断用户的权限，是否满足所设置的执行权限
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
 
        //如果 session 存在，则表明已经登录过了
        Object user = request.getSession().getAttribute("user");
        if (user == null) {
            //用户需要登录
            ResposeResult(response, Result.fail(-99, "请登录后再访问"));
            return false;
        }
 
        if (handler instanceof HandlerMethod) {
            HandlerMethod hm = (HandlerMethod) handler;
 
            //获取用户具有的权限
            JSONObject userMap = JSON.parseObject(user.toString());
            JSONArray jsonArray = userMap.getJSONArray("powerlist");
            String[] powerlist = jsonArray.toArray(new String[jsonArray.size()]);
 
            // controller 上配置的权限是否满足，默认为 true 表示满足
            boolean controllerCheckPowerFlag = true;
            //获取类上的注解，看是否存在 CheckPower 注解
            CheckPower cpClass = hm.getBeanType().getAnnotation(CheckPower.class);
            if (cpClass != null) {
                System.out.println("访问的 Controller 上有 @CheckPower 注解...");
                //获取配置的权限列表
                System.out.println("Controller 需要的权限为：" + Arrays.toString(cpClass.power()) +
                        "，权限逻辑关系：" + cpClass.loggic());
                System.out.println("用户具有的权限：" + Arrays.toString(powerlist));
                //如果 controller 上有 @CheckPower 注解，并且没有配置任何权限，则表示登录后可以随便访问
                if (cpClass.power().length == 1 && cpClass.power()[0].equals("")) {
                    controllerCheckPowerFlag = true;
                } else {
                    controllerCheckPowerFlag =
                            getCheckPowerResult(powerlist, cpClass.power(), cpClass.loggic());
                }
            }
 
            //先判断方法上是否有 @CheckPower 注解
            if (hm.hasMethodAnnotation(CheckPower.class)) {
                System.out.println("访问的 Method 方法上有 @CheckPower 注解...");
                CheckPower cpMethod = hm.getMethodAnnotation(CheckPower.class);
                //获取配置的权限列表
                System.out.println("Method 需要的权限为：" + Arrays.toString(cpMethod.power())
                        + "，权限逻辑关系：" + cpMethod.loggic());
                System.out.println("用户具有的权限：" + Arrays.toString(powerlist));
                //如果方法上有 @CheckPower 注解，并且没有配置任何权限，则表示登录后可以随便访问
                //之所以这样做，是为了能够在 Controller 上设置了权限后，对其下面的个别方法可以放开权限。
                if (cpMethod.power().length == 1 && cpMethod.power()[0].equals("")) {
                    System.out.println("方法上 @CheckPower 没有配置任何权限，" +
                            "表示不考虑 controller 上是否配置了权限，只要登录就可以任意访问");
                    return true;
                }
 
                //方法上需要验证权限，此时先看 controler 上的权限验证是否通过，通过后再考虑验证方法上的权限
                if (controllerCheckPowerFlag) {
                    boolean methodCheckPowerFlag =
                            getCheckPowerResult(powerlist, cpMethod.power(), cpMethod.loggic());
                    if (methodCheckPowerFlag == false) {
                        ResposeResult(response, Result.fail(-1, "没有权限访问"));
                    }
 
                    return methodCheckPowerFlag;
                }
            }
 
            if (controllerCheckPowerFlag == false) {
                ResposeResult(response, Result.fail(-1, "没有权限访问"));
            }
 
            return controllerCheckPowerFlag;
        }
 
        return true;
    }
 
    //判断用户的权限，是否满足所需要的访问权限
    private Boolean getCheckPowerResult(String[] userPowerList, String[] checkPowerList, String loggic) {
        if (loggic.equalsIgnoreCase("or")) {
            // or 关系，只要用户具有的任意一个权限，在配置的权限列表中，就可以访问
            return CollectionUtil.containsAny(Arrays.asList(userPowerList), Arrays.asList(checkPowerList));
        } else if (loggic.equalsIgnoreCase("and")) {
            // and 关系，要求用户的权限，必须包含所配置的权限列表
            return CollectionUtil.containsAll(Arrays.asList(userPowerList), Arrays.asList(checkPowerList));
        } else {
            return false;
        }
    }
 
    //返回给前端 json 结果
    private void ResposeResult(HttpServletResponse response, Result result) throws IOException {
        response.setContentType("application/json;charset=utf-8");
        String json = JSON.toJSONString(result);
        response.getWriter().write(json);
    }
}

这里也实现了一个逻辑：如果 controller 和其内部的一个方法资源（假设方法名称为 aaa）上，同时配置了 CheckPower 注解权限，此时如果方法（aaa）上配置的 CheckPower 权限列表为空，则不再考虑 controller 上配置的权限，用户只要登录了，就可以访问方法（aaa）。之所以实现这样的权限控制逻辑，主要是为了满足这样的场景：controller 中的绝大多数方法需要控制权限，只需要在 controller 类上加上注解即可，但是个别方法不需要控制权限，只需要为这些方法增加 @CheckPower 注解，但不进行 power 属性的配置即可。

最后我们需要对拦截器进行相关配置，以便其能够在 SpringBoot 中生效，拦截所有的请求，但是要放行一些资源，比如用户登录接口等等，具体要放行的资源，大家可以抽取出来，配置到 yml 文件中，这里为了方便就直接在代码中写死了。

package com.jobs.config;
 
import com.jobs.interceptor.CheckPowerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.oas.annotations.EnableOpenApi;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
 
@EnableOpenApi
@Configuration
public class WebMvcConfig extends WebMvcConfigurationSupport {
 
    //设置静态资源目录，以及访问地址映射，这里放行 knife4j 文档的访问地址
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/doc.html")
                .addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**")
                .addResourceLocations("classpath:/META-INF/resources/webjars/");
    }
 
    //拦截器，拦截所有请求，一方面判断用户是否登录，
    //另一方面判断类上是否有 @CheckPower 注解，如果有则判断当前登录的用户是否有权限
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        //添加拦截器（可以添加多个拦截器，拦截器的执行顺序，就是添加顺序）
        CheckPowerInterceptor myInterceptor = new CheckPowerInterceptor();
        //设置拦截器拦截的请求路径，以及不拦截的请求路径
        registry.addInterceptor(myInterceptor).addPathPatterns("/**")
                .excludePathPatterns(getExcludePathPatterns());
    }
 
    //在这里设置拦截器不需要进行拦截的路径
    private String[] getExcludePathPatterns() {
        String[] uris = new String[]{
                //放行用户登录接口
                "/user/login",
                //放行用户退出接口
                "/user/logout",
                //放行下面的 knifefj 的静态资源文件路径
                "/doc.html",
                "/webjars/**",
                "/swagger-resources",
                "/v2/api-docs"
        };
        return uris;
    }
 
    @Bean
    public Docket createRestApi() {
        // 文档类型
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.jobs.controller"))
                .paths(PathSelectors.any())
                .build();
    }
 
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("我的测试")
                .version("1.0")
                .description("注解加拦截器的权限控制测试")
                .build();
    }
}

三、用于测试的接口

UserController 主要实现用户的登录和退出，在拦截器中已经放行，可以随便访问：

package com.jobs.controller;
 
import com.alibaba.fastjson.JSON;
import com.jobs.common.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
import javax.servlet.http.HttpServletRequest;
import java.util.*;
 
@Api(tags = "用户操作相关接口")
@RequestMapping("/user")
@RestController
public class UserController {
 
    @Value("${user.username}")
    private String username;
 
    @Value("${user.password}")
    private String passoword;
 
    //对于以英文逗号分隔的字符串配置，可以自动转换为数组
    @Value("${user.powerlist}")
    private String[] powerlist;
 
 
    @ApiOperation("用户登录")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "name", value = "用户名", required = true),
            @ApiImplicitParam(name = "pwd", value = "密码", required = true)
    })
    @PostMapping("/login")
    public Result<String> login(String name, String pwd, HttpServletRequest request) {
        if (username.equals(name) && passoword.equals(pwd)) {
            Map<String, Object> userMap = new HashMap<>();
            userMap.put("username", username);
            userMap.put("powerlist", powerlist);
            String json = JSON.toJSONString(userMap);
            request.getSession().setAttribute("user", json);
            return Result.success("登录成功");
        } else {
            return Result.fail(-1, "用户名或密码不正确");
        }
    }
 
    @ApiOperation("用户退出")
    @PostMapping("/logout")
    public Result<String> logout(HttpServletRequest request) {
        request.getSession().removeAttribute("user");
        return Result.success("退出成功");
    }
}

Test1Controller 用于测试在方法上使用注解配置权限的场景：

package com.jobs.controller;
 
import com.jobs.annotation.CheckPower;
import com.jobs.common.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@Api(tags = "test1方法权限测试")
@RequestMapping("/test1")
@RestController
public class Test1Controller {
 
    @ApiOperation("添加订单测试")
    @GetMapping("/addorder")
    //只要用户具有 addorder 权限，就可以访问
    @CheckPower(power = "addorder")
    public Result addorder() {
        return Result.success("hello addorder 访问成功");
    }
 
    @ApiOperation("删除订单测试")
    @GetMapping("/delorder")
    //用户具有 root 或 delorder 任意一个权限，就可以访问
    //由于 loggic 的默认值就是 or ，所以可以省略不写
    @CheckPower(power = {"root", "delorder"}, loggic = "or")
    public Result delorder() {
        return Result.success("hello delorder 访问成功");
    }
 
    @ApiOperation("添加用户测试")
    @GetMapping("/adduser")
    //只要用户具有 adduser 权限，就可以访问
    @CheckPower(power = "adduser")
    public Result adduser() {
        return Result.success("hello adduser 访问成功");
    }
 
    @ApiOperation("删除用户测试")
    @GetMapping("/deluser")
    //用户具有 admin 或者 deluser 的任意权限，就可以访问
    @CheckPower(power = {"admin", "deluser"}, loggic = "and")
    public Result deluser() {
        return Result.success("hello deluser 访问成功");
    }
}

Test2Controller 用于同时测试在类和方法上使用注解配置权限的场景：

package com.jobs.controller;
 
import com.jobs.annotation.CheckPower;
import com.jobs.common.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
//在 controller 类上面添加了权限验证的注解
@CheckPower(power = "root")
@Api(tags = "test2类权限测试")
@RequestMapping("/test2")
@RestController
public class Test2Controller {
 
    //在该方法上添加了 @CheckPower 注解，但是没有配置任何权限
    //此时即使 controller 上配置了权限，并且验证不通过，该方法也可以不验证权限进行访问
    @CheckPower
    @ApiOperation("查看订单列表")
    @GetMapping("/vieworder")
    public Result vieworder() {
        return Result.success("hello vieworder 访问成功");
    }
 
 
    //在方法上没有添加权限验证的注解
    @ApiOperation("查看订单详情")
    @GetMapping("/viewdetail")
    public Result getdetail() {
        return Result.success("hello viewdetail 访问成功");
    }
}

Test3Controller 用于测试在类上使用注解配置访问权限的场景：

package com.jobs.controller;
 
import com.jobs.annotation.CheckPower;
import com.jobs.common.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
//在 controller 类上面添加了权限验证的注解
@CheckPower(power = "admin")
@Api(tags = "test3类上的权限测试")
@RequestMapping("/test3")
@RestController
public class Test3Controller {
 
    //在方法上没有添加权限验证的注解
    @ApiOperation("查看用户测试")
    @GetMapping("/viewuser")
    public Result viewuser() {
        return Result.success("hello viewuser 访问成功");
    }
}

最后运行 SpringBoot 工程，访问 http://localhost:8888/doc.html 即可查看接口文档，通过其调试功能即可验证：

运行效果为：在没有运行成功登录接口之前，访问每个接口都会提示需要登录，登录之后访问相关接口，就能够验证权限。

本篇博客的源代码下载地址：https://files.cnblogs.com/files/blogs/699532/springboot_annotion1.zip