一篇文章带你搞定 SpringSecurity 结合Jwt 实现无状态登录

梦里梦外; 2022-12-06 15:54 461阅读 0赞

在前后端分离的项目中，登录策略也有不少，不过 JWT 算是目前比较流行的一种解决方案了，本文就和大家来分享一下如何将 Spring Security 和 JWT 结合在一起使用，进而实现前后端分离时的登录解决方案。

### 文章目录 ###

*   *  一、无状态登录
     *   *  1. 什么是有状态 ？
         *  2. 什么是无状态 ?
         *  3. 如何实现无状态 ？
     *  二、JWT
     *   *  1. JWT 简介
         *  2. JWT 数据格式
         *  3. JWT 交互流程
         *  4. JWT 存在的问题
     *  三、实战 SpringBoot 整合 JWT
     *   *  1. 加入依赖：
         *  2. 建立用户对象 User
         *  3. 建立测试接口 HelloController
         *  4. JWT 过滤器配置
         *  5. Spring Security 配置
         *  6. 测试

## 一、无状态登录 ##

### 1. 什么是有状态 ？ ###

有状态服务，即服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理，典型的设计如Tomcat中的Session

例如登录：用户登录后，我们把用户的信息保存在服务端session中，并且给用户一个cookie值，记录对应的session，然后下次请求，用户携带cookie值来（这一步有浏览器自动完成），我们就能识别到对应session，从而找到用户的信息。  
这种方式目前来看最方便，但是也有一些缺陷，如下：

> （1）服务端保存大量数据，增加服务端压力  
> （2）服务端保存用户状态，不支持集群化部署

### 2. 什么是无状态 ? ###

微服务集群中的每个服务，对外提供的都使用 RESTful 风格的接口。  
而 RESTful 风格的一个最重要的规范就是：服务的无状态性，即：

> 服务端不保存任何客户端请求者信息  
> 客户端的每次请求必须具备自描述信息，通过这些信息识别客户端身份

那么这种无状态性有哪些好处呢？

> 客户端请求不依赖服务端的信息，多次请求不需要必须访问到同一台服务器  
> 服务端的集群和状态对客户端透明  
> 服务端可以任意的迁移和伸缩（可以方便的进行集群化部署）  
> 减小服务端存储压力

### 3. 如何实现无状态 ？ ###

无状态登录的流程：

> 首先客户端发送账户名/密码到服务端进行认证  
> 认证通过后，服务端将用户信息加密并且编码成一个 token，返回给客户端  
> 以后客户端每次发送请求，都需要携带认证的 token  
> 服务端对客户端发送来的 token 进行解密，判断是否有效，并且获取用户登录信息

## 二、JWT ##

### 1. JWT 简介 ###

JWT，全称是 Json Web Token ， 是一种 JSON 风格的轻量级的授权和身份认证规范，可实现无状态、分布式的 Web 应用授权：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center]  
JWT 作为一种规范，并没有和某一种语言绑定在一起，常用的 Java 实现是 GitHub 上的开源项目 jjwt，地址如下：`https://github.com/jwtk/jjwt`

### 2. JWT 数据格式 ###

JWT 包含三部分数据：

1.  Header：头部，通常头部有两部分信息：

> 声明类型，这里是JWT  
> 加密算法，自定义

我们会对头部进行 Base64Url 编码（可解码），得到第一部分数据。

1.  Payload：载荷，就是有效数据，在官方文档中(RFC7519)，这里给了 7 个示例信息：

> iss (issuer)：表示签发人  
> exp (expiration time)：表示token过期时间  
> sub (subject)：主题  
> aud (audience)：受众  
> nbf (Not Before)：生效时间  
> iat (Issued At)：签发时间  
> jti (JWT ID)：编号

这部分也会采用 Base64Url 编码，得到第二部分数据。

1.  Signature：签名，是整个数据的认证信息。一般根据前两步的数据，再加上服务的的密钥 secret（密钥保存在服务端，不能泄露给客户端），通过 Header 中配置的加密算法生成。用于验证整个数据完整和可靠性。  
    生成的数据格式如下图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 1]  
注意，这里的数据通过 `.` 隔开成了三部分，分别对应前面提到的三部分，另外，这里数据是不换行的，图片换行只是为了展示方便而已。

### 3. JWT 交互流程 ###

流程图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 2]  
步骤翻译：

> 应用程序或客户端向授权服务器请求授权  
> 获取到授权后，授权服务器会向应用程序返回访问令牌  
> 应用程序使用访问令牌来访问受保护资源（如API）

因为 JWT 签发的 token 中已经包含了用户的身份信息，并且每次请求都会携带，这样服务的就无需保存用户信息，甚至无需去数据库查询，这样就符合了 RESTful 的无状态规范。

### 4. JWT 存在的问题 ###

说了这么多，JWT 也不是天衣无缝，由客户端维护登录状态带来的一些问题在这里依然存在，举例如下：

> （1） 续签问题，这是被很多人诟病的问题之一，传统的 cookie+session 的方案天然的支持续签，但是 jwt 由于服务端不保存用户状态，因此很难完美解决续签问题，如果引入 redis，虽然可以解决问题，但是 jwt 也变得不伦不类了。  
> （2）注销问题，由于服务端不再保存用户信息，所以一般可以通过修改 secret 来实现注销，服务端 secret 修改后，已经颁发的未过期的 token 就会认证失败，进而实现注销，不过毕竟没有传统的注销方便。  
> （3）密码重置，密码重置后，原本的 token 依然可以访问系统，这时候也需要强制修改 secret。  
> （4）基于第 2 点和第 3 点，一般建议不同用户取不同 secret。

## 三、实战 SpringBoot 整合 JWT ##

### 1. 加入依赖： ###

![在这里插入图片描述][20200914145836336.png_pic_center]  
然后加入 jwt 依赖：

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

### 2. 建立用户对象 User ###

public class User implements UserDetails { 
        private String username;
        private String password;
        private List<GrantedAuthority> authorities;
    
        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() { 
            return authorities;
        }
        @Override
        public boolean isAccountNonExpired() { 
            return true;
        }
    
        @Override
        public boolean isAccountNonLocked() { 
            return true;
        }
    
        @Override
        public boolean isCredentialsNonExpired() { 
            return true;
        }
    
        @Override
        public boolean isEnabled() { 
            return true;
        }
        //get 和 set 方法省略
    }

### 3. 建立测试接口 HelloController ###

@RestController
    public class HelloController { 
        @GetMapping("/hello")
        public String hello() { 
            return "hello";
        }
    
        @GetMapping("/admin")
        public String admin() { 
            return "admin";
        }
    }

HelloController 很简单，这里有两个接口，设计是 `/hello` 接口可以被具有 `user` 角色的用户访问，而 `/admin` 接口则可以被具有 `admin` 角色的用户访问。

### 4. JWT 过滤器配置 ###

接下来提供两个和 JWT 相关的过滤器配置：

一个是用户登录的过滤器，在用户的登录的过滤器中校验用户是否登录成功，如果登录成功，则生成一个token返回给客户端，登录失败则给前端一个登录失败的提示。

第二个过滤器则是当其他请求发送来，校验token的过滤器，如果校验成功，就让请求继续执行。

（1）用户登录的过滤器

public class JwtLoginFilter extends AbstractAuthenticationProcessingFilter { 
    
        public JwtLoginFilter(String defaultFilterProcessesUrl, AuthenticationManager authenticationManager) { 
            super(new AntPathRequestMatcher(defaultFilterProcessesUrl));
            setAuthenticationManager(authenticationManager);
        }
    
        @Override
        public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse httpServletResponse) throws AuthenticationException, IOException { 
            User user = new ObjectMapper().readValue(req.getInputStream(), User.class);
            return getAuthenticationManager().authenticate(new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword()));
        }
    
        @Override
        protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse resp, FilterChain chain, Authentication authResult) throws IOException, ServletException { 
            //获取登录用户的角色
            Collection<? extends GrantedAuthority> authorities = authResult.getAuthorities();
            StringBuffer sb = new StringBuffer();
            //遍历角色存储到 buffer 中
            for (GrantedAuthority authority : authorities) { 
                sb.append(authority.getAuthority()).append(",");
            }
            String jwt = Jwts.builder()
                    .claim("authorities", sb)
                    .setSubject(authResult.getName())
                    .setExpiration(new Date(System.currentTimeMillis() + 60 * 60 * 1000))
                    .signWith(SignatureAlgorithm.HS512, "yolo@123")
                    .compact();
            Map<String, String> map = new HashMap<>();
            map.put("token", jwt);
            map.put("msg", "登录成功");
            resp.setContentType("application/json;charset=utf-8");
            PrintWriter out = resp.getWriter();
            out.write(new ObjectMapper().writeValueAsString(map));
            out.flush();
            out.close();
        }
    
        @Override
        protected void unsuccessfulAuthentication(HttpServletRequest req, HttpServletResponse resp, AuthenticationException failed) throws IOException, ServletException { 
            Map<String, String> map = new HashMap<>();
            map.put("msg", "登录失败");
            resp.setContentType("application/json;charset=utf-8");
            PrintWriter out = resp.getWriter();
            out.write(new ObjectMapper().writeValueAsString(map));
            out.flush();
            out.close();
        }
    }

> （1）自定义 JwtLoginFilter 继承自 AbstractAuthenticationProcessingFilter，并实现其中的三个默认方法。  
> （2）attemptAuthentication方法中，我们从登录参数中提取出用户名密码，然后调用`AuthenticationManager.authenticate()`方法去进行自动校验。  
> （3）第二步如果校验成功，就会来到successfulAuthentication回调中，在successfulAuthentication方法中，将用户角色遍历然后用一个 , 连接起来，然后再利用Jwts去生成token，按照代码的顺序，生成过程一共配置了四个参数，分别是用户角色、主题、过期时间以及加密算法和密钥，然后将生成的token写出到客户端。  
> （4）第二步如果校验失败就会来到 unsuccessfulAuthentication 方法中，在这个方法中返回一个错误提示给客户端即可。

（2）token校验的过滤器：

public class JwtFilter extends GenericFilterBean { 
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { 
            HttpServletRequest req = (HttpServletRequest) servletRequest;
            String jwtToken = req.getHeader("authorization");
            Jws<Claims> jws = Jwts.parser().setSigningKey("yolo@123")
                    //前端传过来的时候会多一个 "Bearer"，需要将其替换掉
                    .parseClaimsJws(jwtToken.replace("Bearer", ""));
            Claims claims = jws.getBody();
            //获取当前登录用户名
            String username = claims.getSubject();
            List<GrantedAuthority> authorities = AuthorityUtils.commaSeparatedStringToAuthorityList((String) claims.get("authorities"));
            UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, null, authorities);
            SecurityContextHolder.getContext().setAuthentication(token);
            filterChain.doFilter(servletRequest,servletResponse);
        }
    }

> （1）首先从请求头中提取出 authorization 字段，这个字段对应的value就是用户的token。  
> （2）将提取出来的token字符串转换为一个Claims对象，再从Claims对象中提取出当前用户名和用户角色，创建一个`UsernamePasswordAuthenticationToken`放到当前的Context中，然后执行过滤链使请求继续执行下去。

### 5. Spring Security 配置 ###

@Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter { 
        @Bean
        PasswordEncoder passwordEncoder() { 
            return new BCryptPasswordEncoder();
        }
    
        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception { 
            auth.inMemoryAuthentication()
                    .withUser("yolo")
                    .password("$2a$10$0WjZpkSCAHKrcQ/a3.CwOuWP3arJOloYs2oecrC9oPny9HWdnZ.Ti")
                    .roles("user")
                    .and()
                    .withUser("admin")
                    .password("$2a$10$NRYzZTFPSDorqpIVXJaSxuOwITR6NJmFTJZUBkLcBK7JyRNxdfxTy")
                    .roles("admin");
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception { 
            http.authorizeRequests()
                    .antMatchers("/hello")
                    .hasRole("user")
                    .antMatchers("/admin")
                    .hasRole("admin")
                    .antMatchers(HttpMethod.POST, "/login")
                    .permitAll()
                    .anyRequest().authenticated()
                    .and()
                    //添加过滤器，分配 token
                    .addFilterBefore(new JwtLoginFilter("/login", authenticationManager()), UsernamePasswordAuthenticationFilter.class)
                    //校验token
                    .addFilterBefore(new JwtFilter(), UsernamePasswordAuthenticationFilter.class)
                    .csrf().disable();
        }
    }

> （1）首先对密码做解密处理。  
> （2）简单起见，这里并未连接数据库，我直接在内存中配置了两个用户，两个用户具备不同的角色。  
> （3）配置路径规则时， `/hello` 接口必须要具备 user 角色才能访问， `/admin` 接口必须要具备 admin 角色才能访问，POST 请求并且是 `/login` 接口则可以直接通过，其他接口必须认证后才能访问。  
> （4）最后配置上两个自定义的过滤器并且关闭掉csrf保护。

### 6. 测试 ###

小插曲：测试时报错：`java.lang.ClassNotFoundException: javax.xml.bind.DatatypeConverter`

原因就是 jdk 的版本过高可以添加如下依赖解决：

<dependency>
                <groupId>javax.xml.bind</groupId>
                <artifactId>jaxb-api</artifactId>
                <version>2.3.0</version>
            </dependency>
            <dependency>
                <groupId>com.sun.xml.bind</groupId>
                <artifactId>jaxb-impl</artifactId>
                <version>2.3.0</version>
            </dependency>
            <dependency>
                <groupId>com.sun.xml.bind</groupId>
                <artifactId>jaxb-core</artifactId>
                <version>2.3.0</version>
            </dependency>
            <dependency>
                <groupId>javax.activation</groupId>
                <artifactId>activation</artifactId>
                <version>1.1.1</version>
            </dependency>

登录成功：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 3]  
访问 hello 接口：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 4]  
由于 yolo 只具有 user 权限，所以访问 admin 会失败：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 5]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/4e984644cb7d4c5989f8912b4ef4fd7c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/e1a060197cd047dda80c84666e4e4a4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/e0703e061a5748399ea8e0518bdfaab1.png
[20200914145836336.png_pic_center]: /images/20221123/3626fbcf5c594a0394b16da59969ef78.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/d7805b383061496ca17dde0d0260ba4d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/be2787b8d5bd485c8927be4e4df04e43.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmh1YWliZWlhbg_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/d7b38d79467247b18c866e7443bc0ae0.png