JWT整合springboot自定義定時更換秘鑰方式

更新時間：2025年11月18日 08:53:20 作者：騎豬少年

文章介紹了JWT（ JSON Web Token）的基本概念、結(jié)構(gòu)和使用場景,并重點講解了在Spring Boot中自定義定時更換JWT秘鑰的過程,通過定義用戶信息類、JWT工具類、配置攔截器和定時修改秘鑰工具類,實現(xiàn)了一個基本的JWT認(rèn)證和密鑰管理機制

JWT整合springboot自定義定時更換秘鑰

jwt概要：

JWT（JSON WEB TOKEN）：JSON網(wǎng)絡(luò)令牌，JWT是一個輕便的安全跨平臺傳輸格式，定義了一個緊湊的自包含的方式在不同實體之間安全傳輸信息（JSON格式）。

它是在Web環(huán)境下兩個實體之間傳輸數(shù)據(jù)的一項標(biāo)準(zhǔn)。實際上傳輸?shù)木褪且粋€字符串。廣義上講JWT是一個標(biāo)準(zhǔn)的名稱；狹義上JWT指的就是用來傳遞的那個token字符串。

jwt是一種無狀態(tài)token，可用于oss單點登錄

JWT的數(shù)據(jù)結(jié)構(gòu)以及簽發(fā)的過程

JWT由三部分構(gòu)成：header（頭部）、payload（載荷）和signature（簽名）。

Header 頭部信息：指定類型和算法
Payload 荷載信息：存放Claims聲明信息
Signature簽名：把前兩者對應(yīng)的Json結(jié)構(gòu)進行base64url編碼之后的字符串拼接起來和密鑰放一起加密后的簽名組成方式為header.payload.signature

Header的結(jié)構(gòu)

type 聲明類型
algorithm 聲明加密算法
格式： {“typ”: “JWT”,“alg”: “HS256”}

payload的結(jié)構(gòu)

聲明信息
payload用來承載要傳遞的數(shù)據(jù)，它的json結(jié)構(gòu)實際上是對JWT要傳遞的數(shù)據(jù)的聲明，這些聲明被JWT標(biāo)準(zhǔn)稱為claims（聲明），它的每個屬性鍵值對其實就是一個claim，JWT常用的有兩種聲明，一種是
Reserved claims（保留聲明），也就是JWT規(guī)定的標(biāo)準(zhǔn)聲明。
一種是Private claims（自定義聲明），我們在這里定義要傳遞的信息
還有一種是public claims（公共聲明），這個目前沒用到。

標(biāo)準(zhǔn)聲明（JWT保留聲明）

iss(Issuser)：代表這個JWT的簽發(fā)主體；
sub(Subject)：代表這個JWT的主體，即它的所有人；
aud(Audience)：代表這個JWT的接收對象；
exp(Expiration time)：是一個時間戳，代表這個JWT的過期時間；
nbf(Not Before)：是一個時間戳，代表這個JWT生效的開始時間，意味著在這個時間之前驗證JWT是會失敗的；
iat(Issuedat)：是一個時間戳，代表這個JWT的簽發(fā)時間； jti(JWT ID)：是JWT的唯一標(biāo)識。

signature

簽名
把header和payload對應(yīng)的json結(jié)構(gòu)進行base64url編碼之后得到的字符串用點號拼接起來，然后根據(jù)header里面alg指定的簽名算法生成出來的，然后添加自己設(shè)定的key進行加密簽名

java代碼實現(xiàn)

maven依賴

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

定義一個用戶信息類，存放一些用戶基本信息（如用戶名、權(quán)限（可進行菜單鑒權(quán)））

/**
 * @author : ljt
 * @version V1.0
 * @Description: 用戶信息
 * @date Date : 2021年08月06日 13:56
 */
@Data
public class UserLoginBO {
    /**
     * 用戶id
     */
    private Long id;
    /**
     * 用戶名
     */
    private String userName;
    /**
     * 用戶昵稱
     */
    private String nickName;
    /**
     * 用戶真實姓名
     */
    private String realName;

    /**
     * 用戶openid
     */
    private String openId;
    /**
     * 用戶token
     */
    private String accessToken;

}

JWT工具類：

/**
 * @author : ljt
 * @version V1.0
 * @Description: jwt工具類
 * @date Date : 2021年08月06日 13:22
 */
@Component
public class JwtTokenUtil {

    /**
     * jwt生成token秘鑰，此處動態(tài)更新所以為空，可隨便自定義
     */
    public static String TOKEN_SECRET = "";

    /**
     * 定義token有效期 秒
     */
    public static Integer tokenExpiration=1800;

    /**
     * 生成token
     * @param subject  用戶名
     * @param claims 用戶信息
     * @return token字符串
     */
    public static String generateToken(String subject, Map<String, Object> claims) {
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(subject)
                .setId(UUID.randomUUID().toString())
                .setIssuedAt(new Date())
                .setExpiration(generateExpirationDate(tokenExpiration))
                .compressWith(CompressionCodecs.DEFLATE)
                .signWith(SignatureAlgorithm.HS256, TOKEN_SECRET)
                .compact();
    }

    /***
     * 解析token 信息
     * @param token token字符串
     * @return 用戶map信息
     */
    private static Claims getClaimsFromToken(String token) {
        Claims claims;
        try {
            claims = Jwts.parser()
                    .setSigningKey(TOKEN_SECRET)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            claims = null;
        }
        return claims;
    }


    /**
     * 生成失效時間
     * @param expiration 失效時長
     * @return 到期時間 時間格式
     */
    private static Date generateExpirationDate(long expiration) {
        return new Date(System.currentTimeMillis() + expiration * 1000);
    }

    /**
     * 根據(jù)token 獲取用戶信息
     * @param token token
     * @return 自定義的用戶對象
     */
    public static UserLoginBO getUserFromToken(String token) {
        UserLoginBO userDetail;
        try {
            final Claims claims = getClaimsFromToken(token);
            userDetail = new UserLoginBO();
            userDetail.setId(Long.parseLong(claims.get("id").toString()));
            userDetail.setUserName(String.valueOf(claims.get("userName")));
            userDetail.setNickName(String.valueOf(claims.get("nickName")));
            userDetail.setRealName(String.valueOf(claims.get("UserName")));
            userDetail.setOpenId(String.valueOf(claims.get("openId")));
        } catch (Exception e) {
            userDetail = null;
        }
        return userDetail;
    }

    /**
     * 根據(jù)token 獲取用戶ID
     * 和獲取用戶信息一致 此處新定義一個方法是用著方便
     * @param token token
     * @return 返回用戶id
     */
    private Long getUserIdFromToken(String token) {
        Long userId;
        try {
            final Claims claims = getClaimsFromToken(token);
            userId = Long.parseLong(claims.get("id").toString());
        } catch (Exception e) {
            userId = 0L;
        }
        return userId;
    }
    /**
     * 根據(jù)token 獲取用戶名
     * 和獲取用戶信息一致 此處新定義一個方法是用著方便
     * @param token token字符串
     * @return 用戶昵稱
     */
    public static String getUsernameFromToken(String token) {
        String username;
        try {
            final Claims claims = getClaimsFromToken(token);
            username = claims.getSubject();
        } catch (Exception e) {
            username = null;
        }
        return username;
    }

    /**
     * 刷新token
     *
     * @param token 原token
     * @return 新token
     */
    public static String refreshToken(String token,Integer tokenExpiration) {
        String refreshedToken;
        try {
            final Claims claims = getClaimsFromToken(token);
            refreshedToken = generateToken(claims.getSubject(), claims,tokenExpiration);
        } catch (Exception e) {
            refreshedToken = null;
        }
        return refreshedToken;
    }

    /**
     * 根據(jù)token 獲取生成時間
     * @param token token字符串
     * @return 時間
     */
    public Date getCreatedDateFromToken(String token) {
        Date created;
        try {
            final Claims claims = getClaimsFromToken(token);
            created = claims.getIssuedAt();
        } catch (Exception e) {
            created = null;
        }
        return created;
    }

    /**
     * 根據(jù)token 獲取過期時間
     * @param token token
     * @return 時間
     */
    public static Date getExpirationDateFromToken(String token) {
        Date expiration;
        try {
            final Claims claims = getClaimsFromToken(token);
            expiration = claims.getExpiration();
        } catch (Exception e) {
            expiration = null;
        }
        return expiration;
    }


    /**
     * 驗證token 是否合法
     * @param token  token
     * @param userDetail  用戶信息
     * @return true 或 false
     */
    public boolean validateToken(String token, UserLoginBO userDetail) {
        final long userId = getUserIdFromToken(token);
        final String username = getUsernameFromToken(token);
        return (userId == userDetail.getId()
                && username.equals(userDetail.getUserName())
                && !isTokenExpired(token)
        );
    }

    /**
     * 判斷令牌是否過期
     * @param token 令牌
     * @return 是否過期
     */
    public static Boolean isTokenExpired(String token) {
        final Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }



}

配置攔截器：

@Slf4j
public class LoginInterceptor extends HandlerInterceptorAdapter {

    /**
     * token剩余過期時間
     * 此處設(shè)定剩余到期時間自動刷新token
     * 根據(jù)需要手動編輯刷新token接口
     */
    private final Long TOKEN_DATE = 5*60*1000L;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //token約定放置在請求頭中以access_token的方式發(fā)送
        String token = request.getHeader("access_token");
        log.debug("用戶請求鑒權(quán)token = {}", token);
        //判斷token是否存在 不存在無權(quán)限 直接返回
        if(StringUtils.isNotEmpty(token))   {
            //工具類 直接獲取用戶信息
            UserLoginBO userFromToken = JwtTokenUtil.getUserFromToken(token);
            //獲取不到 用戶授權(quán)過期 直接返回
            if (userFromToken != null && !JwtTokenUtil.isTokenExpired(token)) {
                //TODO 能正常獲取用戶信息 可判斷用戶信息是否一致 一致則鑒權(quán)成功 這里我懶省事
              
                //判斷token剩余過期時間 將過期自動簽發(fā)新token 以response方式返回
                if ( JwtTokenUtil.getExpirationDateFromToken(token).getTime() - System.currentTimeMillis() < TOKEN_DATE ){
                    String refreshToken = JwtTokenUtil.refreshToken(token,JwtTokenUtil.tokenExpiration);
                    Object value = CacheUtil.getInstance().getValue(token);
                    CacheUtil.getInstance().putValue(refreshToken,value, CacheConstant.PERMS_INFO);
                    response.setContentType("text/html; charset=UTF-8");
                    Map<String,String> map = new HashMap<>(16);
                    map.put("accessToken",refreshToken);
                    response.setHeader("access_token",refreshToken);
                }
                return true;
            }
        }
        response.setContentType("text/html; charset=UTF-8");
        ResponseBO responseBO = new ResponseBO();
        responseBO.setCode(ResponseCode.L001.getCode());
        responseBO.setMsg(ResponseCode.L001.getTitle());
        response.getWriter().write(JSONObject.toJSONString(responseBO));
        return false;
    }
}

注冊攔截器，定義攔截規(guī)則

@Configuration
public class AuthConfigurer extends WebMvcConfigurationSupport {
    /**
     * 攔截器注入
     */
    @Bean
    public LoginInterceptor loginInterceptor() {
        return new LoginInterceptor();
    }

    /**
     * 添加攔截
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry
         		//注冊攔截器 定義攔截接口
        		.addInterceptor(loginInterceptor()).addPathPatterns("/**")
                // 排除登錄接口攔截
                .excludePathPatterns("/user/login")
        super.addInterceptors(registry);
    }


    /**
     * 替換Spring默認(rèn)JSON轉(zhuǎn)換器為fastjson
     * @param converters
     */
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        super.configureMessageConverters(converters);
        FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
        FastJsonConfig fastJsonConfig = new FastJsonConfig();
        fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);
        fastJsonConfig.setSerializerFeatures(SerializerFeature.DisableCircularReferenceDetect);
        fastConverter.setFastJsonConfig(fastJsonConfig);
        converters.add(fastConverter);

    }

   
    /**
     * 發(fā)現(xiàn)如果繼承了WebMvcConfigurationSupport，則在yml中配置的相關(guān)內(nèi)容會失效。 需要重新指定靜態(tài)資源
     *
     * @param registry
     */
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {

        //將所有/static/** 訪問都映射到classpath:/static/ 目錄下
        registry.addResourceHandler("/static/**").addResourceLocations("classpath:/static/");
        registry.addResourceHandler("/templates/**").addResourceLocations("classpath:/templates/");
        registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");

    }


    /**
     * 配置servlet處理
     */
    @Override
    public void configureDefaultServletHandling(
            DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}

生成JWT秘鑰工具類：

/**
 * @author : ljt
 * @version V1.0
 * @Description: 生成JWT秘鑰
 * @date Date : 2021年11月25日 15:34
 */
@Slf4j
public class CreateJWTKeyUtil {
	//生成60位秘鑰串
    public static String createJwtKey(){
        String str="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+<>?:,|./;'";
        Random random=new Random();
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<60;i++){
            int number=random.nextInt(84);
            sb.append(str.charAt(number));
        }
        log.info("key====" + sb.toString());
        return sb.toString();
    }
}

定時修改JWT秘鑰：

/**
 * @author : ljt
 * @version V1.0
 * @Description: 定時修改jwtkey
 * @date Date : 2021年11月25日 15:43
 */
@Component
public class CreateJWTKey {

    /**
     * jwt秘鑰存儲，可選擇mysql、redis
     */
   @Autowired
   private IJwtKeyService jwtKeyService;

    /**
     * 可自定義更換周期
     * 注意：秘鑰更換后，已簽發(fā)token將無法解密，返回結(jié)果為token失效，需要重新簽發(fā)
     */
    @Scheduled(cron = "0 0 0 1/7 * ?")
    public void createJtw(){
        //獲取新秘鑰
        String jwtKey = CreateJWTKeyUtil.createJwtKey();
        //秘鑰存儲修改
        jwtKeyService.updateJwtKey(jwtKey);
        //秘鑰靜態(tài)變量修改 可減少實現(xiàn)層查詢次數(shù) 直接使用靜態(tài)數(shù)據(jù)
        JwtTokenUtil.TOKEN_SECRET = jwtKey;
    }
}

項目啟動時獲取秘鑰：

@Component
public class ApplicationRunnerImplConfig implements ApplicationRunner {

    @Autowired
    private IJwtKeyService jwtKeyService;

    /**
     * 項目啟動獲取jwt秘鑰
     * @param args
     * @throws Exception
     */
    @Override
    public void run(ApplicationArguments args) throws Exception {
    	//從存儲庫中獲取秘鑰
        JwtTokenUtil.TOKEN_SECRET = jwtKeyService.findJwtKey();
    }
}

使用示例：登錄成功后返回token

Map<String, Object> map = new HashMap<>(16);
map.put("id",login.getId());
map.put("userName",login.getUserName());
map.put("nickName",login.getNickName());
map.put("realName",login.getRealName());
String token = JwtTokenUtil.generateToken("user", map,JwtTokenUtil.userTokenExpiration);
login.setAccessToken(token);

return login;