基于SpringBoot+JWT 实现Token登录认证与登录人信息查询功能

<!-- jwt核心依赖：提供token生成、解析的api -->
<dependency>
    <groupid>io.jsonwebtoken</groupid>
    <artifactid>jjwt-api</artifactid>
    <version>0.11.5</version>
</dependency>
<!-- jwt运行时依赖：实现核心api的底层逻辑 -->
<dependency>
    <groupid>io.jsonwebtoken</groupid>
    <artifactid>jjwt-impl</artifactid>
    <version>0.11.5</version>
    <scope>runtime</scope> <!-- 仅运行时生效，编译时不依赖 -->
</dependency>
<!-- jwt json序列化依赖：用于payload中json数据的序列化/反序列化 -->
<dependency>
    <groupid>io.jsonwebtoken</groupid>
    <artifactid>jjwt-jackson</artifactid>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>

jwt:
  secret: "zxcvbnmlkjhgfdsaqwertyuiop123456" # 自定义密钥，长度≥32位，建议生产环境使用更复杂的密钥
  expiration: 7200 # token过期时间（秒），7200秒=2小时

package com.qcby.aischool.util;
import io.jsonwebtoken.jwtexception;
import io.jsonwebtoken.jwts;
import io.jsonwebtoken.signaturealgorithm;
import io.jsonwebtoken.security.keys;
import org.springframework.beans.factory.annotation.value;
import org.springframework.stereotype.component;
import java.security.key;
import java.util.date;
@component // 交给spring管理，支持依赖注入
public class jwtutil {
    // 从配置文件注入token过期时间（秒）
    @value("${jwt.expiration}")
    private long expiration;
    // 从配置文件注入jwt密钥
    @value("${jwt.secret}")
    private string secret;
    /**
     * 生成token（核心方法）
     * @param id 存储在token中的用户标识（如用户id、用户名，本文用用户id）
     * @return 生成的jwt token字符串
     */
    public string generatetoken(string id) {
        // 1. 根据密钥生成加密key（hs256算法要求key为hmacsha256类型）
        key key = keys.hmacshakeyfor(secret.getbytes());
        // 2. 构建token并返回
        return jwts.builder()
                .setsubject(id) // 设置payload：存储用户标识（核心信息）
                .setissuedat(new date()) // 设置签发时间（当前时间）
                // 设置过期时间：当前时间 + 过期时间（秒转毫秒）
                .setexpiration(new date(system.currenttimemillis() + expiration * 1000))
                .signwith(key, signaturealgorithm.hs256) // 设置签名算法和密钥
                .compact(); // 生成最终的token字符串
    }
    /**
     * 解析token，获取存储在payload中的用户标识（如用户id）
     * @param token 客户端传递的token字符串
     * @return 用户标识（本文返回用户id）
     */
    public string getusernamefromtoken(string token) {
        // 1. 生成加密key（与生成token时的密钥一致）
        key key = keys.hmacshakeyfor(secret.getbytes());
        // 2. 解析token，获取payload中的subject（即用户标识）
        return jwts.parserbuilder()
                .setsigningkey(key) // 设置验证签名的密钥
                .build() // 构建解析器
                .parseclaimsjws(token) // 解析token（若token无效，会抛出jwtexception）
                .getbody() // 获取payload部分
                .getsubject(); // 获取subject（用户标识）
    }
    /**
     * 验证token是否有效（核心方法）
     * @param token 客户端传递的token字符串
     * @return true：token有效；false：token无效（签名错误、已过期、格式错误等）
     */
    public boolean validatetoken(string token) {
        try {
            // 1. 生成加密key
            key key = keys.hmacshakeyfor(secret.getbytes());
            // 2. 解析token，若解析成功且未过期，则token有效
            jwts.parserbuilder()
                    .setsigningkey(key)
                    .build()
                    .parseclaimsjws(token);
            return true;
        } catch (jwtexception | illegalargumentexception e) {
            // 捕获异常：jwtexception（token签名错误、已过期等）、illegalargumentexception（token格式错误）
            return false;
        }
    }
}

import org.springframework.beans.factory.annotation.autowired;
import org.springframework.web.bind.annotation.postmapping;
import org.springframework.web.bind.annotation.requestbody;
import org.springframework.web.bind.annotation.responsebody;
import org.springframework.web.bind.annotation.restcontroller;
import java.util.hashmap;
import java.util.list;
import java.util.map;
@restcontroller // 标记为控制器，处理http请求
public class logincontroller {
    // 注入管理员服务（用于查询数据库，验证用户身份，替换为自己项目中的service）
    @autowired
    private administratorservice administratorservice;
    // 注入jwt工具类（用于生成token）
    @autowired
    private jwtutil jwtutil;
    /**
     * 登录接口（客户端提交用户名/密码，获取token）
     * @param user 客户端传递的登录信息（包含用户名、密码，封装为administrator实体类）
     * @return 响应结果（成功返回token，失败返回错误信息）
     */
    @postmapping("/login")
    @responsebody
    public result login(@requestbody administrator user){
        // 1. 验证用户身份：查询数据库，判断用户名/密码是否正确（实际项目中需加密密码后比对）
        list<administrator> users = administratorservice.login(user);
        // 2. 验证通过（查询到唯一用户），生成token
        if (users.size() == 1){
            // 获取登录用户的id，作为token的payload（用户标识）
            string userid = users.get(0).getid().tostring();
            // 调用jwtutil生成token
            string token = jwtutil.generatetoken(userid);
            // 构建响应数据，将token返回给客户端
            map<string,string> data = new hashmap<>();
            data.put("token", token);
            // 返回成功响应（result为自定义响应实体，包含code、msg、data）
            return new result().success(data);
        }else {
            // 验证失败（未查询到用户或查询到多个用户），返回错误信息
            return new result().error("用户名或密码错误");
        }
    }
}

    /**
     * 登录人信息查询接口（需携带token访问）
     * 前端请求路径：/api/user/info（可根据实际需求修改）
     * @param request 请求对象，用于获取拦截器解析后的用户id
     * @return 登录人的完整信息（如管理员信息）
     */
    @getmapping("/info")
    @responsebody
    public result getloginadministratorinfo(httpservletrequest request) {
        system.out.println("进入查询登录人信息的接口");
        // 1. 从request中获取拦截器解析的用户id（拦截器已验证token有效性）
        string id = (string) request.getattribute("id");
        // 2. 根据用户id查询数据库，获取登录人完整信息
        administrator administrator = administratorservice.findadministratorbyid(integer.valueof(id));
        // 3. 返回登录人信息
        return result.success(administrator);
    }

@component
public class jwtinterceptor implements handlerinterceptor {
    @autowired
    private jwtutil jwtutil;
    @override
    public boolean prehandle(httpservletrequest request, httpservletresponse response, object handler) throws exception {
        // 1. 从header中获取token（前端需将token放在authorization中）
        string token = request.getheader("authorization");
        if (token != null && token.startswith("bearer ")) {
            token = token.substring(7); // 去掉"bearer "前缀
        }
        // 2. 验证token
        if (token == null || !jwtutil.validatetoken(token)) {
            response.setstatus(401); // 未授权
            response.setcontenttype("application/json;charset=utf-8");
            response.getwriter().write("{\"code\":401,\"message\":\"token无效或已过期\"}");
            return false;
        }
        // 3. token有效，将用户id存入request属性中
        string userid = jwtutil.getusernamefromtoken(token);
        request.setattribute("id", userid);
        // 4. 继续处理请求
        return true;
    }
}

@configuration
public class webconfig implements webmvcconfigurer {
    @autowired
    private jwtinterceptor jwtinterceptor;
    // 加自定义拦截器jwtinterceptor，设置拦截规则
    @override
    public void addinterceptors(interceptorregistry registry) {
        registry.addinterceptor(jwtinterceptor)
                .addpathpatterns("/**")
                .excludepathpatterns("/administrator/login");  
    }
}