devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

JWT及和Spring Security整合_springsecurity jwt

作者：我家自动化 | 2024-05-06 23:07:52

赞

踩

springsecurity jwt

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

1 无状态登录

1.1 什么是有状态？

有状态服务，即服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理，典型的设计如Tomcat中的Session。例如登录：用户登录后，我们把用户的信息保存在服务端session中，并且给用户一个cookie值，记录对应的session，然后下次请求，用户携带cookie值来（这一步有浏览器自动完成），我们就能识别到对应session，从而找到用户的信息。这种方式目前来看最方便，但是也有一些缺陷，如下：

· 服务端保存大量数据，增加服务端压力

· 服务端保存用户状态，不支持集群化部署

1.2 什么是无状态

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

· 服务端不保存任何客户端请求者信息

· 客户端的每次请求必须具备自描述信息，通过这些信息识别客户端身份

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

· 客户端请求不依赖服务端的信息，多次请求不需要必须访问到同一台服务器

· 服务端的集群和状态对客户端透明

· 服务端可以任意的迁移和伸缩（可以方便的进行集群化部署）

· 减小服务端存储压力

1.3.如何实现无状态

无状态登录的流程：

· 首先客户端发送账户名/密码到服务端进行认证

· 认证通过后，服务端将用户信息加密并且编码成一个token，返回给客户端

· 以后客户端每次发送请求，都需要携带认证的token

· 服务端对客户端发送来的token进行解密，判断是否有效，并且获取用户登录信息

1.4 JWT

1.4.1 简介

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

解析jwt的官网：JSON Web Tokens - jwt.io

JWT 作为一种规范，并没有和某一种语言绑定在一起

1.4.2 JWT数据格式

JWT包含三部分数据：

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

o 声明类型，这里是JWT

o 加密算法，自定义

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

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

o iss (issuer)：表示签发人

o exp (expiration time)：表示token过期时间

o sub (subject)：主题

o aud (audience)：受众

o nbf (Not Before)：生效时间

o iat (Issued At)：签发时间

o jti (JWT ID)：编号

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

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

生成的数据格式如下图：

 注意，这里的数据通过 . 隔开成了三部分，分别对应前面提到的三部分，另外，这里数据是不换行的，图片换行只是为了展示方便而已。

1.4.3 JWT交互流程

流程图：

步骤翻译：

1. 应用程序或客户端向授权服务器请求授权

2. 获取到授权后，授权服务器会向应用程序返回访问令牌

3. 应用程序使用访问令牌来访问受保护资源（如API）

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

1.5 JWT 存在的问题

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

1. 续签问题，这是被很多人诟病的问题之一，传统的cookie+session的方案天然的支持续签，但是jwt由于服务端不保存用户状态，因此很难完美解决续签问题，如果引入redis，虽然可以解决问题，但是jwt也变得不伦不类了。

2. 注销问题，由于服务端不再保存用户信息，所以一般可以通过修改secret来实现注销，服务端secret修改后，已经颁发的未过期的token就会认证失败，进而实现注销，不过毕竟没有传统的注销方便。

3. 密码重置，密码重置后，原本的token依然可以访问系统，这时候也需要强制修改secret。

4. 基于第2点和第3点，一般建议不同用户取不同secret。

2 实战

说了这么久，接下来我们就来看看这个东西到底要怎么用？

2.1 环境搭建

首先我们来创建一个Spring Boot项目，创建时需要添加Spring Security依赖，创建完成后，添加 jjwt 依赖，完整的pom.xml文件如下：

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-security</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>org.springframework.boot</groupId>
  7.     <artifactId>spring-boot-starter-web</artifactId>
  8. </dependency>
  9. <dependency>
  10.     <groupId>io.jsonwebtoken</groupId>
  11.     <artifactId>jjwt</artifactId>
  12.     <version>0.9.1</version>
  13. </dependency>

然后在项目中创建一个简单的 User 对象实现 UserDetails 接口，如下：

  1. public class User implements UserDetails {
  2.     private String username;
  3.     private String password;
  4.     private List<GrantedAuthority> authorities;
  5.     public String getUsername() {
  6.         return username;
  7.     }
  8.     @Override
  9.     public boolean isAccountNonExpired() {
  10.         return true;
  11.     }
  12.     @Override
  13.     public boolean isAccountNonLocked() {
  14.         return true;
  15.     }
  16.     @Override
  17.     public boolean isCredentialsNonExpired() {
  18.         return true;
  19.     }
  20.     @Override
  21.     public boolean isEnabled() {
  22.         return true;
  23.     }
  24.     //省略getter/setter
  25. }

这个就是我们的用户对象，先放着备用，再创建一个HelloController，内容如下：

  1. @RestController
  2. public class HelloController {
  3.     @GetMapping("/hello")
  4.     public String hello() {
  5.         return "hello jwt !";
  6.     }
  7.     @GetMapping("/admin")
  8.     public String admin() {
  9.         return "hello admin !";
  10.     }
  11. }

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

2.2 JWT 过滤器配置

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

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

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

这两个过滤器，我们分别来看，先看第一个：

  1. public class JwtLoginFilter extends AbstractAuthenticationProcessingFilter {
  2.     protected JwtLoginFilter(String defaultFilterProcessesUrl, AuthenticationManager authenticationManager) {
  3.         super(new AntPathRequestMatcher(defaultFilterProcessesUrl));
  4.         setAuthenticationManager(authenticationManager);
  5.     }
  6.     @Override
  7.     public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse resp) throws AuthenticationException, IOException, ServletException {
  8.         User user = new ObjectMapper().readValue(req.getInputStream(), User.class);
  9.         return getAuthenticationManager().authenticate(new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword()));
  10.     }
  11.     @Override
  12.     protected void successfulAuthentication(HttpServletRequest req, HttpServletResponse resp, FilterChain chain, Authentication authResult) throws IOException, ServletException {
  13.         Collection<? extends GrantedAuthority> authorities = authResult.getAuthorities();
  14.         StringBuffer as = new StringBuffer();
  15.         for (GrantedAuthority authority : authorities) {
  16.             as.append(authority.getAuthority())
  17.                     .append(",");
  18.         }
  19.         String jwt = Jwts.builder()
  20.                 .claim("authorities", as)//配置用户角色
  21.                 .setSubject(authResult.getName())
  22.                 .setExpiration(new Date(System.currentTimeMillis() + 10 * 60 * 1000))
  23.                 .signWith(SignatureAlgorithm.HS512,"sang@123")
  24.                 .compact();
  25.         resp.setContentType("application/json;charset=utf-8");
  26.         PrintWriter out = resp.getWriter();
  27.         out.write(new ObjectMapper().writeValueAsString(jwt));
  28.         out.flush();
  29.         out.close();
  30.     }
  31.     protected void unsuccessfulAuthentication(HttpServletRequest req, HttpServletResponse resp, AuthenticationException failed) throws IOException, ServletException {
  32.         resp.setContentType("application/json;charset=utf-8");
  33.         PrintWriter out = resp.getWriter();
  34.         out.write("登录失败!");
  35.         out.flush();
  36.         out.close();
  37.     }
  38. }

关于这个类，我说如下几点：

1. 自定义 JwtLoginFilter 继承自 AbstractAuthenticationProcessingFilter，并实现其中的三个默认方法。

2. attemptAuthentication方法中，我们从登录参数中提取出用户名密码，然后调用AuthenticationManager.authenticate()方法去进行自动校验。

3. 第二步如果校验成功，就会来到successfulAuthentication回调中，在successfulAuthentication方法中，将用户角色遍历然后用一个 , 连接起来，然后再利用Jwts去生成token，按照代码的顺序，生成过程一共配置了四个参数，分别是用户角色、主题、过期时间以及加密算法和密钥，然后将生成的token写出到客户端。

4. 第二步如果校验失败就会来到unsuccessfulAuthentication方法中，在这个方法中返回一个错误提示给客户端即可。

再来看第二个token校验的过滤器：

  1. public class JwtFilter extends GenericFilterBean {
  2.     @Override
  3.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  4.         HttpServletRequest req = (HttpServletRequest) servletRequest;
  5.         String jwtToken = req.getHeader("authorization");
  6.         System.out.println(jwtToken);
  7.         Claims claims = Jwts.parser().setSigningKey("sang@123").parseClaimsJws(jwtToken.replace("Bearer",""))
  8.                 .getBody();
  9.         String username = claims.getSubject();//获取当前登录用户名
  10.         List<GrantedAuthority> authorities = AuthorityUtils.commaSeparatedStringToAuthorityList((String) claims.get("authorities"));
  11.         UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, null, authorities);
  12.         SecurityContextHolder.getContext().setAuthentication(token);
  13.         filterChain.doFilter(req,servletResponse);
  14.     }
  15. }

关于这个过滤器，我说如下几点：

1. 首先从请求头中提取出 authorization 字段，这个字段对应的value就是用户的token。

2. 将提取出来的token字符串转换为一个Claims对象，再从Claims对象中提取出当前用户名和用户角色，创建一个UsernamePasswordAuthenticationToken放到当前的Context中，然后执行过滤链使请求继续执行下去。

如此之后，两个和JWT相关的过滤器就算配置好了。

2.3 Spring Security 配置

接下来我们来配置 Spring Security,如下：

  1. @Configuration
  2. public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
  3.     @Bean
  4.     PasswordEncoder passwordEncoder() {
  5.         return NoOpPasswordEncoder.getInstance();
  6.     }
  7.     @Override
  8.     protected void configure(AuthenticationManagerBuilder auth) throws Exception {
  9.         auth.inMemoryAuthentication().withUser("admin")
  10.                 .password("123").roles("admin")
  11.                 .and()
  12.                 .withUser("sang")
  13.                 .password("456")
  14.                 .roles("user");
  15.     }
  16.  
  17.     @Override
  18.     protected void configure(HttpSecurity http) throws Exception {
  19.         http.authorizeRequests()
  20.                 .antMatchers("/hello").hasRole("user")
  21.                 .antMatchers("/admin").hasRole("admin")
  22.                 .antMatchers(HttpMethod.POST, "/login").permitAll()
  23.                 .anyRequest().authenticated()
  24.                 .and()
  25.                 .addFilterBefore(new JwtLoginFilter("/login",authenticationManager()),UsernamePasswordAuthenticationFilter.class)
  26.                 .addFilterBefore(new JwtFilter(),UsernamePasswordAuthenticationFilter.class)
  27.                 .csrf().disable();
  28.     }
  29. }

1. 简单起见，这里我并未对密码进行加密，因此配置了NoOpPasswordEncoder的实例。

2. 简单起见，这里并未连接数据库，我直接在内存中配置了两个用户，两个用户具备不同的角色。

3. 配置路径规则时， /hello 接口必须要具备 user 角色才能访问， /admin 接口必须要具备 admin 角色才能访问，POST 请求并且是 /login 接口则可以直接通过，其他接口必须认证后才能访问。

4. 最后配置上两个自定义的过滤器并且关闭掉csrf保护。

2.4 测试

做完这些之后，我们的环境就算完全搭建起来了，接下来启动项目然后在 POSTMAN 中进行测试，如下：

 接下来再去访问 /hello 接口，注意认证方式选择 Bearer Token，Token值为刚刚获取到的值，如下：

 可以看到，访问成功。

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

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号