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

一个玩游戏的程序猿

已于 2024-03-31 12:21:54 修改

阅读量6.1k

点赞数 10

分类专栏： SpringBoot 文章标签： spring boot 后端 java

于 2023-07-31 10:11:05 首次发布

本文链接：https://blog.csdn.net/qq_21154101/article/details/132016813

版权

SpringBoot 专栏收录该内容

10 篇文章 17 订阅

订阅专栏

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

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

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

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

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

一、服务端生成token

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

1、添加token依赖

		<dependency>
			<groupId>com.auth0</groupId>
			<artifactId>java-jwt</artifactId>
			<version>3.4.1</version>
		</dependency>
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt</artifactId>
			<version>0.9.1</version>
		</dependency>

2、token工具类

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

package com.zhaojun.server.util;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;
public class JwtUtil {
    private static final String secret = "hand2020";
    private static final Long expiration = 1209600L;

    /**
     * 生成用户token,设置token超时时间
     */
    public static String createToken(String name) {
        //过期时间
        Date expireDate = new Date(System.currentTimeMillis() + expiration * 1000);
        Map<String, Object> map = new HashMap<>();
        map.put("alg", "HS256");
        map.put("typ", "JWT");
        String token = JWT.create()
                // 添加头部
                .withHeader(map)
                //可以将基本信息放到claims中
                //userName
                .withClaim("userName", name)
                //超时设置,设置过期的日期
                .withExpiresAt(expireDate)
                //签发时间
                .withIssuedAt(new Date())
                //SECRET加密
                .sign(Algorithm.HMAC256(secret));
        System.out.println(token);
        return token;
    }

    /**
     * 校验token并解析token
     */
    public static boolean verifyToken(String token) {
        DecodedJWT jwt;
        try {
            JWTVerifier verifier = JWT.require(Algorithm.HMAC256(secret)).build();
            jwt = verifier.verify(token);
            if (jwt.getExpiresAt().before(new Date())) {
                System.out.println("token过期");
                return false;
            }
        } catch (Exception e) {
            //解码异常则抛出异常
            System.out.println("token解析异常:" + e.getMessage());
            return false;
        }
        return true;
    }

}

二、客户端携带token

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

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

1、注册时获取token

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

    private void doRegister() {
        String name = mNameEditText.getText().toString();
        String password = mPasswordEditText.getText().toString();
        String phone = mPhoneEditText.getText().toString();
        if (TextUtils.isEmpty(name) || TextUtils.isEmpty(password) || TextUtils.isEmpty(phone)) {
            Toast.makeText(this, "用户名、手机号或密码为空", Toast.LENGTH_SHORT).show();
        }
        String url = URL + "name=" + name + "&password=" + password + "&phone=" + phone;
        new Thread(new Runnable() {
            @Override
            public void run() {
                OkHttpClient client = new OkHttpClient();
                Request request = new Request.Builder()
                        .url(url)
                        .build();
                try {
                    Response response = client.newCall(request).execute();
                    ResponseBody body = response.body();
                    if (body != null) {
                        String result = body.string();
                        Log.d("TTTT",result);
                        Gson gson = new Gson();
                        TypeToken<RegisterResult> typeToken = new TypeToken<RegisterResult>() {
                        };
                        RegisterResult registerResult = gson.fromJson(result, typeToken);
                        if (registerResult != null) {
                            String token = registerResult.getToken();
                            SPUtils.getInstance().put("token", token);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

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

2、请求时携带token

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

    private void tokenLogin() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                OkHttpClient client = new OkHttpClient();
                Request request = new Request.Builder()
                        .url(url)
                        .addHeader("token", SPUtils.getInstance().getString("token"))
                        .build();
                try {
                    Response response = client.newCall(request).execute();
                    ResponseBody body = response.body();
                    if (body != null) {
                        String result = body.string();
                        Log.d("TTTT", result);
                        Gson gson = new Gson();
                        TypeToken<LoginResult> typeToken = new TypeToken<LoginResult>() {
                        };
                        LoginResult loginResult = gson.fromJson(result, typeToken);
                        if (loginResult != null) {
                            int code = loginResult.getCode();
                            if (code != 0) {
                                runOnUiThread(new Runnable() {
                                    @Override
                                    public void run() {
                                        startLoginActivity();
                                    }
                                });
                            }
                        }
                    }
                } catch (Exception e) {
                    Log.d("TTTT",e.getMessage());
                }
            }
        }).start();
    }

三、请求后验证token

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

1、token拦截器

package com.zhaojun.server.interceptor;

import com.zhaojun.server.util.JwtUtil;
import com.zhaojun.server.util.TextUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;

public class TokenInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpServletResponseWrapper wrapper = new HttpServletResponseWrapper(response);
        String token = request.getHeader("token");
        if (TextUtils.isEmpty(token)) {
            wrapper.sendRedirect("fail/token/null");
            System.out.println("null token");
            return false;
        }
        if (!JwtUtil.verifyToken(token)) {
            wrapper.sendRedirect("fail/token/invalid");
            System.out.println("invalid token");
            return false;
        }
        System.out.println("valid token");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("拦截器处理结束...");
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("请求结束...");
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

2、注册token拦截器

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

package com.zhaojun.server.interceptor;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class MyWebMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TokenInterceptor())
                .addPathPatterns("/login")
                .excludePathPatterns("/register");
    }
}

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：

一个玩游戏的程序猿

关注

10
点赞
踩
50

收藏

觉得还不错? 一键收藏
打赏
1
评论
SpringBoot（九）jwt + 拦截器实现token验证

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

扫一扫