SpringBoot jwt + 拦截器实现token验证

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

一、服务端生成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 在线解密 (box3.cn)

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

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

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

SpringBoot jwt + 拦截器实现token验证

Spring 实现 3 种异步接口 2024-10-18 09:07

重学SpringBoot3-集成Redis（五）之布隆过滤器 2024-10-08 11:24

SpringBoot整合异步任务执行 2024-10-08 11:24

springboot kafka多数据源，通过配置动态加载发送者和消费者 2024-10-08 11:24

SpringBoot 集成 Redis 2024-10-08 11:24

SpringBoot整合QQ邮箱 2024-10-08 11:24

目录