木道寻08

这个屌丝很懒，什么也没留下！

热门标签

SpringBoot集成权限认证框架(Sa-Token)_springboot sa-token

作者：木道寻08 | 2024-08-20 09:17:34

踩

springboot sa-token

SpringBoot集成权限认证框架(Sa-Token)

介绍

身份验证又称“验证”、“鉴权”，是指通过一定的手段，完成对用户身份的确认。

身份验证的目的是确认当前所声称为某种身份的用户，确实是所声称的用户。在日常生活中，身份验证并不罕见；比如，通过检查对方的证件，我们一般可以确信对方的身份。

在互联网中身份验证极为重要，不论是web端还是移动端、小程序等，在与后台交互的过程中都是需要携带身份信息的，只有通过身份认证后，后台才会执行相关请求。

常见的认证模式

Cookie模式

所谓 Cookie ，本质上是一个特殊的header参数。

Cookie是一种客户端会话技术，将数据保存在客户端。一小段文本信息随着请求和响应，在客户端和服务器端之间来回传递。根据设定的时间来决定该段文本在客户端保存时长的这种工作模式。如果服务器创建cookie后，会以key=value的形式传递到客户端，并保存在客户端。一旦客户端有服务器发回的文本信息，那么当浏览器再次向服务器发起请求时，也会以key=value这样的形式将文本信息发送到服务器端。

Cookie是一段不超过4KB的小型文本数据，由一个名称（Name）、一个值（Value）和其它几个用于控制Cookie有效期、安全性、使用范围的可选属性组成。如下图所示：

Cookie作用

保持客户端和服务器之间的状态
客户端存储用户的认证信息
客户端存储简单数据

Cookie特点

常规PC端鉴权方法，一般由Cookie模式完成，而 Cookie 有两个特性:

可由后端控制写入
每次请求自动提交

这就使得我们在前端代码中，无需任何特殊操作，就能完成鉴权的全部流程（因为整个流程都是后端控制完成的）。

Cookie安全

cookie是可以被客户端修改的，所有它是有安全问题的，重要的隐私信息不能存储在cookie中，我们要慎用cookie。

注意事项：

cookie不能存储用户账号密码
cookie需要设置超时时间
cookie在账号退出时需要最好主动删除

前后台分离（无Cookie模式）

而在app、小程序等前后台分离场景中，一般是没有 Cookie 这一功能的。

这里我们就需要使用token来进行认证。

前端进行用户登录后，后台会返回一个token到前端
前端在进行接口请求时，将token存放到header中，格式为：{tokenName: tokenValue}
后台接收到token就会开始鉴权判断是否有权力进行该接口请求，无token的请求会被直接拒绝提示未登录

使用token模式进行交互，很容易实现SSO单点登录。

使用sa-token

这里我们使用sa-token框架完成单体SpringBoot项目的权限认证功能，选择前后台分离模式，即使用token进行权限认证。前端可以是VUE、APP和小程序等客户端。

sa-token是一个轻量级 Java 权限认证框架，主要解决：登录认证、权限认证、Session会话、单点登录、OAuth2.0、微服务网关鉴权 等一系列权限相关问题。简化了我们开发权限管理的业务逻辑。

sa-token

集成步骤

用户管理表

这里我们使用RBAC模型，RBAC 是基于角色的访问控制（Role-Based Access Control ）在RBAC中，权限与角色相关联，用户通过成为适当角色的成员而得到这些角色的权限。这就极大地简化了权限的管理。这样管理都是层级相互依赖的，权限赋予给角色，而把角色又赋予用户，这样的权限设计很清楚，管理起来很方便。

这里我除了用户、角色、权限还多增加了一个部门

用户表

DROP TABLE IF EXISTS auth_user;
CREATE TABLE auth_user(
    id INT NOT NULL   COMMENT '唯一标识' ,
    created_time timestamp   DEFAULT now() COMMENT '创建时间' ,
    updated_time timestamp    COMMENT '修改时间' ,
    username VARCHAR(255)    COMMENT '用户名' ,
    password VARCHAR(255)    COMMENT '密码' ,
    email VARCHAR(255)    COMMENT '邮箱' ,
    phone INTEGER    COMMENT '手机号' ,
    is_deleted VARCHAR(1)   DEFAULT 0 COMMENT '是否删除;0：未删除，1：已删除' ,
    is_enable VARCHAR(1)   DEFAULT 0 COMMENT '是否启用;0：未启用，1：启用' ,
    PRIMARY KEY (id)
)  COMMENT = '用户信息';
1
2
3
4
5
6
7
8
9
10
11
12
13

角色表

DROP TABLE IF EXISTS auth_role;
CREATE TABLE auth_role(
    id INT NOT NULL   COMMENT '唯一标识' ,
    created_time DATETIME   DEFAULT now() COMMENT '创建时间' ,
    name VARCHAR(255)    COMMENT '角色名称' ,
    remark VARCHAR(255)    COMMENT '备注' ,
    PRIMARY KEY (id)
)  COMMENT = '角色';
1
2
3
4
5
6
7
8

权限表

DROP TABLE IF EXISTS auth_permit;
CREATE TABLE auth_permit(
    id INT NOT NULL   COMMENT '唯一标识' ,
    created_time timestamp   DEFAULT now() COMMENT '创建时间' ,
    name VARCHAR(255)    COMMENT '权限名称' ,
    url VARCHAR(255)    COMMENT '授权路径' ,
    remark VARCHAR(255)    COMMENT '备注' ,
    PRIMARY KEY (id)
)  COMMENT = '权限';
1
2
3
4
5
6
7
8
9

部门表

DROP TABLE IF EXISTS auth_org;
CREATE TABLE auth_org(
    id INT NOT NULL   COMMENT '唯一标识' ,
    created_time timestamp   DEFAULT now() COMMENT '创建时间' ,
    name VARCHAR(255)    COMMENT '部门名称' ,
    remark VARCHAR(255)    COMMENT '备注' ,
    PRIMARY KEY (id)
)  COMMENT = '部门机构';
1
2
3
4
5
6
7
8

用户角色表

DROP TABLE IF EXISTS auth_user_role;
CREATE TABLE auth_user_role(
    id INT NOT NULL   COMMENT '唯一标识' ,
    created_time timestamp   DEFAULT now() COMMENT '创建时间' ,
    user_id INT    COMMENT '用户id' ,
    role_id INT    COMMENT '角色id' ,
    PRIMARY KEY (id)
)  COMMENT = '用户角色表';
1
2
3
4
5
6
7
8

角色权限表

DROP TABLE IF EXISTS auth_role_permit;
CREATE TABLE auth_role_permit(
    id INT NOT NULL   COMMENT '唯一标识' ,
    created_time timestamp   DEFAULT now() COMMENT '创建时间' ,
    role_id INT    COMMENT '角色ID' ,
    permit_id INT    COMMENT '权限ID' ,
    PRIMARY KEY (id)
)  COMMENT = '角色权限表';
1
2
3
4
5
6
7
8

部门用户表

DROP TABLE IF EXISTS auth_org_user;
CREATE TABLE auth_org_user(
    id INT NOT NULL   COMMENT '唯一标识' ,
    created_time timestamp   DEFAULT now() COMMENT '创建时间' ,
    org_id INT    COMMENT '部门id' ,
    user_id INT    COMMENT '用户id' ,
    PRIMARY KEY (id)
)  COMMENT = '部门用户表';
1
2
3
4
5
6
7
8

以上7张表基本涵盖了常用的RBAC模式，如果需要可以根据具体的业务进行扩展

项目配置

我这里使用的是SpringBoot项目，数据库是PostgreSQL（MySQL也可以），使用mybatis plus框架，数据库连接池为Druid。

默认各位已经熟悉SpringBoot项目的使用，这里只列出了关键配置，像实体类、controller层等都需自己去新建。

项目结构如图：

添加maven依赖

sa-token依赖

        <!-- Sa-Token 权限认证, 在线文档：http://sa-token.dev33.cn/ -->
        <dependency>
            <groupId>cn.dev33</groupId>
            <artifactId>sa-token-spring-boot-starter</artifactId>
            <version>1.29.0</version>
        </dependency>
1
2
3
4
5
6

完整maven依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--springboot内置Jetty , Tomcat , Undertow , 默认是Tomcat，需要排除Tomcat-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.76</version>
            <exclusions>
                <exclusion>
                    <artifactId>commons-logging</artifactId>
                    <groupId>commons-logging</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- 阿里巴巴的druid数据源 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.23</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.0</version>
            <exclusions>
                <!-- 排除默认的 HikariCP 数据源 -->
                <exclusion>
                    <groupId>com.zaxxer</groupId>
                    <artifactId>HikariCP</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.3.0</version>
        </dependency>

        <!-- Sa-Token 权限认证, 在线文档：http://sa-token.dev33.cn/ -->
        <dependency>
            <groupId>cn.dev33</groupId>
            <artifactId>sa-token-spring-boot-starter</artifactId>
            <version>1.29.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-crypto</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

application.yml配置

sa-token配置

# Sa-Token配置
sa-token:
  # token名称 (同时也是cookie名称)
  token-name: token
  # token有效期，单位s 默认30天, -1代表永不过期
  timeout: 86400
  # token临时有效期 (指定时间内无操作就视为token过期) 单位: 秒
  activity-timeout: -1
  # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
  is-concurrent: true
  # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token)
  is-share: true
  # token风格
  token-style: uuid
  # 是否输出操作日志
  is-log: false
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

完整配置

server:
  port: 8081
spring:
  datasource:
    url: jdbc:postgresql://${base.config.db.hostname}:${base.config.db.port}/${base.config.db.db}?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
    username: ${base.config.db.username}
    password: ${base.config.db.password}
    driver-class-name: org.postgresql.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      # 配置初始化大小、最小、最大
      initial-size: 5
      minIdle: 10
      max-active: 20
      # 配置获取连接等待超时的时间(单位：毫秒)
      max-wait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      time-between-eviction-runs-millis: 2000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      min-evictable-idle-time-millis: 600000
      max-evictable-idle-time-millis: 900000
      # 用来测试连接是否可用的SQL语句,默认值每种数据库都不相同,这是mysql
      validationQuery: select 1
      # 应用向连接池申请连接，并且testOnBorrow为false时，连接池将会判断连接是否处于空闲状态，如果是，则验证这条连接是否可用
      testWhileIdle: true
      # 如果为true，默认是false，应用向连接池申请连接时，连接池会判断这条连接是否是可用的
      testOnBorrow: false
      # 如果为true（默认false），当应用使用完连接，连接池回收连接的时候会判断该连接是否还可用
      testOnReturn: false
      # 是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle
      poolPreparedStatements: true
      # 要启用PSCache，必须配置大于0，当大于0时， poolPreparedStatements自动触发修改为true，
      # 在Druid中，不会存在Oracle下PSCache占用内存过多的问题，
      # 可以把这个数值配置大一些，比如说100
      maxOpenPreparedStatements: 20
      # 连接池中的minIdle数量以内的连接，空闲时间超过minEvictableIdleTimeMillis，则会执行keepAlive操作
      keepAlive: true
      # Spring 监控，利用aop 对指定接口的执行时间，jdbc数进行记录
      aop-patterns: "com.dzzh.big_screen.mapper.*"
      ########### 启用内置过滤器（第一个 stat必须，否则监控不到SQL）##########
      filters: stat,wall,log4j2
      # 自己配置监控统计拦截的filter
      filter:
        # 开启druidDatasource的状态监控
        stat:
          enabled: true
          db-type: postgresql
          # 开启慢sql监控，超过2s 就认为是慢sql，记录到日志中
          log-slow-sql: true
          slow-sql-millis: 2000
        # 日志监控，使用slf4j 进行日志输出
        slf4j:
          enabled: true
          statement-log-error-enabled: true
          statement-create-after-log-enabled: false
          statement-close-after-log-enabled: false
          result-set-open-after-log-enabled: false
          result-set-close-after-log-enabled: false
      ########## 配置WebStatFilter，用于采集web关联监控的数据 ##########
      web-stat-filter:
        enabled: true                   # 启动 StatFilter
        url-pattern: /*                 # 过滤所有url
        exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*" # 排除一些不必要的url
        session-stat-enable: true       # 开启session统计功能
        session-stat-max-count: 1000    # session的最大个数,默认100
      ########## 配置StatViewServlet（监控页面），用于展示Druid的统计信息 ##########
      stat-view-servlet:
        enabled: true                   # 启用StatViewServlet
        url-pattern: /druid/*           # 访问内置监控页面的路径，内置监控页面的首页是/druid/index.html
        reset-enable: false              # 不允许清空统计数据,重新计算
        login-username: root            # 配置监控页面访问密码
        login-password: 123456
        allow: 127.0.0.1           # 允许访问的地址，如果allow没有配置或者为空，则允许所有访问
        deny:                                        # 拒绝访问的地址，deny优先于allow，如果在deny列表中，就算在allow列表中，也会被拒绝


# Sa-Token配置
sa-token:
  # token名称 (同时也是cookie名称)
  token-name: token
  # token有效期，单位s 默认30天, -1代表永不过期
  timeout: 86400
  # token临时有效期 (指定时间内无操作就视为token过期) 单位: 秒
  activity-timeout: -1
  # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
  is-concurrent: true
  # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token)
  is-share: true
  # token风格
  token-style: uuid
  # 是否输出操作日志
  is-log: false


base:
  config:
    db:
      hostname: 192.168.1.250
      port: 5432
      db: user
      username: postgres
      password: postgres
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

简单使用sa-token

    @Resource
    LoginService loginService;

	@ApiOperation(value = "登录接口", notes = "使用账号密码登录用户")
    @GetMapping("doLogin")
    public ResponseResult doLogin(@RequestParam("username") String username, @RequestParam("password") String password) {
        return loginService.doLogin(username, password);
    }
1
2
3
4
5
6
7
8

service层

    /**
     * 使用账号密码登录用户
     *
     * @param username 账户
     * @param password 密码
     * @return ResponseResult
     */
    ResponseResult doLogin(String username, String password);
1
2
3
4
5
6
7
8

serviceImpl层

@Service
public class LoginServiceImpl implements LoginService {

    @Resource
    AuthUserMapper authUserMapper;

    @Resource
    BCryptPasswordEncoder bCryptPasswordEncoder;

    @Override
    public ResponseResult doLogin(String username, String password) {
        QueryWrapper<AuthUser> queryUser = new QueryWrapper<>();
        queryUser.eq("username", username);
        AuthUser authUser = authUserMapper.selectOne(queryUser);
        if (authUser == null) {
            return new ResponseResult(ResponseCode.FAILURE,"用户不存在！");
        }
        Integer id = authUser.getId();
        String userPassword = authUser.getPassword();
        if (!"1".equals(authUser.getIsEnable())) {
            return new ResponseResult(ResponseCode.FAILURE, "用户未激活，请联系管理员！");
        }
        if (!bCryptPasswordEncoder.matches(password, userPassword)) {
            return new ResponseResult(ResponseCode.FAILURE, "用户名密码不正确！");
        }
        // sa-token登录
        StpUtil.login(id);
        SaTokenInfo saTokenInfo = StpUtil.getTokenInfo();
        String token = saTokenInfo.getTokenValue();
        long tokenTimeout = saTokenInfo.getTokenTimeout();
        authUser.setPassword("");
        HashMap<Object, Object> res = new HashMap<>();
        res.put("token", token);
        res.put("tokenTimeout", tokenTimeout);
        res.put("info", authUser);
        return new ResponseResult(ResponseCode.SUCCESS, res);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

返回的结构如图所示：

前台拿到token，就可以存起来了。

到这集成sa-token已经完成50%了，这里实现了认证，后面需要实现授权。

配置sa-token授权

在RBAC模型中不同的用户拥有不同的角色，不同的角色拥有的权限是不一样的。接口拦截需要和权限进行绑定，拥有权限的用户可以访问对应的接口。为了实现这个效果，我们需要自定义实现拦截器。

配置拦截器

继承WebMvcConfigurer实现自定义的拦截方法，设置指定的接口需要指定的权限，

SaTokenConfigure.java

import cn.dev33.satoken.interceptor.SaRouteInterceptor;
import cn.dev33.satoken.router.SaRouter;
import cn.dev33.satoken.stp.StpUtil;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class SaTokenConfigure implements WebMvcConfigurer {
    // 注册Sa-Token的注解拦截器，打开注解式鉴权功能
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 注册注解拦截器，并排除不需要注解鉴权的接口地址 (与登录拦截器无关)
        registry.addInterceptor(new SaRouteInterceptor((req, res, handler) -> {

            // 登录认证 -- 拦截所有路由，并排除/user/doLogin 用于开放登录
            SaRouter.match("/**", "/acc/doLogin", r -> StpUtil.checkLogin());
            // 拥有/user/atCheck权限的用户才能访问该接口
            SaRouter.match("/acc/atCheck", r -> StpUtil.checkPermission("/user/atCheck"));

        })).addPathPatterns("/**");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

配置sa-token自定义权限验证接口扩展

sa-token已经为我们实现了整个认证授权逻辑了，我只需要根据项目的业务需求来实现sa-token自定义权限验证接口扩展就行。新建一个实现类

StpInterfaceImpl.java

import cn.dev33.satoken.stp.StpInterface;

import com.sun.natural_resources.entity.AuthPermit;
import com.sun.natural_resources.entity.AuthRole;
import com.sun.natural_resources.mapper.AuthUserMapper;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 自定义权限验证接口扩展
 *
 * @author Ct
 */
@Component
public class StpInterfaceImpl implements StpInterface {

    @Resource
    AuthUserMapper userMapper;

    /**
     * 返回一个账号所拥有的权限码集合
     */
    @Override
    public List<String> getPermissionList(Object loginId, String loginType) {
        System.out.println();
        List<AuthPermit> permission = userMapper.getPermitByUserId(Integer.valueOf(loginId.toString()));
        System.out.println(permission);
        return permission.stream().map(AuthPermit::getName).collect(Collectors.toList());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

AuthUserMapper.java

    /**
     * 通过用户id获取用户权限
     *
     * @param id 用户id
     * @return 权限集合
     */
    List<AuthPermit> getPermitByUserId(Integer id);
1
2
3
4
5
6
7

AuthUserMapper.xml

    <select id="getPermitByUserId" resultType="com.sun.natural_resources.entity.AuthPermit">
        select ap.*
        from auth_user_role aur
                 right join auth_role_permit arp on aur.role_id = arp.role_id
                 right join auth_permit ap on arp.permit_id = ap.id
        where aur.user_id = #{id}
    </select>
1
2
3
4
5
6
7

配置全局异常

sa-token很贴心的为我们提供了全局异常处理示例

封装返回值

AjaxJson.java

import java.io.Serializable;
import java.util.List;


/**
 * ajax请求返回Json格式数据的封装
 */
public class AjaxJson implements Serializable{
    // 序列化版本号
    private static final long serialVersionUID = 1L;
    // 成功状态码
    public static final int CODE_SUCCESS = 200;
    // 错误状态码
    public static final int CODE_ERROR = 500;
    // 警告状态码
    public static final int CODE_WARNING = 501;
    // 无权限状态码
    public static final int CODE_NOT_JUR = 403;
    // 未登录状态码
    public static final int CODE_NOT_LOGIN = 401;
    // 无效请求状态码
    public static final int CODE_INVALID_REQUEST = 400;
    // 状态码
    public int code;
    // 描述信息
    public String msg;
    // 携带对象
    public Object data;
    // 数据总数，用于分页
    public Long dataCount;

    /**
     * 返回code
     * @return
     */
    public int getCode() {
        return this.code;
    }

    /**
     * 给msg赋值，连缀风格
     */
    public AjaxJson setMsg(String msg) {
        this.msg = msg;
        return this;
    }
    public String getMsg() {
        return this.msg;
    }

    /**
     * 给data赋值，连缀风格
     */
    public AjaxJson setData(Object data) {
        this.data = data;
        return this;
    }

    /**
     * 将data还原为指定类型并返回
     */
    @SuppressWarnings("unchecked")
    public <T> T getData(Class<T> cs) {
        return (T) data;
    }

    // ============================  构建  ==================================

    public AjaxJson(int code, String msg, Object data, Long dataCount) {
        this.code = code;
        this.msg = msg;
        this.data = data;
        this.dataCount = dataCount;
    }

    // 返回成功
    public static AjaxJson getSuccess() {
        return new AjaxJson(CODE_SUCCESS, "ok", null, null);
    }
    public static AjaxJson getSuccess(String msg) {
        return new AjaxJson(CODE_SUCCESS, msg, null, null);
    }
    public static AjaxJson getSuccess(String msg, Object data) {
        return new AjaxJson(CODE_SUCCESS, msg, data, null);
    }
    public static AjaxJson getSuccessData(Object data) {
        return new AjaxJson(CODE_SUCCESS, "ok", data, null);
    }
    public static AjaxJson getSuccessArray(Object... data) {
        return new AjaxJson(CODE_SUCCESS, "ok", data, null);
    }

    // 返回失败
    public static AjaxJson getError() {
        return new AjaxJson(CODE_ERROR, "error", null, null);
    }
    public static AjaxJson getError(String msg) {
        return new AjaxJson(CODE_ERROR, msg, null, null);
    }

    // 返回警告
    public static AjaxJson getWarning() {
        return new AjaxJson(CODE_ERROR, "warning", null, null);
    }
    public static AjaxJson getWarning(String msg) {
        return new AjaxJson(CODE_WARNING, msg, null, null);
    }

    // 返回未登录
    public static AjaxJson getNotLogin() {
        return new AjaxJson(CODE_NOT_LOGIN, "未登录，请登录后再次访问", null, null);
    }

    // 返回没有权限的
    public static AjaxJson getNotJur(String msg) {
        return new AjaxJson(CODE_NOT_JUR, msg, null, null);
    }

    // 返回一个自定义状态码的
    public static AjaxJson get(int code, String msg){
        return new AjaxJson(code, msg, null, null);
    }

    // 返回分页和数据的
    public static AjaxJson getPageData(Long dataCount, Object data){
        return new AjaxJson(CODE_SUCCESS, "ok", data, dataCount);
    }

    // 返回，根据受影响行数的(大于0=ok，小于0=error)
    public static AjaxJson getByLine(int line){
        if(line > 0){
            return getSuccess("ok", line);
        }
        return getError("error").setData(line);
    }

    // 返回，根据布尔值来确定最终结果的  (true=ok，false=error)
    public static AjaxJson getByBoolean(boolean b){
        return b ? getSuccess("ok") : getError("error");
    }

    /* (non-Javadoc)
     * @see java.lang.Object#toString()
     */
    @SuppressWarnings("rawtypes")
    @Override
    public String toString() {
        String data_string = null;
        if(data == null){

        } else if(data instanceof List){
            data_string = "List(length=" + ((List)data).size() + ")";
        } else {
            data_string = data.toString();
        }
        return "{"
                + "\"code\": " + this.getCode()
                + ", \"msg\": \"" + this.getMsg() + "\""
                + ", \"data\": " + data_string
                + ", \"dataCount\": " + dataCount
                + "}";
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

全局异常

GlobalException.java

import cn.dev33.satoken.exception.DisableLoginException;
import cn.dev33.satoken.exception.NotLoginException;
import cn.dev33.satoken.exception.NotPermissionException;
import cn.dev33.satoken.exception.NotRoleException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 全局异常处理
 */
@ControllerAdvice
public class GlobalException {

    // 全局异常拦截（拦截项目中的所有异常）
    @ResponseBody
    @ExceptionHandler
    public AjaxJson handlerException(Exception e, HttpServletRequest request, HttpServletResponse response) {

        // 打印堆栈，以供调试
        System.out.println("全局异常---------------");
//        System.out.println(e.getMessage());

        // 不同异常返回不同状态码
        AjaxJson aj = null;
        // 如果是未登录异常
        if (e instanceof NotLoginException) {
            NotLoginException ee = (NotLoginException) e;
            aj = AjaxJson.getNotLogin().setMsg(ee.getMessage());
        }
        // 如果是角色异常
        else if (e instanceof NotRoleException) {
            NotRoleException ee = (NotRoleException) e;
            aj = AjaxJson.getNotJur("无此角色：" + ee.getRole());
        }
        // 如果是权限异常
        else if (e instanceof NotPermissionException) {
            NotPermissionException ee = (NotPermissionException) e;
            aj = AjaxJson.getNotJur("无此权限：" + ee.getCode());
        }
        // 如果是被封禁异常
        else if (e instanceof DisableLoginException) {
            DisableLoginException ee = (DisableLoginException) e;
            aj = AjaxJson.getNotJur("账号被封禁：" + ee.getDisableTime() + "秒后解封");
        } else {    // 普通异常, 输出：500 + 异常信息
            aj = AjaxJson.getError(e.getMessage());
        }

        // 返回给前端
        return aj;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

权限认证测试

无token测试

这里模拟head没有token的情况（用户未登录），如图所示会提醒401

登录成功后无权限测试

这里使用测试账号，角色为测试角色未分配select-user权限

这里提醒为无权限

登录后有权限测试

这里使用管理员账号，角色为管理员，分配了select-user权限

可以看到有返回值了

结语

sa-token真是利器，使用它可以为我们减少不少的开发过程，而且这个是国产开源项目，stars也不少，文档对国人很友好，支持国产开源！

这里我要说一下，部分内容参考我朋友的教程springboot集成 Sa-Token、mybatisplus实现RPAC_ct1104的博客-CSDN博客

后面有时间再说说sa-token在微服务中的使用！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/1006336