SpringBoot + Apache Shrio + JWT + Redis 实现账户单点登入

绝地灬酷狼 2023-10-10 11:58 9阅读 0赞

我们在上篇文章中：[SpringBoot + Apache Shrio + JWT + Reids 添加验证码功能][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就可以了

<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 实现单点登入核心功能代码片段 ###

#### 用户登入方法： ####

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 1][]

#### 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;
        }
    
    ****其他省略****
    }

#### 用户登出方法 ####

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 2][]

### 效果演示： ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 3][]

模拟其他终端登入

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 5][]

token 替换为新产生token，再看效果

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 6][]

[SpringBoot _ Apache Shrio _ JWT _ Reids]: https://blog.csdn.net/zhouzhiwengang/article/details/110432574
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20201201162827495.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201201162832901.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20201201163248581.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20201201163408180.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/2020120116360640.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20201201163626245.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/2020120116374512.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob3V6aGl3ZW5nYW5n,size_16,color_FFFFFF,t_70