我们在上篇文章中：SpringBoot + Apache Shrio + JWT + Reids 添加验证码功能,讲述如何实现验证码功能，我们在此基础上进行功能完善，实现账户单点登入。下面开始梳理单点登入功能点
业务描述：
在实际项目中，同一账户可能被一个人或多个人在多个客户端，或多个浏览器中访问同一系统，我们希望只允许一个帐号在一处地方登陆，其他地方登陆都踢掉。
实现描述：
单点登陆的实现逻辑:
第一：在用户登陆成功时，生成token。然后将token作为vlaue，将用户登陆账号（username）为key,保存到redis中。并将生成的token 返回给前端。
第二：在用户登陆成功时， 向数据库中的token_relation表（主要:解决登入账户与token 唯一性问题）中，新增/修改记录，主要字段(username,token)
第三：业务系统进行凭证校验时，会根据用户提交token，判断数据库中的token_relation表是否能够查询到对应记录，如果能够查询到说明没有相同账户在其他平台登入，如果不能够查询到说明有相同账户在其他终端登入。并返回错误信息“token已经被注销”。
实现单点登入功能：需要进行Redis 功能封装、新增token_relation表
SpringBoot + Redis 功能封装:
在项目中引入redis非常简单，我们只需要在pom.xml文件中引入 spring-boot-starter-data-redis就可以了
<!-- redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>Redis 功能代码封装:
package com.zzg.redis;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import org.springframework.data.redis.core.RedisTemplate;
import com.zzg.spring.SpringContextUtil;
public class RedisUtils {
private RedisUtils() {
}
@SuppressWarnings("unchecked")
private static RedisTemplate<String, Object> redisTemplate = SpringContextUtil
.getBean("redisTemplate", RedisTemplate.class);
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功；false=设置失败
*/
public static boolean expire(final String key, final long timeout) {
return expire(key, timeout, TimeUnit.SECONDS);
}
/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @param unit 时间单位
* @return true=设置成功；false=设置失败
*/
public static boolean expire(final String key, final long timeout, final TimeUnit unit) {
Boolean ret = redisTemplate.expire(key, timeout, unit);
return ret != null && ret;
}
/**
* 删除单个key
*
* @param key 键
* @return true=删除成功；false=删除失败
*/
public static boolean del(final String key) {
Boolean ret = redisTemplate.delete(key);
return ret != null && ret;
}
/**
* 删除多个key
*
* @param keys 键集合
* @return 成功删除的个数
*/
public static long del(final Collection<String> keys) {
Long ret = redisTemplate.delete(keys);
return ret == null ? 0 : ret;
}
/**
* 存入普通对象
*
* @param key Redis键
* @param value 值
*/
public static void set(final String key, final Object value) {
redisTemplate.opsForValue().set(key, value, 1, TimeUnit.MINUTES);
}
// 存储普通对象操作
/**
* 存入普通对象
*
* @param key 键
* @param value 值
* @param timeout 有效期，单位秒
*/
public static void set(final String key, final Object value, final long timeout) {
redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
}
/**
* 获取普通对象
*
* @param key 键
* @return 对象
*/
public static Object get(final String key) {
return redisTemplate.opsForValue().get(key);
}
// 存储Hash操作
/**
* 删除Hash中指定数据
*
* @param key Redis键
* @param hKey Hash键
*/
public static void hDelete(final String key, final String hKey) {
redisTemplate.opsForHash().delete(key, hKey);
}
/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
public static void hPut(final String key, final String hKey, final Object value) {
redisTemplate.opsForHash().put(key, hKey, value);
}
/**
* 往Hash中存入多个数据
*
* @param key Redis键
* @param values Hash键值对
*/
public static void hPutAll(final String key, final Map<String, Object> values) {
redisTemplate.opsForHash().putAll(key, values);
}
/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public static Object hGet(final String key, final String hKey) {
return redisTemplate.opsForHash().get(key, hKey);
}
/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
public static List<Object> hMultiGet(final String key, final Collection<Object> hKeys) {
return redisTemplate.opsForHash().multiGet(key, hKeys);
}
// 存储Set相关操作
/**
* 往Set中存入数据
*
* @param key Redis键
* @param values 值
* @return 存入的个数
*/
public static long sSet(final String key, final Object... values) {
Long count = redisTemplate.opsForSet().add(key, values);
return count == null ? 0 : count;
}
/**
* 删除Set中的数据
*
* @param key Redis键
* @param values 值
* @return 移除的个数
*/
public static long sDel(final String key, final Object... values) {
Long count = redisTemplate.opsForSet().remove(key, values);
return count == null ? 0 : count;
}
// 存储List相关操作
/**
* 往List中存入数据
*
* @param key Redis键
* @param value 数据
* @return 存入的个数
*/
public static long lPush(final String key, final Object value) {
Long count = redisTemplate.opsForList().rightPush(key, value);
return count == null ? 0 : count;
}
/**
* 往List中存入多个数据
*
* @param key Redis键
* @param values 多个数据
* @return 存入的个数
*/
public static long lPushAll(final String key, final Collection<Object> values) {
Long count = redisTemplate.opsForList().rightPushAll(key, values);
return count == null ? 0 : count;
}
/**
* 往List中存入多个数据
*
* @param key Redis键
* @param values 多个数据
* @return 存入的个数
*/
public static long lPushAll(final String key, final Object... values) {
Long count = redisTemplate.opsForList().rightPushAll(key, values);
return count == null ? 0 : count;
}
/**
* 从List中获取begin到end之间的元素
*
* @param key Redis键
* @param start 开始位置
* @param end 结束位置（start=0，end=-1表示获取全部元素）
* @return List对象
*/
public static List<Object> lGet(final String key, final int start, final int end) {
return redisTemplate.opsForList().range(key, start, end);
}
}Spring JPA 新增表(token_relation)
token_relation sql 语句:
DROP TABLE IF EXISTS `token_relation`;
CREATE TABLE `token_relation` (
`relation_sid` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
`username` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '用户名',
`token` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT 'token凭证',
PRIMARY KEY (`relation_sid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of token_relation
-- ----------------------------
INSERT INTO `token_relation` VALUES (1, 'Jack', 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2MDY4OTQ1MjMsInVzZXJuYW1lIjoiSmFjayJ9.ayv8cbOnrp9QOPCNaasby4EysuP3Iv334-N5ge8icbc');Entity 实体对象和Repository 接口
package com.zzg.entity;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@Entity(name="token_relation")
public class TokenRelation {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY) // 自增长策略
private Integer relationSid;
private String username;
private String token;
}package com.zzg.dao;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.zzg.entity.TokenRelation;
@Repository("tokenRelationRepository")
public interface TokenRelationRepository extends JpaRepository<TokenRelation, Integer> {
TokenRelation findByUsername(String username);
TokenRelation findByToken(String token);
}Apache Shrio 实现单点登入核心功能代码片段
用户登入方法：
apache shrio 自定义Filter，权限校验方法：JWTFilter.isAccessAllowed()方法,实现apache shrio 单点登入第三步
public class JWTFilter extends BasicHttpAuthenticationFilter {
private Logger logger = LoggerFactory.getLogger(this.getClass());
// 定义jackson对象
private static final ObjectMapper MAPPER = new ObjectMapper();
/**
* 如果带有 token，则对 token 进行检查，否则直接通过
* >2 接着执行 isAccessAllowed
*/
@Override
protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws UnauthorizedException {
// 判断请求的请求头是否存在 Token
if (isLoginAttempt(request, response)) {
//如果存在，则进入 executeLogin 方法执行登入，检查 token 是否正确
// 不正常就会抛出异常
try {
// 执行登录
executeLogin(request, response);
return true;
} catch (Exception e) {
//token 错误
responseError(response, e.getMessage());
}
} else {
try{
HttpServletResponse httpResponse = (HttpServletResponse) response;
httpResponse.setContentType("application/json;charset=utf-8");
httpResponse.setHeader("Access-Control-Allow-Credentials", "true");
httpResponse.setHeader("Access-Control-Allow-Origin", HttpContextUtil.getOrigin());
httpResponse.setCharacterEncoding("UTF-8");
//设置编码，否则中文字符在重定向时会变为空字符串
Map<String, Object> result = new HashMap<>();
result.put("status", 400);
result.put("msg", "token 已经注销");
String json = MAPPER.writeValueAsString(result);
httpResponse.getWriter().print(json);
return false;
}catch(IOException e) {
logger.error(e.getMessage());
}
}
// 如果请求头不存在 Token，则可能是执行登陆操作或者是游客状态访问，
// 无需检查 token，直接返回 true
return true;
}
/**
* 判断用户是否想要登入。
* 检测 header 里面是否包含 Token 字段
*
*/
@Override
protected boolean isLoginAttempt(ServletRequest request, ServletResponse response) {
HttpServletRequest req = (HttpServletRequest) request;
System.out.println("req.getHeader(Token)"+req.getHeader("Token"));
String token = req.getHeader("Token");
if(StringUtils.isEmpty(token)){
return false;
}
TokenRelationRepository tokenRelationRepository = SpringContextUtil.getBean(TokenRelationRepository.class);
TokenRelation relation = tokenRelationRepository.findByToken(token);
if(relation != null){
return RedisUtils.get(relation.getUsername()) != null;
}
return false;
}
/**
* 执行登陆操作
*
*/
@Override
protected boolean executeLogin(ServletRequest request, ServletResponse response) throws Exception {
HttpServletRequest httpServletRequest = (HttpServletRequest) request;
String token = httpServletRequest.getHeader("Token");
JWTToken jwtToken = new JWTToken(token);
// 提交给realm进行登入，如果错误他会抛出异常并被捕获
getSubject(request, response).login(jwtToken);
// 如果没有抛出异常则代表登入成功，返回true
return true;
}
****其他省略****
}用户登出方法
效果演示：
模拟其他终端登入
token 替换为新产生token，再看效果
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
