devbox
一键难忘520
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot（九）jwt + 拦截器实现token验证_springboot拦截器验证token

作者：一键难忘520 | 2024-07-15 01:52:01

赞

踩

springboot拦截器验证token

    前面两篇文章的过滤器和拦截器，我们都提到过可以做诸如权限验证的事情。http/https是无状态的协议，当用户访问一个后端接口时，如何判断该用户有没有权限？当然，可以使用账号+密码去验证。但是，如果使用账号和密码，需要频繁访问数据库，很明显，会带来一些额外的开销。本篇介绍下使用jwt和拦截器实现token权限验证。     

    如果你是新手，且没看过我之前的一系列SpringBoot文章，建议至少看一下这一篇：

SpringBoot（四）SpringBoot搭建简单服务端_springboot做成服务_heart荼毒的博客-CSDN博客

    如果你想从头到尾系统地学习，欢迎关注我的专栏，持续更新：

https://blog.csdn.net/qq_21154101/category_12359403.html

目录

一、服务端生成token

1、添加token依赖

2、token工具类

二、客户端携带token

1、注册时获取token

2、 请求时携带token

三、请求后验证token

1、token拦截器

2、注册token拦截器

3、客户端请求和验证

四、token的构成

​​​​​​​一、服务端生成token

    如何生成token，我们可以使用jwt来生成token。什么是jwt，JWT即Json Web Token， JWT是目前最流行的跨域认证解决方案, 是一个开放式标准(RFC 7519), 用于在各方之间以JSON对象安全传输信息。

1、添加token依赖

  1. 		<dependency>
  2. 			<groupId>com.auth0</groupId>
  3. 			<artifactId>java-jwt</artifactId>
  4. 			<version>3.4.1</version>
  5. 		</dependency>
  6. 		<dependency>
  7. 			<groupId>io.jsonwebtoken</groupId>
  8. 			<artifactId>jjwt</artifactId>
  9. 			<version>0.9.1</version>
  10. 		</dependency>

2、token工具类

    写一个工具类，用来生成和校验token

  1. package com.zhaojun.server.util;
  2.  
  3. import com.auth0.jwt.JWT;
  4. import com.auth0.jwt.JWTVerifier;
  5. import com.auth0.jwt.algorithms.Algorithm;
  6. import com.auth0.jwt.interfaces.DecodedJWT;
  7.  
  8. import java.util.Date;
  9. import java.util.HashMap;
  10. import java.util.Map;
  11. public class JwtUtil {
  12.     private static final String secret = "hand2020";
  13.     private static final Long expiration = 1209600L;
  14.  
  15.     /**
  16.      * 生成用户token,设置token超时时间
  17.      */
  18.     public static String createToken(String name) {
  19.         //过期时间
  20.         Date expireDate = new Date(System.currentTimeMillis() + expiration * 1000);
  21.         Map<String, Object> map = new HashMap<>();
  22.         map.put("alg", "HS256");
  23.         map.put("typ", "JWT");
  24.         String token = JWT.create()
  25.                 // 添加头部
  26.                 .withHeader(map)
  27.                 //可以将基本信息放到claims中
  28.                 //userName
  29.                 .withClaim("userName", name)
  30.                 //超时设置,设置过期的日期
  31.                 .withExpiresAt(expireDate)
  32.                 //签发时间
  33.                 .withIssuedAt(new Date())
  34.                 //SECRET加密
  35.                 .sign(Algorithm.HMAC256(secret));
  36.         System.out.println(token);
  37.         return token;
  38.     }
  39.  
  40.     /**
  41.      * 校验token并解析token
  42.      */
  43.     public static boolean verifyToken(String token) {
  44.         DecodedJWT jwt;
  45.         try {
  46.             JWTVerifier verifier = JWT.require(Algorithm.HMAC256(secret)).build();
  47.             jwt = verifier.verify(token);
  48.             if (jwt.getExpiresAt().before(new Date())) {
  49.                 System.out.println("token过期");
  50.                 return false;
  51.             }
  52.         } catch (Exception e) {
  53.             //解码异常则抛出异常
  54.             System.out.println("token解析异常:" + e.getMessage());
  55.             return false;
  56.         }
  57.         return true;
  58.     }
  59.  
  60. }

二、客户端携带token

    因为一般token是放在header中的，直接在浏览器去访问是不能添加header的，当然可以借助postman等工具。我本身是做Android的，我直接基于okhttp快速写几个请求和简单的页面，包括之前的register和login。要实现的逻辑如下：

  • 注册新用户时生成token告诉客户端，客户端收到token后保存到本地
  • 客户端后续的所有请求，都在header中携带token
  • 服务端收到请求后，先校验token，token合法则放行

1、注册时获取token

    首先，我先注册个账号，账号为test，密码为123456，手机号为123456。如下示例代码，我使用okhttp写了一个注册请求。

  1.     private void doRegister() {
  2.         String name = mNameEditText.getText().toString();
  3.         String password = mPasswordEditText.getText().toString();
  4.         String phone = mPhoneEditText.getText().toString();
  5.         if (TextUtils.isEmpty(name) || TextUtils.isEmpty(password) || TextUtils.isEmpty(phone)) {
  6.             Toast.makeText(this, "用户名、手机号或密码为空", Toast.LENGTH_SHORT).show();
  7.         }
  8.         String url = URL + "name=" + name + "&password=" + password + "&phone=" + phone;
  9.         new Thread(new Runnable() {
  10.             @Override
  11.             public void run() {
  12.                 OkHttpClient client = new OkHttpClient();
  13.                 Request request = new Request.Builder()
  14.                         .url(url)
  15.                         .build();
  16.                 try {
  17.                     Response response = client.newCall(request).execute();
  18.                     ResponseBody body = response.body();
  19.                     if (body != null) {
  20.                         String result = body.string();
  21.                         Log.d("TTTT",result);
  22.                         Gson gson = new Gson();
  23.                         TypeToken<RegisterResult> typeToken = new TypeToken<RegisterResult>() {
  24.                         };
  25.                         RegisterResult registerResult = gson.fromJson(result, typeToken);
  26.                         if (registerResult != null) {
  27.                             String token = registerResult.getToken();
  28.                             SPUtils.getInstance().put("token", token);
  29.                         }
  30.                     }
  31.                 } catch (Exception e) {
  32.                     e.printStackTrace();
  33.                 }
  34.             }
  35.         }).start();
  36.     }

    注册成功后，可以看到后端返回了如下的json：

2、 请求时携带token

    如下示例代码，我使用okhttp写了一个header带token的请求，这个token就是之前注册时返回保存到本地的。

  1.     private void tokenLogin() {
  2.         new Thread(new Runnable() {
  3.             @Override
  4.             public void run() {
  5.                 OkHttpClient client = new OkHttpClient();
  6.                 Request request = new Request.Builder()
  7.                         .url(url)
  8.                         .addHeader("token", SPUtils.getInstance().getString("token"))
  9.                         .build();
  10.                 try {
  11.                     Response response = client.newCall(request).execute();
  12.                     ResponseBody body = response.body();
  13.                     if (body != null) {
  14.                         String result = body.string();
  15.                         Log.d("TTTT", result);
  16.                         Gson gson = new Gson();
  17.                         TypeToken<LoginResult> typeToken = new TypeToken<LoginResult>() {
  18.                         };
  19.                         LoginResult loginResult = gson.fromJson(result, typeToken);
  20.                         if (loginResult != null) {
  21.                             int code = loginResult.getCode();
  22.                             if (code != 0) {
  23.                                 runOnUiThread(new Runnable() {
  24.                                     @Override
  25.                                     public void run() {
  26.                                         startLoginActivity();
  27.                                     }
  28.                                 });
  29.                             }
  30.                         }
  31.                     }
  32.                 } catch (Exception e) {
  33.                     Log.d("TTTT",e.getMessage());
  34.                 }
  35.             }
  36.         }).start();
  37.     }

三、请求后验证token

    万事俱备，生成和请求携带token都做好了。接下来，需要在后端实现一个token拦截器，拦截除注册接口以外的任何请求。如果token校验通过则直接放行，否则拦截并返回错误信息。在这里定义了两种：token为空和token不合法。

1、token拦截器

  1. package com.zhaojun.server.interceptor;
  2.  
  3. import com.zhaojun.server.util.JwtUtil;
  4. import com.zhaojun.server.util.TextUtils;
  5. import org.springframework.web.servlet.HandlerInterceptor;
  6. import org.springframework.web.servlet.ModelAndView;
  7.  
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  10. import javax.servlet.http.HttpServletResponseWrapper;
  11.  
  12. public class TokenInterceptor implements HandlerInterceptor {
  13.  
  14.     @Override
  15.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  16.         HttpServletResponseWrapper wrapper = new HttpServletResponseWrapper(response);
  17.         String token = request.getHeader("token");
  18.         if (TextUtils.isEmpty(token)) {
  19.             wrapper.sendRedirect("fail/token/null");
  20.             System.out.println("null token");
  21.             return false;
  22.         }
  23.         if (!JwtUtil.verifyToken(token)) {
  24.             wrapper.sendRedirect("fail/token/invalid");
  25.             System.out.println("invalid token");
  26.             return false;
  27.         }
  28.         System.out.println("valid token");
  29.         return true;
  30.     }
  31.  
  32.     @Override
  33.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
  34.         System.out.println("拦截器处理结束...");
  35.         HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
  36.     }
  37.  
  38.     @Override
  39.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  40.         System.out.println("请求结束...");
  41.         HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
  42.     }
  43. }

2、注册token拦截器

    非常不建议直接对所有的url都进行拦截，仅拦截需要的请求就好了。

  1. package com.zhaojun.server.interceptor;
  2.  
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  6.  
  7. @Configuration
  8. public class MyWebMvcConfig implements WebMvcConfigurer {
  9.     @Override
  10.     public void addInterceptors(InterceptorRegistry registry) {
  11.         registry.addInterceptor(new TokenInterceptor())
  12.                 .addPathPatterns("/login")
  13.                 .excludePathPatterns("/register");
  14.     }
  15. }

3、客户端请求和验证

客户端发起header携带token的请求后，可以看到，验证成功：

使用浏览器进行不带token的请求后，重定向：

四、token的构成

    接下来，我们来看下token的构成。这是我访问我之前的注册接口http://localhost:8080/register?name=abc&phone=13456789123&password=123456，使用jwt生成的一个token 

​​​​​​​

      如下这一坨xx.xx.xx的就是token了：

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyTmFtZSI6ImFiYyIsImV4cCI6MTY5MjAxMjcwOCwiaWF0IjoxNjkwODAzMTA4fQ.rmUx9SCSR_5NI9-BTc6T4UxDTge2ZPTqhEvnEgS5OvM

    token的组成是这样的：header（头）.payload（负载）.signature（签名），header和payload都是base64编码，可以直接使用base64工具解析。当然，也可以去如下网站解析token开发工具箱 - JWT 在线解密 

     signature是签名部分，直接使用base64解析是不行的。需要通过密钥进行解密，密钥也就是我上面jwtUtils代码中的secret。

注意：payload是可以被解析的，因此，withClaim方法不要放关键信息，例如密码等，否则就直接暴露给别人了。

    本篇介绍了如何使用jwt生成和验证token，以及通过Android端发起header带token的请求去验证了token拦截器的执行过程。在最后，也简单介绍了token的构成，尤其需要注意的是，token的前两段是明文，里面不要放用户密码等隐私的信息。

 最后，分享一款免费看热门电影和电视剧的app，仅限Android：

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

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

  

闽ICP备14008679号