Spring Security 使用总结

作者: wean_a23e | 来源:发表于2017-10-05 13:05 被阅读4642次

暑假的时候在学习了 Spring Security 并成功运用到了项目中。在实践中摸索出了一套结合 json + jwt(json web token) + Spring Boot + Spring Security 技术的权限方案趁着国庆假期记录一下。

以下所有步骤的源码可以从我的 github 上取得。如果要了解，请阅读 readme.md。

各个技术的简要介绍

json : 与前端交互的数据交换格式

个人理解上，它的特点是可以促进 web 前后端解耦，提升团队的工作效率。同时也是跟安卓端和 iOS 端交互的工具，目前是没想出除了 json 和 XML 之外的交流形式诶（或许等以后有空闲时间会看看）。

它的另一个特点是轻量级，简洁和清晰的层次可以方便我们阅读和编写，并且减少服务器带宽占用。

jwt (json web token)

用人话讲就是将用户的身份信息（账号名字）、其他信息（不固定，根据需要增加）在用户登陆时提取出来，并且通过加密手段加工成一串密文，在用户登陆成功时带在返回结果发送给用户。以后用户每次请求时均带上这串密文，服务器根据解析这段密文判断用户是否有权限访问相关资源，并返回相应结果。

从网上摘录了一些优点，关于 jwt 的更多资料感兴趣的读者可以自行谷歌：

相比于session，它无需保存在服务器，不占用服务器内存开销。
无状态、可拓展性强：比如有3台机器（A、B、C）组成服务器集群，若session存在机器A上，session只能保存在其中一台服务器，此时你便不能访问机器B、C，因为B、C上没有存放该Session，而使用token就能够验证用户请求合法性，并且我再加几台机器也没事，所以可拓展性好就是这个意思。
由 2 知，这样做可就支持了跨域访问。

Spring Boot

Spring Boot 是一个用来简化 Spring 应用的搭建以及开发过程的框架。用完后会让你大呼 : "wocao! 怎么有这么方便的东西! mama 再也不用担心我不会配置 xml 配置文件了!"。

Spring Security

这是 Spring Security 提供的一个安全权限控制框架，可以根据使用者的需要定制相关的角色身份和身份所具有的权限，完成黑名单操作、拦截无权限的操作。配合 Spring Boot 可以快速开发出一套完善的权限系统。

本次技术方案中 Spring Security 执行流程

从图中可以看出本次执行流程围绕着的就是 token。

用户通过登陆操作获得我们返回的 token 并保存在本地。在以后每次请求都在请求头中带上 token ，服务器在收到客户端传来的请求时会判断是否有 token ，若有，解析 token 并写入权限到本次会话，若无直接跳过解析 token 的步骤，然后判断本次访问的接口是否需要认证，是否需要相应的权限，并根据本次会话中的认证情况做出反应。

动手实现这个安全框架

步骤一：建立项目，配置好数据源

使用 Itellij Idea 建立一个 Spring Boot 项目

需要的组件

选择 Web 、Security 、 Mybatis 和 JDBC 四个组件。

在数据库中建立所需的数据库 spring_security

建立数据库

在 spring boot 配置文件 application.properties 中配置好数据源

配置数据源

启动项目查看 Spring Boot 是否替我们配置好 Spring Security 了。

启动项目

若是正确启动了，可以看到 Spring Security 生成了一段默认密码。

我们访问 localhost:8080 会弹出一个 basic 认证框

输入用户名 user 密码 前面自动生成的密码 便可得到通过的返回消息（返回 404，因为我们还未建立任何页面）
输入错误的用户名或者密码会返回 401 ，提示未认证

如果你走到了这一步，意味着你已经配置好了所需要的环境，接下来就跟着进入下一步吧！

步骤二：生成我们的 jwt

在这一步我们将学习如何根据我们的需要生成我们定制的 token ！

关闭 Spring Boot 替我们配置好的 Spring Security。（因为默认配置好的 Spring Security 会拦截掉我们定制的登陆接口）

创建 Spring Security 配置类 WebSecurityConfig.java

@Configuration      // 声明为配置类
@EnableWebSecurity      // 启用 Spring Security web 安全的功能
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .anyRequest().permitAll()       // 允许所有请求通过
                .and()
                .csrf()
                .disable()                      // 禁用 Spring Security 自带的跨域处理
                .sessionManagement()                        // 定制我们自己的 session 策略
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS); // 调整为让 Spring Security 不创建和使用 session
    }
}

在数据库中建立相应的用户和角色。

创建用户表 user

user 表

其中各个属性和作用如下:

username : 用户名
password : 密码
role_id : 用户所属角色编号
last_password_change : 最后一次密码修改时间
enable : 是否启用该账号，可以用来做黑名单

创建角色表 role

role 表

其中各个属性作用如下:

role_id : 角色相应 id
role_name : 角色的名称
auth : 角色所拥有的权限

编写相应的登陆密码判断逻辑

因为登陆功能很容易实现，这里就不写出来占地方了哎。

编写 token 操作类（生成 token 部分）

因为网上有造好的轮子，我们可以直接拿来做些修改就可以使用了。

使用 maven 导入网上造好的 jwt 轮子

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.4</version>
</dependency>

建立我们自己的 token 操作类 TokenUtils.java

public class TokenUtils {

    private final Logger logger = Logger.getLogger(this.getClass());

    @Value("${token.secret}")
    private String secret;

    @Value("${token.expiration}")
    private Long expiration;

    /**
     * 根据 TokenDetail 生成 Token
     *
     * @param tokenDetail
     * @return
     */
    public String generateToken(TokenDetail tokenDetail) {
        Map<String, Object> claims = new HashMap<String, Object>();
        claims.put("sub", tokenDetail.getUsername());
        claims.put("created", this.generateCurrentDate());
        return this.generateToken(claims);
    }

    /**
     * 根据 claims 生成 Token
     *
     * @param claims
     * @return
     */
    private String generateToken(Map<String, Object> claims) {
        try {
            return Jwts.builder()
                    .setClaims(claims)
                    .setExpiration(this.generateExpirationDate())
                    .signWith(SignatureAlgorithm.HS512, this.secret.getBytes("UTF-8"))
                    .compact();
        } catch (UnsupportedEncodingException ex) {
            //didn't want to have this method throw the exception, would rather log it and sign the token like it was before
            logger.warn(ex.getMessage());
            return Jwts.builder()
                    .setClaims(claims)
                    .setExpiration(this.generateExpirationDate())
                    .signWith(SignatureAlgorithm.HS512, this.secret)
                    .compact();
        }
    }

    /**
     * token 过期时间
     *
     * @return
     */
    private Date generateExpirationDate() {
        return new Date(System.currentTimeMillis() + this.expiration * 1000);
    }

    /**
     * 获得当前时间
     *
     * @return
     */
    private Date generateCurrentDate() {
        return new Date(System.currentTimeMillis());
    }

}

这个工具类的目前做的事情是 :

把用户名封装进下载的轮子的 token 的主体 claims 中，并在里面封装了当前时间（方便后面判断 token 是否在修改密码之前生成的）
再计算 token 过期的时间写入到轮子的 token 中
对轮子的 token 进行撒盐加密，生成一串字符串，即我们定制的 token

生成定制 token 的方法的入参 TokenDetail 的定义如下

public interface TokenDetail {

    //TODO: 这里封装了一层，不直接使用 username 做参数的原因是可以方便未来增加其他要封装到 token 中的信息

    String getUsername();
}

public class TokenDetailImpl implements TokenDetail {

    private final String username;

    public TokenDetailImpl(String username) {
        this.username = username;
    }

    @Override
    public String getUsername() {
        return this.username;
    }
}

同时这个工具类把加密 token 撒盐的字符串和 token 的过期时间提取到了 application.properties 中

# token 加密密钥
token.secret=secret
# token 过期时间，以秒为单位，604800 是 一星期
token.expiration=604800

至此，我们生成 token 的教程已经完成，至于登陆接口，判断账号密码是否正确的操作就留给读者去实现，读者只需在登陆成功时在结果中返回生成好的 token 给用户即可。

步骤三 : 实现验证 token 是否有效，并根据 token 获得账号详细信息（权限，是否处于封号状态）的功能

分析实现的过程

在步骤二中，我们把用户的的 username 、 token 创建的时间、 token 过期的时间封装到了加密过后的 token 字符串中，就是为了服务此时我们验证用户权限的目的。

假设我们此时拿到了用户传递过来的一串 token，并且要根据这串 token 获得用户的详情可以这样做：

A. 尝试解析这串 token ，若成功解析出来，进入下一步，否则终止解析过程
B. 根据解析出来的 username 从数据库中查找用户的账号，最后一次密码修改的时间，权限，是否封号等用户详情信息，把这些信息封装到一个实体类中（userDetail类)。若查找不到该用户，终止解析进程
C. 检查 userDetail 中记录的封号状态，若是账号已被封号，返回封号结果，终止请求
D. 根据 userDtail 比较 token 是否处于有效期内，若不处于有效期内，终止解析过程，否则继续
E. 将 userDetail 中记录的用户权限写入本次请求会话中，解析完成。

可参考下图理解：

分析解析 token ，检查权限的过程

下面开始动手实现

尝试解析 token 获得 username

/**
     * 从 token 中拿到 username
     *
     * @param token
     * @return
     */
    public String getUsernameFromToken(String token) {
        String username;
        try {
            final Claims claims = this.getClaimsFromToken(token);
            username = claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }

    /**
     * 解析 token 的主体 Claims
     *
     * @param token
     * @return
     */
    private Claims getClaimsFromToken(String token) {
        Claims claims;
        try {
            claims = Jwts.parser()
                    .setSigningKey(this.secret.getBytes("UTF-8"))
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            claims = null;
        }
        return claims;
    }

在这段代码中，我们先对 token 进行解密，获得 token 中封装好的主体部分 claims (前面第二部引入的别人造好的轮子)，然后尝试获得里面封装的 username 字符串。

从数据库中获得用户详情 userDetail

这里我们将实现 Spring Security 的一个 UserDetailService 接口，这个接口只有一个方法, loadUserByUsername。流程图如下

获得 UserDetail 的流程图

代码如下:

public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;

    /**
     * 获取 userDetail
     * @param username
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        User user = this.userMapper.getUserFromDatabase(username);

        if (user == null) {
            throw new UsernameNotFoundException(String.format("No user found with username '%s'.", username));
        } else {
            return SecurityModelFactory.create(user);
        }
    }
}

public class User implements LoginDetail, TokenDetail {

    private String username;
    private String password;
    private String authorities;
    private Long lastPasswordChange;
    private char enable;

    // 省略构造器和 getter setter 方法
}

public class SecurityModelFactory {

    public static UserDetailImpl create(User user) {
        Collection<? extends GrantedAuthority> authorities;
        try {
            authorities = AuthorityUtils.commaSeparatedStringToAuthorityList(user.getAuthorities());
        } catch (Exception e) {
            authorities = null;
        }

        Date lastPasswordReset = new Date();
        lastPasswordReset.setTime(user.getLastPasswordChange());
        return new UserDetailImpl(
                user.getUsername(),
                user.getUsername(),
                user.getPassword(),
                lastPasswordReset,
                authorities,
                user.enable()
        );
    }

}

其中获得未处理过的用户详细信息 User 类的 mapper 类定义如下:

public interface UserMapper {


    User getUserFromDatabase(@Param("username") String username);

}

相应的 xml 文件为 :

<select id="getUserFromDatabase"  resultMap="getUserFromDatabaseMap">
        SELECT
        `user`.username,
        `user`.`password`,
        `user`.role_id,
        `user`.enable,
        `user`.last_password_change,
        `user`.enable,
        role.auth
        FROM
        `user` ,
        role
        WHERE
        `user`.role_id = role.role_id AND
        `user`.username = #{username}
    </select>

    <resultMap id="getUserFromDatabaseMap" type="cn.ssd.wean2016.springsecurity.model.domain.User">
        <id column="username" property="username"/>
        <result column="password" property="password"/>
        <result column="last_password_change" property="lastPasswordChange"/>
        <result column="auth" property="authorities"/>
        <result column="enable" property="enable"/>
    </resultMap>

至此，我们已经完成获取用户详细信息的的功能了。接下来只要限制接口的访问权限，并要求用户访问接口时带上 token 即可实现对权限的控制。

步骤四 : 定义解析 token 的拦截器

老规矩，上流程图:

解析 token 的拦截器的执行流程

下面定义这个拦截器

public class AuthenticationTokenFilter extends UsernamePasswordAuthenticationFilter {

    /**
     * json web token 在请求头的名字
     */
    @Value("${token.header}")
    private String tokenHeader;

    /**
     * 辅助操作 token 的工具类
     */
    @Autowired
    private TokenUtils tokenUtils;

    /**
     * Spring Security 的核心操作服务类
     * 在当前类中将使用 UserDetailsService 来获取 userDetails 对象
     */
    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 将 ServletRequest 转换为 HttpServletRequest 才能拿到请求头中的 token
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        // 尝试获取请求头的 token
        String authToken = httpRequest.getHeader(this.tokenHeader);
        // 尝试拿 token 中的 username
        // 若是没有 token 或者拿 username 时出现异常，那么 username 为 null
        String username = this.tokenUtils.getUsernameFromToken(authToken);

        // 如果上面解析 token 成功并且拿到了 username 并且本次会话的权限还未被写入
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
            // 用 UserDetailsService 从数据库中拿到用户的 UserDetails 类
            // UserDetails 类是 Spring Security 用于保存用户权限的实体类
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
            // 检查用户带来的 token 是否有效
            // 包括 token 和 userDetails 中用户名是否一样， token 是否过期， token 生成时间是否在最后一次密码修改时间之前
            // 若是检查通过
            if (this.tokenUtils.validateToken(authToken, userDetails)) {
                // 生成通过认证
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(httpRequest));
                // 将权限写入本次会话
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
            if (!userDetails.isEnabled()){
                response.setCharacterEncoding("UTF-8");
                response.setContentType("application/json;charset=UTF-8");
                response.getWriter().print("{\"code\":\"452\",\"data\":\"\",\"message\":\"账号处于黑名单\"}");
                return;
            }
        }
        chain.doFilter(request, response);
    }

}

其中检查 token 是否有效的 tokenUtils.validateToken(authToken, userDetails) 方法定义如下:

/**
     * 检查 token 是否处于有效期内
     * @param token
     * @param userDetails
     * @return
     */
    public Boolean validateToken(String token, UserDetails userDetails) {
        UserDetailImpl user = (UserDetailImpl) userDetails;
        final String username = this.getUsernameFromToken(token);
        final Date created = this.getCreatedDateFromToken(token);
        return (username.equals(user.getUsername()) && !(this.isTokenExpired(token)) && !(this.isCreatedBeforeLastPasswordReset(created, user.getLastPasswordReset())));
    }

    /**
     * 获得我们封装在 token 中的 token 创建时间
     * @param token
     * @return
     */
    public Date getCreatedDateFromToken(String token) {
        Date created;
        try {
            final Claims claims = this.getClaimsFromToken(token);
            created = new Date((Long) claims.get("created"));
        } catch (Exception e) {
            created = null;
        }
        return created;
    }

    /**
     * 获得我们封装在 token 中的 token 过期时间
     * @param token
     * @return
     */
    public Date getExpirationDateFromToken(String token) {
        Date expiration;
        try {
            final Claims claims = this.getClaimsFromToken(token);
            expiration = claims.getExpiration();
        } catch (Exception e) {
            expiration = null;
        }
        return expiration;
    }

    /**
     * 检查当前时间是否在封装在 token 中的过期时间之后，若是，则判定为 token 过期
     * @param token
     * @return
     */
    private Boolean isTokenExpired(String token) {
        final Date expiration = this.getExpirationDateFromToken(token);
        return expiration.before(this.generateCurrentDate());
    }

    /**
     * 检查 token 是否是在最后一次修改密码之前创建的（账号修改密码之后之前生成的 token 即使没过期也判断为无效）
     * @param created
     * @param lastPasswordReset
     * @return
     */
    private Boolean isCreatedBeforeLastPasswordReset(Date created, Date lastPasswordReset) {
        return (lastPasswordReset != null && created.before(lastPasswordReset));
    }

步骤五 : 注册步骤四的拦截器，使它在 Spring Security 读取本次会话权限前将用户所具有的权限写入本次会话中

在 SpringSecurity 的配置类 WebSecurityConfig.java 中添加如下配置

public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 注册 token 转换拦截器为 bean
     * 如果客户端传来了 token ，那么通过拦截器解析 token 赋予用户权限
     *
     * @return
     * @throws Exception
     */
    @Bean
    public AuthenticationTokenFilter authenticationTokenFilterBean() throws Exception {
        AuthenticationTokenFilter authenticationTokenFilter = new AuthenticationTokenFilter();
        authenticationTokenFilter.setAuthenticationManager(authenticationManagerBean());
        return authenticationTokenFilter;
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .authorizeRequests()
                .antMatchers("/auth").authenticated()       // 需携带有效 token
                .antMatchers("/admin").hasAuthority("admin")   // 需拥有 admin 这个权限
                .antMatchers("/ADMIN").hasRole("ADMIN")     // 需拥有 ADMIN 这个身份
                .anyRequest().permitAll()       // 允许所有请求通过
                .and()
                .csrf()
                .disable()                      // 禁用 Spring Security 自带的跨域处理
                .sessionManagement()                        // 定制我们自己的 session 策略
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS); // 调整为让 Spring Security 不创建和使用 session


        /**
         * 本次 json web token 权限控制的核心配置部分
         * 在 Spring Security 开始判断本次会话是否有权限时的前一瞬间
         * 通过添加过滤器将 token 解析，将用户所有的权限写入本次 Spring Security 的会话
         */
        http
                .addFilterBefore(authenticationTokenFilterBean(), UsernamePasswordAuthenticationFilter.class);
    }
}

其中我们将步骤四中定义的拦截器注册到 Spring 中成为一个 bean ，并登记在 Spring Security 开始判断本次会话是否有权限时的前一瞬间通过添加过滤器将 token 解析，将用户所有的权限写入本次会话。

其次，我们添加了三个 ant 风格的地址拦截规则 :

/auth : 要求携带有效的 token
/admin : 要求携带 token 所对应的账号具有 admin 这个权限
/ADMIN : 要求携带 token 对应的张账号具有 ROLE_ADMIN 这个身份

启动程序到 8080 端口，通过 /login 接口登陆 guest 账号，对 /auth 接口尝试访问，结果如下 :

对 auth 的访问结果

显然，因为 token 有效，所以成功通过了拦截

接下来尝试访问 /admin 接口，结果如下 :

对 admin 的访问结果

显然，因为携带的 token 不具有 admin 这个权限，所以请求被拦截拦截

至此，我们已经完成了一套权限简单的权限规则系统，在下一步中，我们将对无权限访问的返回结果进行优化，并结束这次总结。

步骤六 : 完善 401 和 403 返回结果

定义 401 处理器，实现 AuthenticationEntryPoint 接口

public class EntryPointUnauthorizedHandler implements AuthenticationEntryPoint {

  /**
   * 未登录或无权限时触发的操作
   * 返回  {"code":401,"message":"小弟弟，你没有携带 token 或者 token 无效！","data":""}
   * @param httpServletRequest
   * @param httpServletResponse
   * @param e
   * @throws IOException
   * @throws ServletException
   */
  @Override
  public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
      //返回json形式的错误信息
      httpServletResponse.setCharacterEncoding("UTF-8");
      httpServletResponse.setContentType("application/json");

      httpServletResponse.getWriter().println("{\"code\":401,\"message\":\"小弟弟，你没有携带 token 或者 token 无效！\",\"data\":\"\"}");
      httpServletResponse.getWriter().flush();
  }

}

定义 403 处理器，实现 AccessDeniedHandler 接口

@Component
public class MyAccessDeniedHandler implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
        //返回json形式的错误信息
        httpServletResponse.setCharacterEncoding("UTF-8");
        httpServletResponse.setContentType("application/json");

        httpServletResponse.getWriter().println("{\"code\":403,\"message\":\"小弟弟，你没有权限访问呀！\",\"data\":\"\"}");
        httpServletResponse.getWriter().flush();
    }
}

将这两个处理器配置到 SpringSecurity 的配置类中 :

public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 注册 401 处理器
     */
    @Autowired
    private EntryPointUnauthorizedHandler unauthorizedHandler;

    /**
     * 注册 403 处理器
     */
    @Autowired
    private MyAccessDeniedHandler accessDeniedHandler;

    ...

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                ...

                // 配置被拦截时的处理
                .exceptionHandling()
                .authenticationEntryPoint(this.unauthorizedHandler)   // 添加 token 无效或者没有携带 token 时的处理
                .accessDeniedHandler(this.accessDeniedHandler)      //添加无权限时的处理

                ...
    }
}

尝试以 guest 的身份访问 /admin 接口，结果如下:

以 guest 身份访问 admin 接口

嘻嘻，显然任务完成啦！！！（这个接口也可以用 lamda 表达式配置，这个留给大家去探索啦~~~）

溜了溜了……

网友评论

f4a11db2f45b:问下，我从你的github下载了代码，启动之后，http://localhost:8080并没有登录，同事console也没自动生成密码
wean_a23e:跟着步骤一步一步来，github 给出了 changlog.md

你说的 http://localhost:8080 是在第一步介绍的，配合命令
git checkout step1
4896d2e4a35d:有几个类少了，有源码参考一下吗？
Macchiatto_6f56:请问大神，这种组合如何实现对于修改个人信息这种接口的更高级别的安全验证，保证每个人同一时间只有一个token有效，且保证自己的token只对自己的账户有效。防止有人恶意拿着正确有效的token，修改他人的用户信息
wean_a23e:@Macchiatto_6f56 要做更高级别的安全验证，可以增加短信验证等其他验证方式
wean_a23e:1. 修改个人信息，如修改密码，可以缓存一个最后修改信息时间，在判断 token 的拦截器中判断这个时间来判断 token 是否过期（如果用户修改密码，令他以前的 token 过期）
2.同一时间只能有一个 token 有效，同样也可以通过缓存最后一次获得的 token 字符串，在拦截器中判断用户带来的 token 是否是最新的 token
3.防止别人拿着正确的 token 修改别人的账号，可以通过设计 api 时，获取要操作的用户 id，判断这个 id 是否跟 token 里封装的 id 一致来解决
18587a1108f1:写的很不错！刚好在看这一块支持
Winter_Chen:厉害了，一直没找到详细的使用方法，这个太赞了，感谢

Spring Security 使用总结

各个技术的简要介绍

json : 与前端交互的数据交换格式

jwt (json web token)

Spring Boot

Spring Security

本次技术方案中 Spring Security 执行流程

动手实现这个安全框架

步骤一：建立项目，配置好数据源

步骤二：生成我们的 jwt

步骤三 : 实现验证 token 是否有效，并根据 token 获得账号详细信息（权限，是否处于封号状态）的功能

步骤四 : 定义解析 token 的拦截器

步骤五 : 注册步骤四的拦截器，使它在 Spring Security 读取本次会话权限前将用户所具有的权限写入本次会话中

步骤六 : 完善 401 和 403 返回结果

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Spring

Java开发那些事

web

我爱编程

J2EE

JAVA

Spring 学习

Spring-Boot

Spring Security 使用总结

各个技术的简要介绍

json : 与前端交互的数据交换格式

jwt (json web token)

Spring Boot

Spring Security

本次技术方案中 Spring Security 执行流程

动手实现这个安全框架

步骤一 ： 建立项目，配置好数据源

步骤二 ： 生成我们的 jwt

步骤三 : 实现验证 token 是否有效，并根据 token 获得账号详细信息（权限，是否处于封号状态）的功能

步骤四 : 定义解析 token 的拦截器

步骤五 : 注册步骤四的拦截器，使它在 Spring Security 读取本次会话权限前将用户所具有的权限写入本次会话中

步骤六 : 完善 401 和 403 返回结果

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

步骤一：建立项目，配置好数据源

步骤二：生成我们的 jwt