skbbs-day5

原创已于 2025-12-26 23:36:46 修改 · 145 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java #mybatis #开发语言

于 2025-12-26 23:36:30 首次发布

第一步：引入必要依赖（Maven）

首先在pom.xml中添加 JWT 和 Redis 依赖（若已引入可忽略）：

<!-- JWT核心依赖 -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>

<!-- Redis依赖（存储验证码） -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

第二步：编写 JWT 工具类（核心）

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.crypto.SecretKey;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * JWT工具类：生成、解析、验证token
 */
@Component
public class JwtUtil {
    // JWT密钥（建议配置在application.yml中，至少32位）
    @Value("${jwt.secret:your-secret-key-32bit-1234567890abcdef}")
    private String secret;

    // token过期时间（单位：秒，示例2小时）
    @Value("${jwt.expire:7200}")
    private long expire;

    // 生成加密密钥
    private SecretKey getSecretKey() {
        return Keys.hmacShaKeyFor(secret.getBytes());
    }

    /**
     * 生成JWT令牌
     * @param userDto 用户信息DTO
     * @return JWT token
     */
    public String generateToken(SessionWebUserDto userDto) {
        // 过期时间
        Date expireDate = new Date(System.currentTimeMillis() + expire * 1000);
        
        // 自定义Claims（存储用户核心信息，避免敏感数据）
        Map<String, Object> claims = new HashMap<>();
        claims.put("userId", userDto.getUserId());
        claims.put("email", userDto.getEmail());
        claims.put("username", userDto.getUsername());

        // 生成token
        return Jwts.builder()
                .setClaims(claims)          // 存入用户信息
                .setIssuedAt(new Date())    // 签发时间
                .setExpiration(expireDate)  // 过期时间
                .signWith(getSecretKey())   // 签名加密
                .compact();
    }

    /**
     * 解析token，获取用户信息
     */
    public Claims parseToken(String token) {
        return Jwts.parserBuilder()
                .setSigningKey(getSecretKey())
                .build()
                .parseClaimsJws(token)
                .getBody();
    }

    /**
     * 验证token是否有效（未过期）
     */
    public boolean isValidToken(String token) {
        try {
            Claims claims = parseToken(token);
            return !claims.getExpiration().before(new Date());
        } catch (Exception e) {
            return false;
        }
    }
}

修改登录接口的代码

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/login")
public class LoginController {

    // 注入Redis模板（替代session存储验证码）
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    // 注入JWT工具类
    @Autowired
    private JwtUtil jwtUtil;

    // 注入用户服务
    @Autowired
    private UserInfoService userInfoService;

    // 验证码Redis存储前缀（可提取为常量类）
    private static final String CHECK_CODE_PREFIX = "login:check_code:";
    // 验证码过期时间（5分钟）
    private static final long CHECK_CODE_EXPIRE_MINUTES = 5;

    @GlobalInterceptor(checkParams = true)
    @PostMapping
    public ResponseVO login(HttpServletRequest request,
                            @VerifyParam(required = true) String email,
                            @VerifyParam(required = true) String password,
                            @VerifyParam(required = true) String checkCode) {
        try {
            // 1. 获取客户端IP（用于Redis存储验证码的key）
            String ip = getIpAddr(request);
            
            // 2. 从Redis获取验证码（替代原session.getAttribute）
            String redisCheckCode = stringRedisTemplate.opsForValue().get(CHECK_CODE_PREFIX + ip);
            if (redisCheckCode == null || !checkCode.equalsIgnoreCase(redisCheckCode)) {
                throw new BusinessException("图片验证码不正确");
            }
            
            // 3. 验证通过后删除验证码（防止重复使用）
            stringRedisTemplate.delete(CHECK_CODE_PREFIX + ip);

            // 4. 调用原有登录逻辑，获取用户信息
            SessionWebUserDto userDto = userInfoService.login(email, password, ip);

            // 5. 生成JWT令牌（核心：替换session.setAttribute）
            String token = jwtUtil.generateToken(userDto);

            // 6. 构造返回结果（返回token+用户信息，供前端存储）
            Map<String, Object> result = new HashMap<>();
            result.put("token", token);
            result.put("userInfo", userDto); // 前端可存储非敏感用户信息

            return getSuccessResponseVO(result);
            
        } catch (BusinessException e) {
            // 业务异常（如验证码错误、账号密码错误）
            return getErrorResponseVO(e.getMessage());
        } catch (Exception e) {
            // 系统异常
            e.printStackTrace();
            return getErrorResponseVO("登录失败，请稍后重试");
        }
    }

    // 保留原有的获取客户端IP方法
    private String getIpAddr(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
    }

    // 保留原有响应结果构造方法（根据你的项目实际实现调整）
    private ResponseVO getSuccessResponseVO(Object data) {
        ResponseVO vo = new ResponseVO();
        vo.setCode(200);
        vo.setMsg("登录成功");
        vo.setData(data);
        return vo;
    }

    private ResponseVO getErrorResponseVO(String msg) {
        ResponseVO vo = new ResponseVO();
        vo.setCode(500);
        vo.setMsg(msg);
        return vo;
    }
}

前端登录成功之后

// 登录成功后存储token
localStorage.setItem("token", res.data.token);

// 请求拦截器携带token
axios.interceptors.request.use(config => {
  const token = localStorage.getItem("token");
  if (token) {
    config.headers["Authorization"] = "Bearer " + token;
  }
  return config;
});

最后

你希望在除登录外的其他业务接口中验证前端传递的 JWT token 是否有效（包括签名正确、未过期），并解析 token 中的用户信息供接口使用。最优雅且高效的方式是通过SpringMVC 拦截器实现全局 token 验证（避免每个接口重复写验证逻辑），以下是完整的实现方案：

核心验证思路

前端请求时，在 HTTP 请求头中携带 token（格式：Authorization: Bearer {token}）；
后端通过拦截器统一拦截请求，提取并验证 token；
验证通过：解析 token 中的用户信息，存入ThreadLocal（方便接口直接获取），放行请求；
验证失败：返回 401 未授权错误，拒绝请求。

第一步：封装 ThreadLocal 工具类（存储当前请求的用户信息）

ThreadLocal可以在当前请求线程中共享用户信息，避免通过HttpServletRequest传递，更优雅：

import com.xxx.dto.SessionWebUserDto; // 替换为你的用户DTO类

/**
 * 线程本地存储工具类：存储当前请求的用户信息
 */
public class UserContextHolder {
    // 私有化构造器，禁止实例化
    private UserContextHolder() {}

    // 存储用户信息的ThreadLocal
    private static final ThreadLocal<SessionWebUserDto> USER_THREAD_LOCAL = new ThreadLocal<>();

    /**
     * 设置当前线程的用户信息
     */
    public static void setUser(SessionWebUserDto userDto) {
        USER_THREAD_LOCAL.set(userDto);
    }

    /**
     * 获取当前线程的用户信息
     */
    public static SessionWebUserDto getUser() {
        return USER_THREAD_LOCAL.get();
    }

    /**
     * 移除当前线程的用户信息（防止内存泄漏）
     */
    public static void clear() {
        USER_THREAD_LOCAL.remove();
    }
}

第二步：实现 JWT 拦截器（核心验证逻辑）

拦截所有请求，验证 token 有效性，并解析用户信息存入ThreadLocal：

import io.jsonwebtoken.Claims;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;

@Component
public class JwtAuthInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtUtil jwtUtil; // 复用之前的JWT工具类

    /**
     * 请求处理前验证token（核心方法）
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1. 从请求头获取token（格式：Bearer {token}）
        String authHeader = request.getHeader("Authorization");
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            // 无token，返回401错误
            return handleUnauthorized(response, "未携带有效token");
        }

        // 提取纯token（去掉"Bearer "前缀）
        String token = authHeader.substring(7);

        // 2. 验证token有效性（签名正确 + 未过期）
        if (!jwtUtil.isValidToken(token)) {
            return handleUnauthorized(response, "token无效或已过期");
        }

        // 3. 解析token中的用户信息
        Claims claims = jwtUtil.parseToken(token);
        // 构造用户DTO（根据你的SessionWebUserDto字段调整）
        SessionWebUserDto userDto = new SessionWebUserDto();
        userDto.setUserId((Long) claims.get("userId"));
        userDto.setEmail((String) claims.get("email"));
        userDto.setUsername((String) claims.get("username"));

        // 4. 将用户信息存入ThreadLocal，供后续接口使用
        UserContextHolder.setUser(userDto);

        // 5. 验证通过，放行请求
        return true;
    }

    /**
     * 请求处理完成后，清除ThreadLocal中的用户信息（防止内存泄漏）
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserContextHolder.clear();
    }

    /**
     * 处理未授权错误，返回统一JSON响应
     */
    private boolean handleUnauthorized(HttpServletResponse response, String msg) throws Exception {
        response.setContentType("application/json;charset=UTF-8");
        response.setStatus(HttpStatus.UNAUTHORIZED.value()); // 401状态码
        PrintWriter writer = response.getWriter();
        // 构造统一错误响应（匹配你的ResponseVO格式）
        writer.write("{\"code\":401,\"msg\":\"" + msg + "\",\"data\":null}");
        writer.flush();
        writer.close();
        return false; // 拒绝请求
    }
}

第三步：配置拦截器（指定拦截 / 排除路径）

通过配置类注册拦截器，指定需要验证 token 的接口路径，排除登录、验证码等无需验证的接口：

import org.springframework.beans.factory.annotation.Autowired;
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 WebMvcConfig implements WebMvcConfigurer {

    @Autowired
    private JwtAuthInterceptor jwtAuthInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(jwtAuthInterceptor)
                .addPathPatterns("/**") // 拦截所有路径
                .excludePathPatterns(   // 排除无需验证的路径
                        "/login",        // 登录接口
                        "/captcha",      // 验证码接口
                        "/error",        // 错误页面
                        "/static/**"     // 静态资源
                );
    }
}

在业务接口中使用保存的信息

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/station")
public class StationController {

    /**
     * 示例接口：获取当前登录用户的电站列表（需验证token）
     */
    @GetMapping("/list")
    public ResponseVO getStationList() {
        // 从ThreadLocal获取当前登录用户信息（拦截器已验证并存储）
        SessionWebUserDto currentUser = UserContextHolder.getUser();
        Long userId = currentUser.getUserId();
        String email = currentUser.getEmail();

        // 业务逻辑：根据userId查询电站列表
        // List<StationDto> stationList = stationService.getByUserId(userId);

        return getSuccessResponseVO("当前登录用户：" + email + "，用户ID：" + userId);
    }

    // 复用统一的响应构造方法
    private ResponseVO getSuccessResponseVO(Object data) {
        ResponseVO vo = new ResponseVO();
        vo.setCode(200);
        vo.setMsg("操作成功");
        vo.setData(data);
        return vo;
    }
}