Springboot2整合JWT的实现

曾经终败给现在 2021-11-13 21:14 549阅读 0赞

## jwt的作用 ##

对于一个技术而言，我们不能为了用它而用它，而且应该从业务出发，我为了解决什么问题才用哪种技术。  
首先，jwt全称是Json Web Token，在讨论基于Token的身份认证是如何工作的以及它的好处之前，我们先来看一下以前我们是怎么做的：

由于HTTP协议是无状态的，也就是说，如果我们已经认证了一个用户，那么他下一次请求的时候，服务器不知道我是谁，我们必须再次认证。  
传统的做法是将已经认证过的用户信息存储在服务器上，比如Session。用户下次请求的时候带着Session ID，然后服务器以此检查用户是否认证过。

这种基于服务器的身份认证方式存在一些问题：

*  Sessions : 每次用户认证通过以后，服务器需要创建一条记录保存用户信息，通常是在内存中，随着认证通过的用户越来越多，服务器的在这里的开销就会越来越大。
 *  Scalability : 由于Session是在内存中的，这就带来一些扩展性的问题。
 *  CORS : 当我们想要扩展我们的应用，让我们的数据被多个移动设备使用时，我们必须考虑跨资源共享问题。当使用AJAX调用从另一个域名下获取资源时，我们可能会遇到禁止请求的问题。
 *  CSRF : 用户很容易受到CSRF攻击。

### JWT与Session的差异 ###

相同点是，它们都是存储用户信息；然而，Session是在服务器端的，而JWT是在客户端的。

Session方式存储用户信息的最大问题在于要占用大量服务器内存，增加服务器的开销。

而JWT方式将用户状态分散到了客户端中，可以明显减轻服务端的内存压力。

Session的状态是存储在服务器端，客户端只有session id；而jwt的token的状态是存储在客户端。

同时jwt也很好的解决了跨域的问题。

如果你正在构建从服务器到服务器或客户端到服务器（如：移动应用 APP 或单页面应用）的 API 服务，那么使用 JWT 是非常明智的。比如：  
你的客户端需要通过 API 进行身份验证，并返回 JWT  
然后，客户端使用返回的 JWT 经过身份验证去请求其它的 API 服务  
这些其它 API 服务通过客户端的 JWT 验证客户端是可信的，并且可以执行某些操作无需再次验证

对于这类 API 服务，JWT 非常适合，因为客户端需要频繁进行请求，并且权限是可控的，通常认证数据以无状态方式持久存在，不需要过多依赖用户信息。

如果你正在构建的应用类似单点登录或 OpenID Connect 认证，JWT 同样十分适合，就是实现一种通过第三方验证用户的方法。

## jwt的原理 ##

研究原理当然是推荐先看一下官网文档：https://jwt.io/introduction/  
文档上写的也很清楚，我就简单讲讲，不细说了  
jwt分为3部分：  
Header  
Payload  
Signature  
完整的token样式如：  
xxxxx.yyyyy.zzzzz

### header示例 ###

示例：  
\{  
“alg”: “HS256”,  
“typ”: “JWT”  
\}  
然后使用Base64Url 编码

### payload示例 ###

\{  
“sub”: “1234567890”,  
“name”: “John Doe”,  
“admin”: true  
\}  
然后使用Base64Url 编码

### Signature示例 ###

HMACSHA256(  
base64UrlEncode(header) + “.” +  
base64UrlEncode(payload),  
secret)  
然后使用Base64Url 编码

### token ###

最后的token就是 前3部分使用 . 连接起来

## jwt的java实现 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hvbm55ZWU_size_16_color_FFFFFF_t_70]  
官网的libraries https://jwt.io/\#libraries 有介绍实现这个的规范的库，我们使用的就是图中的jedis  
访问作者的github:https://github.com/jwtk/jjwt ，发现文档写的很详细，大家可以多阅读阅读

但是光使用jwt没有解决注销、修改密码、token自动续签这3个场景。使用redis可以解决，关于实现方式，我们后面再讲。

## 整合springboot ##

读完jjwt的文档后就可以上手整合springboot了

### 导入依赖 ###

<dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-api</artifactId>
        <version>0.10.7</version>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-impl</artifactId>
        <version>0.10.7</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-jackson</artifactId>
        <version>0.10.7</version>
        <scope>runtime</scope>
    </dependency>

### 编写工具类 ###

JwtUtil.java

/** * @author hy * @date 2019-07-24 */
    @Component
    public class JwtUtil { 
    
        Logger logger = LoggerFactory.getLogger(JwtUtil.class);
    
        private static JwtUtil jwtUtil;
    
        @Autowired
        AppConfig appConfig;
    
        private static SecretKey key;
    
        @PostConstruct
        public void init(){ 
            jwtUtil = this;
            logger.info("----------------初始化 JWT 成功");
        }
    
        public static SecretKey getSecretKey(){ 
            if (key == null){ 
                key = Keys.hmacShaKeyFor(jwtUtil.appConfig.getSecretKey().getBytes());
            }
            return key;
        }
    
        /** * 获得token * @param subject 需要携带的json信息 * @return token */
        public synchronized static String getToken(String subject){ 
            SecretKey key = getSecretKey();
            String token = Jwts.builder()
                    .setIssuer(jwtUtil.appConfig.getAppName())
                    .setAudience("client")
                    .setSubject(subject)
                    .setIssuedAt(new Date())
                    .setExpiration(new Date(System.currentTimeMillis() + 60 * 60 * 1000))
                    .signWith(key)
                    .setId(String.valueOf(UUID.randomUUID()))
                    .compact();
            return token;
        }
    
        /** * 获得token * @param iss 发起方 * @param aud 接收方 * @param exp 过期时间，单位分钟 * @param subject 需要携带的json信息 * @return token */
        public static String getToken(String iss,String aud,Integer exp,String subject){ 
            SecretKey key = getSecretKey();
            String token = Jwts.builder()
                    .setIssuer(iss)
                    .setAudience(aud)
                    .setSubject(subject)
                    .setIssuedAt(new Date())
                    .setExpiration(new Date(System.currentTimeMillis() + exp * 60 * 1000))
                    .signWith(key)
                    .setId(String.valueOf(UUID.randomUUID()))
                    .compact();
            return token;
        }
    
        public static Object parseToken(String token){ 
            String keySecret = jwtUtil.appConfig.getSecretKey();
            SecretKey key = Keys.hmacShaKeyFor(keySecret.getBytes());
            try { 
                Claims body = Jwts.parser()
                        .setSigningKey(key)
                        .parseClaimsJws(token)
                        .getBody();
                return body;
            }catch (ExpiredJwtException expiredJwtException){ 
                return ResultCode.TIME_OUT;
            }
        }
    
    }

这里面我使用了AppConfig 这个配置类，也可以不用，我这么做只是方便在配置文件中修改 secretKey  
上面只是实现了一个工具类，我们还需要一个filter才能让jwt更好 的发挥作用。

JwtFilter.java

@Configuration
    public class JwtFilter extends OncePerRequestFilter { 
    
        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { 
    
            String servletPath = request.getServletPath();
            if (StringUtils.isEmpty(servletPath)){ 
                return;
            }
            if (servletPath.startsWith("/test") || servletPath.startsWith("/druid") || servletPath.startsWith("/user/hello") || servletPath.startsWith("/user/login") ){ 
                //放行
                filterChain.doFilter(request, response);
                return;
            }
            String authorization = request.getHeader("Authorization");
            if (StringUtils.isEmpty(authorization)){ 
                fail(response,ResultCode.ERROR_TOKEN);
                return;
            }
            String prefix = "Bearer ";
            if (!authorization.startsWith(prefix)){ 
                fail(response,ResultCode.ERROR_TOKEN);
                return;
            }
            String token = authorization.substring(prefix.length());
            if (StringUtils.isEmpty(token)){ 
                fail(response,ResultCode.ERROR_TOKEN);
                return;
            }
    
            Object r = JwtUtil.parseToken(token);
            if (r instanceof Integer){ 
                fail(response, (Integer) r);
            }else if (r instanceof Claims){ 
                //放行
                filterChain.doFilter(request, response);
            }
        }
    
        private void fail(HttpServletResponse response,Integer resultCode) throws IOException { 
            // 失败
            response.setContentType("application/json; charset=utf-8");
            PrintWriter writer = response.getWriter();
            JsonResult result = new JsonResult(resultCode,"token验证失败");
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("result", result);
            writer.print(jsonObject);
            writer.close();
        }
    }

JwtFilter能够统一验证处理token

使用示例：

@PostMapping(value = "/login")
        public String login(
                @RequestBody JSONObject in
                ){ 
            String username = in.getString("username");
            String password = in.getString("password");
            //验证账户
            String token = JwtUtil.getToken(in.toJSONString());
            redisUtil.set("token", token);
            return redisUtil.get("token");
        }

验证成功返回了token后，前端将token存进header的Authorization里，并且每次请求携带这个Authorization就行了

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hvbm55ZWU_size_16_color_FFFFFF_t_70]: /images/20211113/082dce61b96345b3995fcd94397118b8.png