微信登录流程步骤加JWT令牌认证

流程图

• 小程序代表我们自己开发的微信小程序
• 开发者服务器代表我们自己开发的后端服务
• 微信接口服务代表微信官方给我们提供的服务

第一步

在微信小程序调用vx.login()获取到code code就叫做授权码

第二步

在微信小程序调用vx.request()发起请求给我们自己写的后端 还把code给了我们

第三步

自己后端发送appid+appsecret+code给微信官方接口 然后微信官方给我们返回session_key + openid

第四步

自己的后端自定义登录状态与openid，session_key关联还可以搞一个token给他返回给小程序

第五步

小程序可以存储token通过storage

第六步

小程序调用wx.request()发起业务请求 并且携带自定义登录态 比如说token

第七步

后端去解析这个token然后就知道当前的用户是谁了然后进行业务操作

第八步

把数据返回给前端

步骤

步骤

1.引入jwt令牌依赖和httpclient依赖(微信支付)

<dependency>
  <groupId>io.jsonwebtoken</groupId>
  <artifactId>jjwt</artifactId>
  <version>0.9.1</version>
</dependency>
<dependency>
  <groupId>com.github.wechatpay-apiv3</groupId>
  <artifactId>wechatpay-apache-httpclient</artifactId>
  <version>0.4.8</version>
</dependency>

2.准备一个config类

package com.mbc.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "jwt")
@Data
public class JwtProperties {

    /**
     * 用户端微信用户生成jwt令牌相关配置
     */

    /**
     * 这是用来签署和验证JWT的用户端密钥。
     */
    private String userSecretKey;
    /**
     * 这是JWT的过期时间，一般以秒为单位。
     */
    private long userTtl;
    /**
     * 这是JWT的过期时间，一般以秒为单位。
     */
    private String userTokenName;

}

package com.mbc.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "wechat")
@Data
public class WeChatProperties {

    private String appid; //小程序的appid
    private String secret; //小程序的秘钥
    private String mchid; //商户号
    private String mchSerialNo; //商户API证书的证书序列号
    private String privateKeyFilePath; //商户私钥文件
    private String apiV3Key; //证书解密的密钥
    private String weChatPayCertFilePath; //平台证书
    private String notifyUrl; //支付成功的回调地址
    private String refundNotifyUrl; //退款成功的回调地址

}

配置文件

#JWT 配置
jwt:
  user-secret-key: mbc
    user-ttl: 7200000
    user-token-name: authentication
# 微信小程序配置码
wechat:
  appid: wxeb3a52be05ede3f7
  appsecret: cada08a2737068c78ac1fbe9bf9e595b

3.写JwtUtil

package com.mbc.utils;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.Map;

public class JwtUtil {
    /**
     * 生成jwt
     * 使用Hs256算法, 私匙使用固定秘钥
     *
     * @param secretKey jwt秘钥
     * @param ttlMillis jwt过期时间(毫秒)
     * @param claims    设置的信息
     * @return
     */
    public static String createJWT(String secretKey, long ttlMillis, Map<String, Object> claims) {
        // 指定签名的时候使用的签名算法，也就是header那部分
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        // 生成JWT的时间
        long expMillis = System.currentTimeMillis() + ttlMillis;
        Date exp = new Date(expMillis);

        // 设置jwt的body
        JwtBuilder builder = Jwts.builder()
        // 如果有私有声明，一定要先设置这个自己创建的私有的声明，这个是给builder的claim赋值，一旦写在标准的声明赋值之后，就是覆盖了那些标准的声明的
        .setClaims(claims)
        // 设置签名使用的签名算法和签名使用的秘钥
        .signWith(signatureAlgorithm, secretKey.getBytes(StandardCharsets.UTF_8))
        // 设置过期时间
        .setExpiration(exp);

        return builder.compact();
    }

    /**
     * Token解密
     *
     * @param secretKey jwt秘钥 此秘钥一定要保留好在服务端, 不能暴露出去, 否则sign就可以被伪造, 如果对接多个客户端建议改造成多个
     * @param token     加密后的token
     * @return
     */
    public static Claims parseJWT(String secretKey, String token) {
        // 得到DefaultJwtParser
        Claims claims = Jwts.parser()
        // 设置签名的秘钥
        .setSigningKey(secretKey.getBytes(StandardCharsets.UTF_8))
        // 设置需要解析的jwt
        .parseClaimsJws(token).getBody();
        return claims;
    }

}

这段代码展示了一个名为JwtUtil的工具类，用来生成和解析JWT（JSON Web Tokens）。JWT是一个开放标准

（RFC 7519），它定义了一种紧凑和自包含的方式，用于在各方之间以JSON对象的形式安全地传输信息。在

Web开发中，JWT常用于身份验证和信息交换，因为它们可以通过数字签名被验证和信任。下面是对JwtUtil类中

方法的详细解释：

createJWT(String secretKey, long ttlMillis, Map<String, Object> claims) 方法

这个方法用于生成JWT。

• 参数：

• • secretKey：用于签名JWT的秘钥。
  • ttlMillis：JWT的过期时间，以毫秒为单位。这个值会被加到当前时间上，用于设置JWT的exp（过期时间）声明。
  • claims：包含要放入JWT中的信息。Claims是JWT负载中的一部分，可以包含多个声明（Claim），例如用户身份信息、授权数据等。

• 工作流程：

1. 1. 指定使用HS256算法对JWT进行签名。
   2. 生成JWT的过期时间。
   3. 构建JWT负载，包含传入的claims数据、签名算法和秘钥，以及过期时间。

• 返回值：一个经过编码的字符串，代表了生成的JWT。这个字符串可用于后续的身份验证和信息交换。

parseJWT(String secretKey, String token) 方法

这个方法用于解析和验证JWT。

• 参数：

• • secretKey：用于验证签名的秘钥，必须与生成JWT时用的秘钥相同。
  • token：待解析的JWT字符串。

• 工作流程：

• • 通过指定的秘钥和JWT字符串创建Claims对象。
  • 使用.parser().setSigningKey(secretKey.getBytes(StandardCharsets.UTF_8))来设置验证用的签名秘钥。
  • 使用.parseClaimsJws(token)解析JWT，这会验证JWT的签名并解析负载内容。

• 返回值：Claims对象，包含了JWT负载中的信息（如果JWT验证通过）。

关键点

• 使用的HS256签名算法是对称的，即使用相同的秘钥来进行签名和验证。因此，secretKey应该被严格保密，不应被公开。
• 通过设置过期时间，JWT将在一定时间后失效，这对于安全性是非常重要的。
• 在实践中，claims可以包含诸如用户名、用户角色等信息，用于在客户端和服务器之间安全地传递用户身份信息。

这个工具类提供了一个简单而强大的方式来使用JWT进行身份验证和数据交换的实现。

4.定义用户登录的DTO和VO

package com.mbc.dto;

import lombok.Data;

import java.io.Serializable;

@Data
public class UserLoginDTO implements Serializable {

    /**
     * 微信服务器上的唯一id
     */
    private String openId;

    /**
     * 临时登录凭证
     */
    private String code;
}

package com.mbc.vo;



import lombok.Builder;
import lombok.Data;

import java.io.Serializable;

@Data
@Builder
public class UserLoginVO implements Serializable {

    /**
     * 主键ID
     */
    private Long Id;

    /**
     * 微信服务器上的唯一id
     */
    private String openId;

    /**
     * jwt令牌
     */
    private String token;

}

5.写Controller层

package com.mbc.controller;

import com.mbc.comment.Result;
import com.mbc.config.JwtProperties;
import com.mbc.dto.UserLoginDTO;
import com.mbc.dto.UserRealNameDTO;
import com.mbc.pojo.MbcUser;
import com.mbc.pojo.MbcUserInfo;
import com.mbc.service.UserService;
import com.mbc.utils.JwtUtil;
import com.mbc.vo.MbcUserInfoVO;
import com.mbc.vo.PhoneVO;
import com.mbc.vo.UserLoginVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;


/**
 * 用户控制器
 *
 * @author suimeng
 * @date 2024/04/08
 */
@RestController
@RequestMapping("/user")
@Api(tags = "基本用户接口")
@Slf4j
public class UserController {

    @Autowired
    private UserService userService;

    @Autowired
    private JwtProperties jwtProperties;

    /**
     * 微信登录
     *
     * @param userLoginDTO 用户登录 DTO
     * @return {@link Result}<{@link UserLoginVO}>
     */
    @PostMapping("/login")
    @ApiOperation("微信登录")
    public Result<UserLoginVO> login(@RequestBody UserLoginDTO userLoginDTO) {

        //微信登录
        MbcUser user = userService.wxLogin(userLoginDTO);

        //为用户生成jwt令牌
        HashMap<String, Object> claims = new HashMap<>();
        claims.put("Id",user.getId());
        String token = JwtUtil.createJWT(jwtProperties.getUserSecretKey(), jwtProperties.getUserTtl(), claims);
        UserLoginVO userLoginVO = UserLoginVO.builder()
                .Id(user.getId())
                .openId(user.getOpenid())
                .token(token)
                .build();
        return Result.success(userLoginVO);
    }
}

6封装一个HttpClientUtil的工具类

package com.mbc.utils;

import com.alibaba.fastjson.JSONObject;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * Http工具类
 */
public class HttpClientUtil {

    static final  int TIMEOUT_MSEC = 5 * 1000;

    /**
     * 发送GET方式请求
     * @param url
     * @param paramMap
     * @return
     */
    public static String doGet(String url,Map<String,String> paramMap){
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        String result = "";
        CloseableHttpResponse response = null;

        try{
            URIBuilder builder = new URIBuilder(url);
            if(paramMap != null){
                for (String key : paramMap.keySet()) {
                    builder.addParameter(key,paramMap.get(key));
                }
            }
            URI uri = builder.build();

            //创建GET请求
            HttpGet httpGet = new HttpGet(uri);

            //发送请求
            response = httpClient.execute(httpGet);

            //判断响应状态
            if(response.getStatusLine().getStatusCode() == 200){
                result = EntityUtils.toString(response.getEntity(),"UTF-8");
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                response.close();
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return result;
    }

    /**
     * 发送POST方式请求
     * @param url
     * @param paramMap
     * @return
     * @throws IOException
     */
    public static String doPost(String url, Map<String, String> paramMap) throws IOException {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";

        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);

            // 创建参数列表
            if (paramMap != null) {
                List<NameValuePair> paramList = new ArrayList();
                for (Map.Entry<String, String> param : paramMap.entrySet()) {
                    paramList.add(new BasicNameValuePair(param.getKey(), param.getValue()));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
                httpPost.setEntity(entity);
            }

            httpPost.setConfig(builderRequestConfig());

            // 执行http请求
            response = httpClient.execute(httpPost);

            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            throw e;
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }

    /**
     * 发送POST方式请求
     * @param url
     * @param paramMap
     * @return
     * @throws IOException
     */
    public static String doPost4Json(String url, Map<String, String> paramMap) throws IOException {
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";

        try {
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);

            if (paramMap != null) {
                //构造json格式数据
                JSONObject jsonObject = new JSONObject();
                for (Map.Entry<String, String> param : paramMap.entrySet()) {
                    jsonObject.put(param.getKey(),param.getValue());
                }
                StringEntity entity = new StringEntity(jsonObject.toString(),"utf-8");
                //设置请求编码
                entity.setContentEncoding("utf-8");
                //设置数据类型
                entity.setContentType("application/json");
                httpPost.setEntity(entity);
            }

            httpPost.setConfig(builderRequestConfig());

            // 执行http请求
            response = httpClient.execute(httpPost);

            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
        } catch (Exception e) {
            throw e;
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return resultString;
    }
    private static RequestConfig builderRequestConfig() {
        return RequestConfig.custom()
                .setConnectTimeout(TIMEOUT_MSEC)
                .setConnectionRequestTimeout(TIMEOUT_MSEC)
                .setSocketTimeout(TIMEOUT_MSEC).build();
    }

}

这个Java类HttpClientUtil是一个HTTP工具类，使用了Apache HttpClient库来发送HTTP请求。类中定义了三个

公共静态方法，用于发送GET和POST请求。以下是对这三个方法的简要说明：

doGet(String url, Map<String, String> paramMap) 方法：

• 目的：发送GET请求到指定的URL，并且可以包含URL参数。
• 参数：

• • url: 请求的目标URL地址。
  • paramMap: 包含请求参数的Map对象，其键值对代表请求的参数名和参数值。

• 工作流程：

• • 创建CloseableHttpClient实例。
  • 使用URIBuilder来构建带参数的URI实例。
  • 创建HttpGet对象并执行请求。
  • 如果响应状态码为200，则处理响应并将结果转为字符串返回。
  • 最后关闭响应和HttpClient对象。
  • 返回值：HTTP响应的内容体转换成的字符串。

doPost(String url, Map<String, String> paramMap) 方法：

• 目的：发送POST请求到指定的URL，并可以带有form参数。
• 参数：

• • url: 请求的目标URL地址。
  • paramMap: 包含表单参数的Map对象，其键值对代表表单的字段名和字段值。

• 工作流程：

• • 创建CloseableHttpClient实例。
  • 创建HttpPost对象。
  • 如果paramMap非空，构建表单实体UrlEncodedFormEntity并设置到HttpPost对象中。
  • 应用请求配置（超时设置）。
  • 执行请求并获取响应。
  • 将响应内容体转换为字符串。
  • 最后关闭响应。

doPost4Json(String url, Map<String, String> paramMap) 方法：

• 目的：发送POST请求到指定的URL，并可通过JSON格式传参数。
• 参数：

• • url: 请求的目标URL地址。
  • paramMap: 包含参数的Map对象，将被转换成JSON格式发送。

• 工作流程：

• • 创建CloseableHttpClient实例。
  • 创建HttpPost对象。
  • 如果paramMap非空，构建JSON对象，并创建StringEntity。
  • 将JSON字符串转换为StringEntity并设置到HttpPost对象中。
  • 应用请求配置（超时设置）。
  • 执行请求并获取响应。
  • 将响应内容体转换为字符串。
  • 最后关闭响应。

builderRequestConfig() 私有辅助方法：

• 目的：构建一个带有超时设置的RequestConfig对象。
• 说明：设置的超时时间为5秒（5000毫秒）。

整个类的一个关键点是所有的HTTP请求都有相同的统一超时时间设置，避免长时间挂起。需要注意的是，应确保

Map中的键和值都是正确编码的，以防URL构建或是JSON构建出现问题。此外，该类不处理可能抛出的任何异

常，而是将异常抛出给调用方处理，特别是doPost和doPost4Json方法。在实际的应用场景中，可能需要根据具

体业务逻辑，对方法进行相应的异常捕捉和处理。

7写servicerImpl层

package com.mbc.service.impl;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.mbc.config.WeChatProperties;
import com.mbc.dto.UserLoginDTO;
import com.mbc.dto.UserRealNameDTO;
import com.mbc.mapper.UserMapper;
import com.mbc.pojo.MbcUser;
import com.mbc.pojo.MbcUserInfo;
import com.mbc.service.UserService;
import com.mbc.utils.HttpClientUtil;
import com.mbc.vo.MbcUserInfoVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.security.auth.login.LoginException;
import java.time.LocalDateTime;
import java.util.HashMap;

/**
 * 用户服务实现
 *
 * @author suimeng
 * @date 2024/04/08
 */
@Service
public class UserServiceImpl implements UserService {

    //微信服务接口地址
    public static final String WX_LOGIN = "https://api.weixin.qq.com/sns/jscode2session";

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private WeChatProperties weChatProperties;

    /**
     * WX 登录
     *
     * @param userLoginDTO 用户登录 DTO
     * @return {@link MbcUser}
     */
    @Override
    public MbcUser wxLogin(UserLoginDTO userLoginDTO) {
        //调用微信接口服务，获得当前微信用户的openid
        HashMap<String, String> map = new HashMap<>();
        //封装参数
        map.put("appid",weChatProperties.getAppid());
        map.put("secret",weChatProperties.getSecret());
        map.put("js_code",userLoginDTO.getCode());
        map.put("grant_type","authorization_code");
        //调用微信接口服务，获得当前微信用户的openid
        String json = HttpClientUtil.doGet(WX_LOGIN, map);
        //解析json，获得openid
        JSONObject jsonObject = JSON.parseObject(json);
        String openid = jsonObject.getString("openid");
        //判断openid是否为空，如果为空表示登录失败，抛出业务异常
        if(openid == null){
            throw new RuntimeException("微信登录失败");
        }
        //判断当前用户是否为新用户
        MbcUser user = userMapper.getByOpenid(openid);

        //如果是新用户，自动完成注册
        if(user == null){
            user = MbcUser.builder()
                    .openid(openid)
                    .registeredDate(LocalDateTime.now())
                    .build();
            //执行注册操作
            
            userMapper.insert(user);
        }
        //返回这个用户对象
        return user;
    }
}

8.Mapper层和xml

package com.mbc.mapper;


import com.mbc.pojo.MbcUser;
import com.mbc.vo.MbcUserInfoVO;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import java.time.LocalDateTime;

@Mapper
public interface UserMapper {

    /**
     * 根据openid获取用户信息
     *
     * @param openid 微信 openid
     * @return {@link MbcUser}
     */
    @Select("select * from mbc_user where openid = #{openid}")
    MbcUser getByOpenid(String openid);

    /**
     * 插入用户信息
     * @param user
     */
    void insert(MbcUser user);
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mbc.mapper.UserMapper">

  <insert id="insert" parameterType="com.mbc.pojo.MbcUser" keyProperty="id" useGeneratedKeys="true">
    insert into mbc_user (id, user_id, name, openid, code, nickname, cover, register_local, content_permissions, roles, email_checked, superuser, disabled, last_login_date, last_login_ip, login_count, registered_date)
    values (#{id}, #{userId}, #{name}, 000001, #{code}, #{nickname}, #{cover}, #{registerLocal}, #{contentPermissions}, #{roles}, #{emailChecked}, #{superuser}, #{disabled}, #{lastLoginDate}, #{lastLoginIp}, login_count + 1, #{registeredDate})
  </insert>
</mapper>

9.JwtTokenUserInterceptor微信小程序jwt拦截器的实现

package com.mbc.config;

import com.mbc.utils.JwtUtil;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

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

@Component
@Slf4j
public class JwtTokenUserInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtProperties jwtTokenProvider;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //判断当前拦截到的是Controller的方法还是其他资源
        if (!(handler instanceof HandlerMethod)){
            //其他资源直接放行
            return true;
        }
        //1.获取请求头中的token
        String token = request.getHeader(jwtTokenProvider.getUserTokenName());

        //2.令牌校验
        try {
            log.info("jwt校验:{}",token);
            Claims claims = JwtUtil.parseJWT(jwtTokenProvider.getUserSecretKey(), token);
            log.info("id:{}",claims.getId());
            ThreadLocal<Long> longThreadLocal = new ThreadLocal<>();
            //通过claims里面的键值对的类型的键获取值 因为claims里面存的是一个HashMap
            longThreadLocal.set(Long.valueOf(claims.get("id").toString()));
            //通过 放行
            return true;
        } catch (Exception e) {
            //4、不通过，响应401状态码
            response.setStatus(401);
            return false;
        }
    }
}

这段代码是一个拦截器(Interceptor)的实现，其目的是在Spring MVC的请求处理前，检查和验证请求中的JWT令

牌(Token)。以下是对各个部分的详细解释：

@Component:

这个注解标记了JwtTokenUserInterceptor类为Spring容器的组件，意思是它会作为一个bean被Spring管理。

@Autowired:

这个注解被用在JwtProperties类型的jwtTokenProvider变量上，告诉Spring自动注入这个bean，这个bean包含

了JWT令牌的名字和用于签名的密钥。

preHandle方法:

是HandlerInterceptor接口定义的方法之一，这意味着在拦截器链中的当前拦截器之前执行该方法。

• HttpServletRequest request: 表示当前请求
• HttpServletResponse response: 表示当前响应
• Object handler: 表示被拦截的处理器，往往是一个HandlerMethod，表示一个控制器方法

if (!(handler instanceof HandlerMethod)):

这个检查确保了拦截器只关注控制器方法的拦截。如果拦截到的不是控制器方法（可能是静态资源等），那么直接

放行。

String token = request.getHeader(jwtTokenProvider.getUserTokenName()):

从请求头中获取JWT令牌。getUserTokenName()方法似乎返回的是期望的令牌在请求头中所使用的名字。

在try块中

代码使用JwtUtil.parseJWT方法来验证令牌的有效性。如果parseJWT执行成功，它会返回Claims对

象，包含了令牌的有效载荷(Payload)，如用户ID等信息。

ThreadLocal静态成员:

public static ThreadLocal<Long> longThreadLocal = new ThreadLocal<>();：

这个线程本地存储用于在当前执行的线程中存储和传递用户ID。由于每个HTTP请求都是在独立的线程中处理的，

使用ThreadLocal可以确保每个请求的用户ID不会与其他请求混淆。

longThreadLocal.set(...):

将用户ID设置到ThreadLocal实例中。这样后续处理请求的代码可以获取到这个用户ID。

return true:

表示请求通过了JWT验证，并继续执行后面的逻辑（如进入控制器方法）。

catch块

捕捉到异常说明JWT令牌解析失败，有可能是因为令牌无效、过期或篡改。在这种情况下：

• response.setStatus(401): 设置HTTP响应的状态码为401，表示未授权。
• return false: 拦截器返回false，阻止请求继续处理，即不会调用后续的拦截器或控制器方法。

10.WebMvcConfigurationSupport的配置类

package com.mbc.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

@Configuration
public class WebMvcConfiguration extends WebMvcConfigurationSupport {

    @Autowired
    private JwtTokenUserInterceptor jwtTokenUserInterceptor;

    @Bean
    public void addInterceptor(InterceptorRegistry registry){
        registry.addInterceptor(jwtTokenUserInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/user/login");
    }
}

这是一个Spring MVC的配置类，用于向Spring MVC框架注册拦截器。现在我将对这个类做一个详细的解释：

@Configuration:

这个注解表示这个类包含于应用上下文的bean定义。Spring在启动应用时会扫描这个类，并把它里面用@Bean

注解标记的方法返回的对象添加到应用上下文。

继承WebMvcConfigurationSupport:

这个类继承了WebMvcConfigurationSupport。WebMvcConfigurationSupport是Spring MVC提供的一个

类，可以通过覆盖它的方法来自定义Spring MVC的配置。

@Autowired:

这个注解被用于自动装配。Spring会自动找到一个JwtTokenUserInterceptor的bean，并注入到jwtTokenUserInterceptor变量中。

addInterceptor方法:

• 这个方法使用@Bean注解，说明它会创建一个bean，但是注意这里的方法返回类型是void，这是不符合Spring的标准做法的，通常@Bean注解的方法应该返回一个对象，由Spring进行管理。这里应该是示例代码的错误。
• InterceptorRegistry参数是Spring MVC提供的一个用于注册拦截器的类。

• • registry.addInterceptor(jwtTokenUserInterceptor): 这行代码向InterceptorRegistry添加了一个拦截器实例，即我们之前自动装配的jwtTokenUserInterceptor。
  • addPathPatterns("/**"): 这个方法定义了哪些路径应该由拦截器处理，这里的 "/**" 表示应用中的所有路径都会被拦截。
  • excludePathPatterns("/user/login"): 这个方法定义了哪些路径不应该被拦截器处理，例如/user/login这个路径，通常是因为这些路径不需要进行权限校验。

总结来说,这是一个Spring MVC的配置类，它注册了一个自定义的JwtTokenUserInterceptor拦截器，该拦截器将

应用于所有的路径，除了/user/login之外。这样，所有的HTTP请求在达到具体的处理方法之前，都会先经过

JwtTokenUserInterceptor进行处理。

@Configuration

当我们在类上使用@Configuration注解的时候，它意味着这个类可以包含多个被@Bean注解标记的方法，每一

个这样的方法都会返回一个对象（bean），这些对象将被Spring容器管理。

所以，即使类已经被@Configuration注解了，如果你想要Spring容器来处理并管理方法返回的对象，那么该方法

上还是需要添加@Bean注解。每一个带有@Bean注解的方法都会创建一个bean，方法名即为bean的名称（除非

你通过@Bean的name属性指定了其他名称），方法返回的对象类型就是bean的类型。

在你的代码示例中，如果addInterceptor方法的目的是要注册一个bean，那么它的返回类型应该是这个bean的类

型，并且该方法上应该有@Bean注解。但是，如果这个方法仅仅是配置而不是用来定义一个bean，那么它就不应

该有@Bean注解，并且它的返回类型也应该是void。

根据你的代码，addInterceptor方法看起来是为了配置拦截器，而不是定义一个bean。所以，在这种情况下，

addInterceptor方法不应该被标记为@Bean，而且由于它不返回任何对象，所以这里使用@Bean实际上是不正确

的。正确的做法是要覆盖WebMvcConfigurationSupport类中的addInterceptors方法，并且不需要@Bean注

解。