SpringBoot + SpringSecurity + Mybatis-Plus + JWT + Redis 实现分布式系统认证和授权（刷新Token和Token黑名单）...

最新推荐文章于 2024-10-10 11:37:29 发布
最新推荐文章于 2024-10-10 11:37:29 发布
阅读量1.1k 收藏 17
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48008521/article/details/107374580
版权
1. 前提

  本文在基于SpringBoot整合SpringSecurity实现JWT的前提中添加刷新Token以及添加Token黑名单。在浏览之前，请查看博客：
  SpringBoot + SpringSecurity + Mybatis-Plus + JWT实现分布式系统认证和授权

2. 添加Redis依赖及配置
<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.c3stones</groupId>
	<artifactId>spring-security-jwt-redis-demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>spring-security-jwt-redis-demo</name>
	<description>Spring Boot + Srping Security + Mybatis-Plus + JWT + Redis Demo</description>

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

	<properties>
		<java.version>1.8</java.version>
		<jjwt.version>0.9.0</jjwt.version>
		<druid.version>1.1.6</druid.version>
		<jwt.version>1.0.9.RELEASE</jwt.version>
		<fastjson.version>1.2.45</fastjson.version>
		<mybatis-plus.version>3.3.1</mybatis-plus.version>
		<maven-jar-plugin.version>3.1.1</maven-jar-plugin.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<!--Spring Security依赖 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-security</artifactId>
		</dependency>

		<!-- Mybatis-Plus 依赖 -->
		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-boot-starter</artifactId>
			<version>${mybatis-plus.version}</version>
		</dependency>

		<!-- Druid 连接池 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid</artifactId>
			<version>${druid.version}</version>
		</dependency>

		<!-- StringUtils 工具 -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
		</dependency>

		<!-- JSON工具 -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>${fastjson.version}</version>
		</dependency>

		<!-- JWT依赖 -->
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-jwt</artifactId>
			<version>${jwt.version}</version>
		</dependency>
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt</artifactId>
			<version>${jjwt.version}</version>
		</dependency>

		<!-- Redis依赖 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
	</dependencies>

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

</project>
  • 修改application.yml，添加Redis配置及刷新时间配置
server:
   port: 8080
   
spring:
   datasource:
      type: com.alibaba.druid.pool.DruidDataSource
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://127.0.0.1:3306/security?useSSL=false&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull
      username: root
      password: 123456
   redis:
      host: 127.0.0.1
      port: 6379
      password: 123456
      
# JWT配置
jwt:
   # 密匙Key
   secret: JWTSecret,C3Stones
   # HeaderKey
   tokenHeader: Authorization
   # Token前缀
   tokenPrefix: Bearer
   # 过期时间，单位秒
   expiration: 300
   # 刷新时间，单位天
   refreshTime: 7
   # 配置白名单（不需要认证）
   antMatchers: /login/**,/register/**,/static/**
   
# Mybatis-plus配置
mybatis-plus:
   mapper-locations: classpath:mapper/*.xml
   global-config:
      db-config:
         id-type: AUTO
   configuration:
      # 打印sql
      log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  • 添加Redis工具类
import java.util.HashMap;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import javax.annotation.PostConstruct;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

/**
 * Redis工具类
 * 
 * @author CL
 *
 */
@Component
public class RedisUtils {

	@Autowired
	private StringRedisTemplate redisTemplate;

	private static RedisUtils redisUtils;

	/**
	 * 初始化
	 */
	@PostConstruct
	public void init() {
		redisUtils = this;
		redisUtils.redisTemplate = this.redisTemplate;
	}

	/**
	 * 查询key，支持模糊查询
	 *
	 * @param key
	 */
	public static Set<String> keys(String key) {
		return redisUtils.redisTemplate.keys(key);
	}

	/**
	 * 获取值
	 * 
	 * @param key
	 */
	public static Object get(String key) {
		return redisUtils.redisTemplate.opsForValue().get(key);
	}

	/**
	 * 设置值
	 * 
	 * @param key
	 * @param value
	 */
	public static void set(String key, String value) {
		redisUtils.redisTemplate.opsForValue().set(key, value);
	}

	/**
	 * 设置值，并设置过期时间
	 * 
	 * @param key
	 * @param value
	 * @param expire 过期时间，单位秒
	 */
	public static void set(String key, String value, Integer expire) {
		redisUtils.redisTemplate.opsForValue().set(key, value, expire, TimeUnit.SECONDS);
	}

	/**
	 * 删出key
	 * 
	 * @param key
	 */
	public static void delete(String key) {
		redisUtils.redisTemplate.opsForValue().getOperations().delete(key);
	}

	/**
	 * 设置对象
	 * 
	 * @param key     key
	 * @param hashKey hashKey
	 * @param object  对象
	 */
	public static void hset(String key, String hashKey, Object object) {
		redisUtils.redisTemplate.opsForHash().put(key, hashKey, object);
	}

	/**
	 * 设置对象
	 * 
	 * @param key     key
	 * @param hashKey hashKey
	 * @param object  对象
	 * @param expire  过期时间，单位秒
	 */
	public static void hset(String key, String hashKey, Object object, Integer expire) {
		redisUtils.redisTemplate.opsForHash().put(key, hashKey, object);
		redisUtils.redisTemplate.expire(key, expire, TimeUnit.SECONDS);
	}

	/**
	 * 设置HashMap
	 *
	 * @param key key
	 * @param map map值
	 */
	public static void hset(String key, HashMap<String, Object> map) {
		redisUtils.redisTemplate.opsForHash().putAll(key, map);
	}

	/**
	 * key不存在时设置值
	 * 
	 * @param key
	 * @param hashKey
	 * @param object
	 */
	public static void hsetAbsent(String key, String hashKey, Object object) {
		redisUtils.redisTemplate.opsForHash().putIfAbsent(key, hashKey, object);
	}

	/**
	 * 获取Hash值
	 *
	 * @param key
	 * @param hashKey
	 * @return
	 */
	public static Object hget(String key, String hashKey) {
		return redisUtils.redisTemplate.opsForHash().get(key, hashKey);
	}

	/**
	 * 获取key的所有值
	 *
	 * @param key
	 * @return
	 */
	public static Object hget(String key) {
		return redisUtils.redisTemplate.opsForHash().entries(key);
	}

	/**
	 * 删除key的所有值
	 *
	 * @param key
	 */
	public static void deleteKey(String key) {
		redisUtils.redisTemplate.opsForHash().getOperations().delete(key);
	}

	/**
	 * 判断key下是否有值
	 *
	 * @param key
	 */
	public static Boolean hasKey(String key) {
		return redisUtils.redisTemplate.opsForHash().getOperations().hasKey(key);
	}

	/**
	 * 判断key和hasKey下是否有值
	 *
	 * @param key
	 * @param hasKey
	 */
	public static Boolean hasKey(String key, String hasKey) {
		return redisUtils.redisTemplate.opsForHash().hasKey(key, hasKey);
	}

}
  • 添加获取请求IP地址工具类
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

/**
 * 获取请求IP地址工具类
 * 
 * @author CL
 *
 */
@Component
public class AccessAddressUtils {

	/**
	 * 获取用户真实IP地址
	 * 
	 * @param request
	 * @return
	 */
	public static String getIpAddress(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.getHeader("HTTP_CLIENT_IP");
		}
		if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getHeader("HTTP_X_FORWARDED_FOR");
		}
		if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
			ip = request.getRemoteAddr();
		}
		return ip;
	}
}
3. 核心类修改
  • 修改JWT配置类，并添加刷新时间属性
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * JWT配置基础类
 * 
 * @author CL
 *
 */
@Component
@ConfigurationProperties(prefix = "jwt")
@SuppressWarnings("static-access")
public class JWTConfig {

	/**
	 * 密匙Key
	 */
	public static String secret;

	/**
	 * HeaderKey
	 */
	public static String tokenHeader;

	/**
	 * Token前缀
	 */
	public static String tokenPrefix;

	/**
	 * 过期时间
	 */
	public static Integer expiration;

	/**
	 * 有效时间
	 */
	public static Integer refreshTime;

	/**
	 * 配置白名单
	 */
	public static String antMatchers;

	/**
	 * 将过期时间单位换算成毫秒
	 * 
	 * @param expiration 过期时间，单位秒
	 */
	public void setExpiration(Integer expiration) {
		this.expiration = expiration * 1000;
	}

	/**
	 * 将有效时间单位换算成毫秒
	 * 
	 * @param validTime 有效时间，单位秒
	 */
	public void setRefreshTime(Integer refreshTime) {
		this.refreshTime = refreshTime * 24 * 60 * 60 * 1000;
	}

	public void setSecret(String secret) {
		this.secret = secret;
	}

	public void setTokenHeader(String tokenHeader) {
		this.tokenHeader = tokenHeader;
	}

	public void setTokenPrefix(String tokenPrefix) {
		this.tokenPrefix = tokenPrefix + " ";
	}

	public void setAntMatchers(String antMatchers) {
		this.antMatchers = antMatchers;
	}

}
  • 修改JWTToken工具类
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.PostConstruct;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.c3stones.security.config.JWTConfig;
import com.c3stones.security.entity.SysUserDetails;
import com.c3stones.security.service.SysUserDetailsService;
import com.c3stones.utils.RedisUtils;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.extern.slf4j.Slf4j;

/**
 * JWT生产Token工具类
 * 
 * @author CL
 *
 */
@Slf4j
@Component
public class JWTTokenUtils {
	/**
	 * 时间格式化
	 */
	private static final DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

	@Autowired
	private SysUserDetailsService sysUserDetailsService;

	private static JWTTokenUtils jwtTokenUtils;

	@PostConstruct
	public void init() {
		jwtTokenUtils = this;
		jwtTokenUtils.sysUserDetailsService = this.sysUserDetailsService;
	}

	/**
	 * 创建Token
	 * 
	 * @param sysUserDetails 用户信息
	 * @return
	 */
	public static String createAccessToken(SysUserDetails sysUserDetails) {
		String token = Jwts.builder()// 设置JWT
				.setId(sysUserDetails.getId().toString()) // 用户Id
				.setSubject(sysUserDetails.getUsername()) // 主题
				.setIssuedAt(new Date()) // 签发时间
				.setIssuer("C3Stones") // 签发者
				.setExpiration(new Date(System.currentTimeMillis() + JWTConfig.expiration)) // 过期时间
				.signWith(SignatureAlgorithm.HS512, JWTConfig.secret) // 签名算法、密钥
				.claim("authorities", JSON.toJSONString(sysUserDetails.getAuthorities()))// 自定义其他属性，如用户组织机构ID，用户所拥有的角色，用户权限信息等
				.claim("ip", sysUserDetails.getIp()).compact();
		return JWTConfig.tokenPrefix + token;
	}

	/**
	 * 刷新Token
	 * 
	 * @param oldToken 过期但未超过刷新时间的Token
	 * @return
	 */
	public static String refreshAccessToken(String oldToken) {
		String username = JWTTokenUtils.getUserNameByToken(oldToken);
		SysUserDetails sysUserDetails = (SysUserDetails) jwtTokenUtils.sysUserDetailsService
				.loadUserByUsername(username);
		sysUserDetails.setIp(JWTTokenUtils.getIpByToken(oldToken));
		return createAccessToken(sysUserDetails);
	}

	/**
	 * 解析Token
	 * 
	 * @param token Token信息
	 * @return
	 */
	public static SysUserDetails parseAccessToken(String token) {
		SysUserDetails sysUserDetails = null;
		if (StringUtils.isNotEmpty(token)) {
			try {
				// 去除JWT前缀
				token = token.substring(JWTConfig.tokenPrefix.length());

				// 解析Token
				Claims claims = Jwts.parser().setSigningKey(JWTConfig.secret).parseClaimsJws(token).getBody();

				// 获取用户信息
				sysUserDetails = new SysUserDetails();
				sysUserDetails.setId(Long.parseLong(claims.getId()));
				sysUserDetails.setUsername(claims.getSubject());

				// 获取角色
				Set<GrantedAuthority> authorities = new HashSet<GrantedAuthority>();
				String authority = claims.get("authorities").toString();
				if (StringUtils.isNotEmpty(authority)) {
					List<Map<String, String>> authorityList = JSON.parseObject(authority,
							new TypeReference<List<Map<String, String>>>() {
							});
					for (Map<String, String> role : authorityList) {
						if (!role.isEmpty()) {
							authorities.add(new SimpleGrantedAuthority(role.get("authority")));
						}
					}
				}

				sysUserDetails.setAuthorities(authorities);

				// 获取IP
				String ip = claims.get("ip").toString();
				sysUserDetails.setIp(ip);
			} catch (Exception e) {
				log.error("解析Token异常：" + e);
			}
		}
		return sysUserDetails;
	}

	/**
	 * 保存Token信息到Redis中
	 * 
	 * @param token    Token信息
	 * @param username 用户名
	 * @param ip       IP
	 */
	public static void setTokenInfo(String token, String username, String ip) {
		if (StringUtils.isNotEmpty(token)) {
			// 去除JWT前缀
			token = token.substring(JWTConfig.tokenPrefix.length());

			Integer refreshTime = JWTConfig.refreshTime;
			LocalDateTime localDateTime = LocalDateTime.now();

			RedisUtils.hset(token, "username", username, refreshTime);
			RedisUtils.hset(token, "ip", ip, refreshTime);
			RedisUtils.hset(token, "refreshTime",
					df.format(localDateTime.plus(JWTConfig.refreshTime, ChronoUnit.MILLIS)), refreshTime);
			RedisUtils.hset(token, "expiration", df.format(localDateTime.plus(JWTConfig.expiration, ChronoUnit.MILLIS)),
					refreshTime);
		}
	}

	/**
	 * 将Token放到黑名单中
	 * 
	 * @param token Token信息
	 */
	public static void addBlackList(String token) {
		if (StringUtils.isNotEmpty(token)) {
			// 去除JWT前缀
			token = token.substring(JWTConfig.tokenPrefix.length());
			RedisUtils.hset("blackList", token, df.format(LocalDateTime.now()));
		}
	}

	/**
	 * Redis中删除Token
	 * 
	 * @param token Token信息
	 */
	public static void deleteRedisToken(String token) {
		if (StringUtils.isNotEmpty(token)) {
			// 去除JWT前缀
			token = token.substring(JWTConfig.tokenPrefix.length());
			RedisUtils.deleteKey(token);
		}
	}

	/**
	 * 判断当前Token是否在黑名单中
	 * 
	 * @param token Token信息
	 */
	public static boolean isBlackList(String token) {
		if (StringUtils.isNotEmpty(token)) {
			// 去除JWT前缀
			token = token.substring(JWTConfig.tokenPrefix.length());
			return RedisUtils.hasKey("blackList", token);
		}
		return false;
	}

	/**
	 * 是否过期
	 * 
	 * @param expiration 过期时间，字符串
	 * @return 过期返回True，未过期返回false
	 */
	public static boolean isExpiration(String expiration) {
		LocalDateTime expirationTime = LocalDateTime.parse(expiration, df);
		LocalDateTime localDateTime = LocalDateTime.now();
		if (localDateTime.compareTo(expirationTime) > 0) {
			return true;
		}
		return false;
	}

	/**
	 * 是否有效
	 * 
	 * @param refreshTime 刷新时间，字符串
	 * @return 有效返回True，无效返回false
	 */
	public static boolean isValid(String refreshTime) {
		LocalDateTime validTime = LocalDateTime.parse(refreshTime, df);
		LocalDateTime localDateTime = LocalDateTime.now();
		if (localDateTime.compareTo(validTime) > 0) {
			return false;
		}
		return true;
	}

	/**
	 * 检查Redis中是否存在Token
	 * 
	 * @param token Token信息
	 * @return
	 */
	public static boolean hasToken(String token) {
		if (StringUtils.isNotEmpty(token)) {
			// 去除JWT前缀
			token = token.substring(JWTConfig.tokenPrefix.length());
			return RedisUtils.hasKey(token);
		}
		return false;
	}

	/**
	 * 从Redis中获取过期时间
	 * 
	 * @param token Token信息
	 * @return 过期时间，字符串
	 */
	public static String getExpirationByToken(String token) {
		if (StringUtils.isNotEmpty(token)) {
			// 去除JWT前缀
			token = token.substring(JWTConfig.tokenPrefix.length());
			return RedisUtils.hget(token, "expiration").toString();
		}
		return null;
	}

	/**
	 * 从Redis中获取刷新时间
	 * 
	 * @param token Token信息
	 * @return 刷新时间，字符串
	 */
	public static String getRefreshTimeByToken(String token) {
		if (StringUtils.isNotEmpty(token)) {
			// 去除JWT前缀
			token = token.substring(JWTConfig.tokenPrefix.length());
			return RedisUtils.hget(token, "refreshTime").toString();
		}
		return null;
	}

	/**
	 * 从Redis中获取用户名
	 * 
	 * @param token Token信息
	 * @return
	 */
	public static String getUserNameByToken(String token) {
		if (StringUtils.isNotEmpty(token)) {
			// 去除JWT前缀
			token = token.substring(JWTConfig.tokenPrefix.length());
			return RedisUtils.hget(token, "username").toString();
		}
		return null;
	}

	/**
	 * 从Redis中获取IP
	 * 
	 * @param token Token信息
	 * @return
	 */
	public static String getIpByToken(String token) {
		if (StringUtils.isNotEmpty(token)) {
			// 去除JWT前缀
			token = token.substring(JWTConfig.tokenPrefix.length());
			return RedisUtils.hget(token, "ip").toString();
		}
		return null;
	}

}
  • 修改登录成功处理类，将Token添加到Redis中
import java.util.HashMap;
import java.util.Map;

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

import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;

import com.c3stones.security.entity.SysUserDetails;
import com.c3stones.security.utils.JWTTokenUtils;
import com.c3stones.utils.AccessAddressUtils;
import com.c3stones.utils.ResponseUtils;

import lombok.extern.slf4j.Slf4j;

/**
 * 登录成功处理类
 * 
 * @author CL
 *
 */
@Slf4j
@Component
public class UserLoginSuccessHandler implements AuthenticationSuccessHandler {

	@Override
	public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
			Authentication authentication) {
		SysUserDetails sysUserDetails = (SysUserDetails) authentication.getPrincipal();
		// 获得请求IP
		String ip = AccessAddressUtils.getIpAddress(request);
		sysUserDetails.setIp(ip);
		String token = JWTTokenUtils.createAccessToken(sysUserDetails);

		// 保存Token信息到Redis中
		JWTTokenUtils.setTokenInfo(token, sysUserDetails.getUsername(), ip);
		
		log.info("用户{}登录成功，Token信息已保存到Redis", sysUserDetails.getUsername());

		Map<String, String> tokenMap = new HashMap<>();
		tokenMap.put("token", token);
		ResponseUtils.responseJson(response, ResponseUtils.response(200, "登录成功", tokenMap));
	}
}
  • 修改登出成功处理类，登出后将Token添加至黑名单
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;
import org.springframework.stereotype.Component;

import com.c3stones.security.config.JWTConfig;
import com.c3stones.security.utils.JWTTokenUtils;
import com.c3stones.utils.ResponseUtils;

import lombok.extern.slf4j.Slf4j;

/**
 * 登出成功处理类
 * 
 * @author CL
 *
 */
@Slf4j
@Component
public class UserLogoutSuccessHandler implements LogoutSuccessHandler {

	@Override
	public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response,
			Authentication authentication) {
		// 添加到黑名单
		String token = request.getHeader(JWTConfig.tokenHeader);
		JWTTokenUtils.addBlackList(token);

		log.info("用户{}登出成功，Token信息已保存到Redis的黑名单中", JWTTokenUtils.getUserNameByToken(token));

		SecurityContextHolder.clearContext();
		ResponseUtils.responseJson(response, ResponseUtils.response(200, "登出成功", null));
	}
}
  • 修改JWT过滤器，对Token进行校验
      加入黑名单后将拦截；
      Token过期但在刷新期间内将刷新Token；
      超过过期时间且超过刷新时间，将拦截；
      请求IP与Token中IP不一致，将拦截。
import java.io.IOException;

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

import org.apache.commons.lang3.StringUtils;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.www.BasicAuthenticationFilter;

import com.c3stones.security.config.JWTConfig;
import com.c3stones.security.entity.SysUserDetails;
import com.c3stones.security.utils.JWTTokenUtils;
import com.c3stones.utils.AccessAddressUtils;
import com.c3stones.utils.ResponseUtils;

import lombok.extern.slf4j.Slf4j;

/**
 * JWT权限过滤器，用于验证Token是否合法
 * 
 * @author CL
 *
 */
@Slf4j
public class JWTAuthenticationFilter extends BasicAuthenticationFilter {

	public JWTAuthenticationFilter(AuthenticationManager authenticationManager) {
		super(authenticationManager);
	}

	@Override
	protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
			throws IOException, ServletException {
		// 取出Token
		String token = request.getHeader(JWTConfig.tokenHeader);

		if (token != null && token.startsWith(JWTConfig.tokenPrefix)) {
			// 是否在黑名单中
			if (JWTTokenUtils.isBlackList(token)) {
				ResponseUtils.responseJson(response, ResponseUtils.response(505, "Token已失效", "Token已进入黑名单"));
				return;
			}

			// 是否存在于Redis中
			if (JWTTokenUtils.hasToken(token)) {
				String ip = AccessAddressUtils.getIpAddress(request);
				String expiration = JWTTokenUtils.getExpirationByToken(token);
				String username = JWTTokenUtils.getUserNameByToken(token);

				// 判断是否过期
				if (JWTTokenUtils.isExpiration(expiration)) {
					// 加入黑名单
					JWTTokenUtils.addBlackList(token);

					// 是否在刷新期内
					String validTime = JWTTokenUtils.getRefreshTimeByToken(token);
					if (JWTTokenUtils.isValid(validTime)) {
						// 刷新Token，重新存入请求头
						String newToke = JWTTokenUtils.refreshAccessToken(token);

						// 删除旧的Token，并保存新的Token
						JWTTokenUtils.deleteRedisToken(token);
						JWTTokenUtils.setTokenInfo(newToke, username, ip);
						response.setHeader(JWTConfig.tokenHeader, newToke);

						log.info("用户{}的Token已过期，但为超过刷新时间，已刷新", username);

						token = newToke;
					} else {

						log.info("用户{}的Token已过期且超过刷新时间，不予刷新", username);

						// 加入黑名单
						JWTTokenUtils.addBlackList(token);
						ResponseUtils.responseJson(response, ResponseUtils.response(505, "Token已过期", "已超过刷新有效期"));
						return;
					}
				}

				SysUserDetails sysUserDetails = JWTTokenUtils.parseAccessToken(token);

				if (sysUserDetails != null) {
					// 校验IP
					if (!StringUtils.equals(ip, sysUserDetails.getIp())) {

						log.info("用户{}请求IP与Token中IP信息不一致", username);

						// 加入黑名单
						JWTTokenUtils.addBlackList(token);
						ResponseUtils.responseJson(response, ResponseUtils.response(505, "Token已过期", "可能存在IP伪造风险"));
						return;
					}

					UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
							sysUserDetails, sysUserDetails.getId(), sysUserDetails.getAuthorities());
					SecurityContextHolder.getContext().setAuthentication(authentication);
				}
			}
		}
		filterChain.doFilter(request, response);
	}

}
4. 测试
  • 用户登录
  • 查看Redis：
      配置文件中配置Token过期时间为300秒即5分钟，刷新时间为7天之内有效。
  • 超过有效时间但为超过刷新时间测试
      注意看响应头中Authorization值的变化。
  • 使用之前的Token再次请求
  • 在其他IP主机上访问接口，使用本机申请的Token
# 请求：
curl -X POST -H "Authorization:Bearer eyJhbGciOiJIUzUxMiJ9.eyJqdGkiOiIyIiwic3ViIjoidXNlciIsImlhdCI6MTU5NDc3NjYzMiwiaXNzIjoiQzNTdG9uZXMiLCJleHAiOjE1OTQ3NzY5MzIsImF1dGhvcml0aWVzIjoiW3tcImF1dGhvcml0eVwiOlwiUk9MRV9VU0VSXCJ9XSIsImlwIjoiMTI3LjAuMC4xIn0.ogo8Q3-MOj5bFLA01bxM1Fh0plaB8tvwwSnDlgHQqxVMm0zOiKvsQhsqO673xeFPMpSXhFhPu57coaHX1J5E0A" "http://192.168.0.100:8080/user/info"

# 结果：
{"code":505,"data":"可能存在IP伪造风险","msg":"Token已过期"}
  • 登出，使用响应头中的新的Token

      注意：每次测试后，请查看Redis中的变化。
5. 项目地址

  spring-security-jwt-redis-demo

C3Stones
关注
Springboot+Spring-Security+JWT 实现用户登录和权限认证
congge
06-08 27万+
如今，互联网项目对于安全的要求越来越严格，这就是对后端开发提出了更多的要求，目前比较成熟的几种大家比较熟悉的模式，像RBAC 基于角色权限的验证，shiro框架专门用于处理权限方面的，另一个比较流行的后端框架是Spring-Security，该框架提供了一整套比较成熟，也很完整的机制用于处理各类场景下的可以基于权限，资源路径，以及授权方面的解决方案，部分模块支持定制化，而且在和oauth2.0进...
SpringBoot + SpringSecurity + Mybatis-Plus + JWT + Redis 实现分布式系统认证和授权（刷新Token和Token黑名单）
weixin_50185313的博客
12-01 1681
SpringBoot + SpringSecurity + Mybatis-Plus + JWT + Redis 实现分布式系统认证和授权（刷新Token和Token黑名单）
Spring Boot+Spring Security+Mybatis-plus+jwt+redis 通用后台管理
qq_37220802的博客
10-26 747
touch-spring-template 简介 打造一个简洁、易扩展的开发脚手架。 代码结构清晰，遵循低耦合高内聚设计思想。 各模块之间灵活搭配，即插即用。 丰富的代码注释、便于阅读及二次开发。 功能 系统管理：用户管理、角色管理、菜单管理、部门管理、字典管理、资源管理、租户管理 系统监控：系统日志、访问日志、在线用户、定时任务、DB监控 系统工具：接口文档、代码生成、表单设计 流程管理：流程模型、流程定义、用户分组、流程用户 技术选型 核心框架：Spring Boot 2.2.0
使用Spring Security+jwt+redis实现登录注册逻辑
最新发布
qq_45791526的博客
10-10 611
使用Spring Security+jwt+redis实现登录注册逻辑
Springboot + Spring Security +JWT + mybatis plus 实现前后端分离登录认证及权限控制
秋收的麦穗的博客
11-22 2917
前言: 参考文章: Springboot + Spring Security 实现前后端分离登录认证及权限控制 springboot+Spring-Security+JWT 实现用户登录和权限认证 项目主要代码来源于参考的第一篇文章,jwt来源于第二篇 改变: 将第一篇文章的项目改成我熟悉的无xml文件模式 将第二篇文章的jwt加入第一篇文章代码 代码部分修改… 项目结构 一.基于权限控制 编写controller接口 a.管理员资源接口,需要有管理员相关权限或角色才可以访问 /** * @
springboot整合springsecurity+jwt+redis
klz
05-02 7967
依赖 <!-- springsecurity依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> ...
spring boot集成spring security（jwt+redis有完整源码）
fds技术枭牛
09-06 1194
一、Spring Security官方解释 Spring Security是一个强大的和高度可定制的身份验证和访问控制框架。它是保证基于spring的应用程序安全的实际标准。Spring Security是一个框架,着重于为Java应用程序提供身份验证和授权。春天像所有项目,Spring Security的真正力量是很容易找到的它可以扩展以满足定制需求。 本项目使用jwt当作token，使用redis存储token，登录信息不依赖于单个项目，集中存储到redis内存型数据库中。 二、spring boot集
Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统.rar
08-12
主流技术 几乎零XML，极简配置 两套UI实现(bootstrap+layer ui)，可以自由切换 报表后端采用技术： SpringBoot整合SSM(Spring+Mybatis-plus+ SpringMvc)，spring security 全注解式的权限管理和JWT方式禁用Session,...
SpringBoot2.7整合SpringSecurity+Jwt+Redis+MySQL+MyBatis完整项目代码
10-30
在本项目中，我们主要关注的是SpringBoot 2.7版本与多个技术的深度整合，包括Spring Security、JWT（JSON Web Token）、Redis缓存以及MySQL数据库，并利用MyBatis作为持久层框架。以下是对这些技术及其整合应用的...
springboot+security+mybatis+redis+jwt，鉴权框架搭建
06-22
本项目集成了springboot+security+mybatis+redis+jwt用于学习security鉴权功能，其中有集成了redis，mybatis，jasypt，jwt，thymeleaf，knife4j，mybatis-plus 项目搭建已经比较成熟，能够直接进行使用，通过代码...
Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统
04-19
报表后端采用技术： SpringBoot整合SSM，spring security 全注解式的权限管理和JWT方式禁用Session,采用redis存储token及权限信息 报表前端采用Bootstrap框架，结合Jquery Ajax，整合前端Layer.js（提供弹窗）+...
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证
08-26
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证，可根据注解的格式不同，做到角色权限控制，角色加资源权限控制等，粒度比较细化。 @PreAuthorize("hasAnyRole('ADMIN','USER')")：具有admin或user角色的用户可以访问。 @PreAuthorize("hasRole('ADMIN') and hasRole('USER')"):具有admin和user角色的用户可以访问 文章地址：https://blog.csdn.net/fuu123f/article/details/108233463
通用权限管理系统+springboot+mybatis plus+spring security+jwt+redis+mysql
05-30
通用权限管理系统可练手可毕设，如果项目中有权限开发要求可直接拿来基础开发。 系统设计包括前端Vue框架和后端SpringBoot框架的搭建，以及数据库和权限控制模块的设计。前端使用Vue框架进行页面开发，利用Vue Router实现路由管理和权限控制。后端使用SpringBoot框架进行业务逻辑开发，利用Spring Security实现权限控制。数据库采用MySQL进行数据存储，使用MyBatis进行数据访问。 权限控制模块设计包括用户、角色和权限三个主要模块。用户模块用于管理用户信息，角色模块用于管理角色信息，权限模块用于管理权限信息。实现对用户访问资源的控制，可以通过将权限与角色进行关联。 系统实现主要包括用户登录、权限验证、角色管理、权限管理、资源管理等功能。当用户尝试登录时，系统会通过核实其用户名和密码来确认其身份。权限验证时，根据用户的角色和权限信息，系统评估用户是否具备访问该资源的权利。角色管理、权限管理和资源管理等功能，通过对应的模块实现。 总的来说，基于SpringBoot+Vue的通用权限控制系统设计与实现，可以提供灵活、可扩展、易维护的权限控制功能，适用于各种应用
SpringBoot+SpringSecurity+Jwt+Mybatis-Plus+Swwager
zjy660358的专栏
05-05 524
因公司业务为PC端后台管理居多，session有这得天独厚优势。 本月有个项目，有一端是小程序。天然不支持Cookie。因此打算用Jwt token方式 博客简单讲解一下与Springboot+SpringSecurity+SpringSession+Redis+Mybatis-Plus+Swwager搭建的区别 pom 去掉 SpringSession Redis依赖 <!-- jwt --> <dependency> .
Spring boot+Spring security+JWT实现前后端分离登录认证及权限控制
热门推荐
李哈zzz的博客
03-30 2万+
借鉴文章： Springboot + Spring Security 实现前后端分离登录认证及权限控制_I_am_Rick_Hu的博客-CSDN博客_springsecurity前后端分离登录认证 最近一段时间，公司给我安排了一个公司子系统的后台管理系统，让我实现权限管理。此时我就考虑到Spring全家桶的Spring security来权限管理。Spring security大致分为认证和授权两个功能，底层也是通过JavaWeb的Filter过滤器来实现，在Spring security中维护了一个.
Spring Boot + Vue的网上商城之springsecurity+jwt+redis实现用户权限认证实现
qq_22593423的博客
09-13 847
本文介绍了如何使用Spring Security和Vue实现用户登录和权限认证的功能。通过使用JWT和Redis存储Token，我们可以实现无状态的用户认证，提高系统的可扩展性和安全性。同时，通过使用Vue的路由导航守卫，我们可以实现前端的权限校验，确保只有登录用户才能访问受限资源。希望本文能对你理解和实现用户登录和权限认证功能有所帮助。
Spring Boot 整合SpringSecurity和JWT和Redis实现统一鉴权认证
wgq2020的博客
11-06 730
Spring Boot是目前非常流行的一款Java框架，Spring Security是Spring家族中的一个安全框架，JWT（JSON Web Token）是一种跨域认证解决方案，Redis是一种内存数据库。本文主要介绍如何使用Spring Boot整合Spring Security和JWT和Redis来实现统一的鉴权认证。JWT是一种轻量级的认证方案，它包含了一些用户信息以及签名，这些信息都在一个字符串中，可以方便地在不同系统之间传递。JWT主要包含三部分：头部信息，载荷信息和签名信息。
springboot + spring security + jwt + redis详细（一）
qq_38324424的博客
04-24 908
作为一个刚入门，没多久的新手小白，由于项目需要，所以学习了一下spring security，基本上此篇文章是根据各路大神撰写的博客结合而来，为了同样刚接触的新手小白少踩点坑，有什么问题还请大神们多多指点 创建用户表： CREATE TABLE `sys_user` ( `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT, `...
springboot教程之整合SpringSecurity+JWT 2万字超详细鉴权系统讲解
竹林幽深
12-01 444
原创康东伟西瓜阵地2021-05-24 23:04 收录于话题 #springboot15个内容 #mybatis-plus5个内容 #springsecurity2个内容 #jwt2个内容 Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependen...
spring boot + spring security + jwt + spring mvc + mybatis + redis商城项目
12-12
Spring Boot 是一个用于构建微服务的开源框架，它能够快速搭建项目并且提供了许多便捷的功能和特性。Spring Security 是一个用于处理认证和授权的框架，可以保护我们的应用程序免受恶意攻击。JWT（JSON Web Token）是一种用于身份验证的开放标准，可以被用于安全地传输信息。Spring MVC 是一个用于构建 Web 应用程序的框架，它能够处理 HTTP 请求和响应。MyBatis 是一个用于操作数据库的框架，可以简化数据库操作和提高效率。Redis 是一种高性能的键值存储系统，可以用于缓存与数据存储。 基于这些技术，可以搭建一个商城项目。Spring Boot 可以用于构建商城项目的后端服务，Spring Security 可以确保用户信息的安全性，JWT 可以用于用户的身份验证，Spring MVC 可以处理前端请求，MyBatis 可以操作数据库，Redis 可以用于缓存用户信息和商品信息。 商城项目的后端可以使用 Spring Boot 和 Spring Security 来搭建，通过 JWT 来处理用户的身份验证和授权。数据库操作可以使用 MyBatis 来简化与提高效率，同时可以利用 Redis 来缓存一些常用的数据和信息，提升系统的性能。前端请求则可以通过 Spring MVC 来处理，实现商城项目的整体功能。 综上所述，借助于 Spring Boot、Spring Security、JWT、Spring MVC、MyBatis 和 Redis 这些技术，可以构建出一个高性能、安全可靠的商城项目，为用户提供良好的购物体验。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值