springboot jwt redis實現token刷新

本文轉載自查看原文 2020-08-03 21:38 2565

使用jwt的好處就是，服務器不需要維護，存儲token的狀態。服務器只需要驗證Token是否合法就行。確實省了不少事兒。但是弊端也顯而易見，就是服務器沒法主動讓一個Token失效，並且給Token指定了exp過期時間后，不能修改。

配合redis，就可以輕松的解決上面兩個問題

token的續約
服務器主動失效指定的token

接下來，我會演示一個實現Demo

初始化一個工程

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.3.2.RELEASE</version>
</parent>

<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
	
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
		<exclusions>
			<exclusion>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-starter-tomcat</artifactId>
			</exclusion>
		</exclusions>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-freemarker</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-websocket</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-undertow</artifactId>
	</dependency>
	<!-- redis -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-data-redis</artifactId>
	</dependency>
	<dependency>
		<groupId>org.apache.commons</groupId>
		<artifactId>commons-pool2</artifactId>
	</dependency>
	<!-- jwt -->
	<dependency>
		<groupId>com.auth0</groupId>
		<artifactId>java-jwt</artifactId>
		<version>3.10.3</version>
	</dependency>
</dependencies>

<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
			<configuration>
				<executable>true</executable>
			</configuration>
		</plugin>
	</plugins>
</build>

核心的配置

spring:
  redis:
    database: 0
    host: 127.0.0.1
    port: 6379
    timeout: 2000
    lettuce:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0

jwt:
  key: "springboot"

redis的配置，大家都熟。jwt.key是自定義的一個配置項，它配置的就是jwt用來簽名的key。

Token在Redis中的存儲方式

需要在Redis中緩存用戶的Token，通過自定義一個對象用來描述相關信息。並且這里使用jdk的序列化方式。而不是json。

創建Token的描述對象：UserToken

import java.io.Serializable;
import java.time.LocalDateTime;

public class UserToken implements Serializable {

	private static final long serialVersionUID = 8798594496773855969L;
	// token id
	private String id;
	// 用戶id
	private Integer userId;
	// ip
	private String ip;
	// 客戶端
	private String userAgent;
	// 授權時間
	private LocalDateTime issuedAt;
	// 過期時間
	private LocalDateTime expiresAt;
	// 是否記住我
	private boolean remember;
    // 忽略getter/setter
}

創建：ObjectRedisTemplate

import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

public class ObjectRedisTemplate extends RedisTemplate<String, Object> {
	
	public ObjectRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
		
		this.setConnectionFactory(redisConnectionFactory);
		
		this.setKeySerializer(StringRedisSerializer.UTF_8);
		this.setValueSerializer(new JdkSerializationRedisSerializer());
	}
}

需要配置到IOC

import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

public class ObjectRedisTemplate extends RedisTemplate<String, Object> {
	
	public ObjectRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
		this.setConnectionFactory(redisConnectionFactory);
		// key 使用字符串
		this.setKeySerializer(StringRedisSerializer.UTF_8);
		// value 使用jdk的序列化方式
		this.setValueSerializer(new JdkSerializationRedisSerializer());
	}
}

這里不會涉及太多Redis相關的東西，如果不熟悉，那么你只需要記住ObjectRedisTemplate 的value就是存儲的Java對象。

登錄的實現邏輯

import java.time.Duration;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;

import io.springboot.jwt.domain.User;
import io.springboot.jwt.redis.ObjectRedisTemplate;
import io.springboot.jwt.web.support.UserToken;

@RestController
@RequestMapping("/login")
public class LoginController {
	
	@Autowired
	private ObjectRedisTemplate objectRedisTemplate;
	
	@Value("${jwt.key}")
	private String jwtKey;		// 從配置中讀取到 jwt 的key

	@PostMapping
	public Object login(HttpServletRequest request,
						HttpServletResponse response,
						@RequestParam("account") String account,
						@RequestParam("password") String password,
						@RequestParam(value = "remember", required = false) boolean remember) {

		/**
		 *忽略驗證邏輯，假設用戶已經是登錄成功的狀態，並且他的ID是1 
		 */
		User user = new User(); 
		user.setId(1);
		
		/**
		 * 登錄信息
		 */
		String ip = request.getRemoteAddr();							// 客戶端ip（如果是反向代理，要根據情況獲取實際的ip）
    	String userAgent = request.getHeader(HttpHeaders.USER_AGENT);	// UserAgent
    	
    	// 登錄時間
    	LocalDateTime issuedAt = LocalDateTime.now();
    	
    	
    	// 過期時間，如果是“記住我”，則Token有效期是7天，反之則是半個小時
    	LocalDateTime expiresAt = issuedAt.plusSeconds(remember 
    								? TimeUnit.DAYS.toSeconds(7)
    								: TimeUnit.MINUTES.toSeconds(30));
    	
    	// 距離過期時間剩余的秒數
    	int expiresSeconds = (int) Duration.between(issuedAt, expiresAt).getSeconds();
    	
    	/**
    	 * 存儲Session
    	 */
    	UserToken userToken = new UserToken();
    	// 隨機生成uuid，作為token的id
    	userToken.setId(UUID.randomUUID().toString().replace("-", ""));
    	userToken.setUserId(user.getId());
    	userToken.setIssuedAt(issuedAt);
    	userToken.setExpiresAt(expiresAt);
    	userToken.setRemember(remember);
    	userToken.setUserAgent(userAgent);
    	userToken.setIp(ip);
    	
    	// 序列化Token對象到Redis
    	this.objectRedisTemplate.opsForValue().set("token:" + user.getId(), userToken, expiresSeconds, TimeUnit.SECONDS);
    	
    	/**
    	 * 生成Token信息
    	 */
    	Map<String, Object> jwtHeader = new HashMap <>();
    	jwtHeader.put("alg", "alg");
    	jwtHeader.put("JWT", "JWT");
    	String token = JWT.create()
    			.withHeader(jwtHeader)
    			// 把用戶的id寫入到token
    			.withClaim("id", user.getId())
    			.withIssuedAt(new Date(issuedAt.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli()))
    			/**
    			 * 這里不在Token上設置過期時間，過期時間由Redis維護
    			 */
    			// .withExpiresAt(new Date(expiresAt.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli()))
    			// 使用生成的tokenId作為jwt的id
    			.withJWTId(userToken.getId())
    			.sign(Algorithm.HMAC256(this.jwtKey));

    	/**
    	 * 把Token以Cookie的形式響應客戶端
    	 */
    	Cookie cookie = new Cookie("_token", token);
    	cookie.setSecure(request.isSecure());
    	cookie.setHttpOnly(true);
    	// 非記住我的狀態情況，cookie生命周期設置為-1，瀏覽器關閉后就立即刪除
    	cookie.setMaxAge(remember ? expiresSeconds : -1);
    	cookie.setPath("/");
    	response.addCookie(cookie);
    	
		return Collections.singletonMap("success", true);
	}
}

允許同一個用戶在多出登錄

上述代碼中，存儲Token，使用的是用戶的id作為key，那么任何時候，用戶只能有一個合法的Token。但是有些場景又是允許用戶同時有多個Token，此時可以在redis的key中，添加token的id。

this.objectRedisTemplate.opsForValue().set("token:" + user.getId() + ":" + userToken.getId(), userToken, expiresSeconds, TimeUnit.SECONDS);

如果需要檢索出用戶的所有Token，可以使用Redis的sacnner，進行掃描。

token:{userId}:*

在攔截器中的驗證邏輯

import java.util.concurrent.TimeUnit;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import org.springframework.web.util.WebUtils;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTVerificationException;
import com.auth0.jwt.interfaces.DecodedJWT;

import io.springboot.jwt.redis.ObjectRedisTemplate;
import io.springboot.jwt.web.support.UserToken;

public class TokenValidateInterceptor extends HandlerInterceptorAdapter {

	private static final Logger LOGGER = LoggerFactory.getLogger(TokenValidateInterceptor.class);

	@Autowired
	private ObjectRedisTemplate objectRedisTemplate;

	@Value("${jwt.key}")
	private String jwtKey;

	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

		// 解析 cookie
		Cookie cookie = WebUtils.getCookie(request, "_token");

		if (cookie != null) {

			DecodedJWT decodedJWT = null;

			Integer userId = null;

			try {
				decodedJWT = JWT.require(Algorithm.HMAC256(this.jwtKey)).build().verify(cookie.getValue());
				userId = decodedJWT.getClaim("id").asInt();
			} catch (JWTVerificationException e) {
				LOGGER.warn("解析Token異常：{}，token={}", e.getMessage(), cookie.getValue());
			}

			if (userId != null) {

				String tokenKey = "token:" + userId;

				UserToken userToken = (UserToken) objectRedisTemplate.opsForValue().get(tokenKey);

				if (userToken != null && userToken.getId().equals(decodedJWT.getId()) && userId.equals(userToken.getUserId())) {

					/**
					 * 此時Token是合法的Token，需要進行續約操作
					 */
					this.objectRedisTemplate.expire(tokenKey, userToken.getRemember() 
							? TimeUnit.DAYS.toSeconds(7) 
							: TimeUnit.MINUTES.toSeconds(30),
								TimeUnit.SECONDS);

					//TODO 把當前用戶的身份信息，存儲到當前請求的上下文，以便在Controller中獲取 （例如存儲到：ThreadLocal）
					return true;
				}
			}
		}
		
		/**
		 * 校驗失敗。Token不存在/非法的Token/Token已過期
		 */
		
		// TODO 拋出未登錄異常，在全局處理器中響應客戶端（也可以直接在這里通過Response響應）
		return false;
	}
	
	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)	throws Exception {
		// TODO，需要記得清理存儲到當前請求的上下文中的用戶身份信息
	}
}

很簡單的邏輯，通過Cookie讀取到token，嘗試從Redis中讀取到緩存的數據。進行校驗，如果校驗成功。則刷新Token的過期時間，完成續約。

管理Token

就很簡單了，只需要根據用戶的id，就可以進行刪除/續約操作。服務器可以主動的取消某個Token的授權。
如果需要獲取到全部的Token，那么可以借助sacn，通過指定的前綴進行掃描。

配合Redis的過期key通知事件，還可以在程序中監聽到哪些Token過期了。

原文：https://springboot.io/t/topic/2345

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 SpringBoot整合Shiro、JWT和Redis實現token登錄授權驗證以及token刷新 SpringBoot + SpringSecurity + Mybatis-Plus + JWT + Redis 實現分布式系統認證和授權（刷新Token和Token黑名單） JWT 實現自動刷新登陸token JWT刷新token策略 jwt刷新token SpringBoot集成JWT實現token驗證 SpringBoot集成JWT實現token驗證 SpringBoot集成JWT實現token驗證 SpringBoot集成JWT實現token驗證 SpringBoot集成JWT實現token驗證