单一登陆，同用户同系统不同设备同时登陆时顶号，redis实现

 思路：
    第一次用户登陆时生成UUID随机数作为token 查数据库获取用户信息 保存redis中  key token value 用户iduserId，
 同时保存 key userId ，value用户基本信息实体其中包含token字段息， 返回用户基本信息，每次请求时传token去查redis中是否存在
当第二次登陆时 先查数据库获取userId 拿到userId去redis里查询用户实体是否存在，存在说明之前登陆过，拿到其中token，根据key token删除保存在redis中的信息，redis保存新的 key token  和 key userId 

思路：
    第一次用户登陆时生成UUID随机数作为token 查数据库获取用户信息 保存redis中  key token value 用户iduserId，
 同时保存 key userId ，value用户基本信息实体其中包含token字段息， 返回用户基本信息，每次请求时传token去查redis中是否存在
当第二次登陆时 先查数据库获取userId 拿到userId去redis里查询用户实体是否存在，存在说明之前登陆过，拿到其中token，根据key token删除保存在redis中的信息，redis保存新的 key token  和 key userId 

登陆逻辑token处理

/**
 * 登陆处理
 * @param lmUserEntity
 * @return
 * @throws Exception
 */
public String handleLogin(LmUserEntity  lmUserEntity) throws Exception {
    LmUserEntity info = this.getUserByUserId(lmUserEntity.getUserId());
    if (info != null) {
        this.delToken(info.getToken());
        logger.info("清除原登陆token："+info.getToken());
    }
    String token=this.setLoginToken(lmUserEntity.getUserId());
    logger.info("生成token："+token);
    lmUserEntity.setToken(token);
    this.setUserByUserId(lmUserEntity);
    return token;
}

用户实体
public class LmUserEntity implements Serializable {
   private static final long serialVersionUID = 1L;
   
   //
   private Integer id;
private String token;

private String userMobile;

private String userName;

private String userPassword;

/**
拦截器
*/

@Configuration
public class AddInterceptorsConfig implements WebMvcConfigurer {
    private CorsConfiguration buildConfig() {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.addAllowedOrigin("*"); // 1
        corsConfiguration.addAllowedHeader("*"); // 2
        corsConfiguration.addAllowedMethod("*"); // 3
        return corsConfiguration;
    }

    @Bean
    public CorsFilter corsFilter() {
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        source.registerCorsConfiguration("/**", buildConfig());
        return new CorsFilter(source);
    }
    @Bean
    public HandlerInterceptor getInterceptor() {
        return new LoginInterceptor();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {


        registry.addInterceptor(getInterceptor())
                .addPathPatterns("/user/**"); 
    }

}

public class LoginInterceptor implements HandlerInterceptor{
    private static Logger logger = LoggerFactory.getLogger(LoginInterceptor.class);
    @Autowired
    private TokenRedisUtils tokenUtils;

    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token=request.getHeader("tokenStr");
        response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE);
        if (StringUtils.isBlank(token)){
            logger.info("未获取到tokenStr");
            //用户未登录
            response.getWriter().print(JSONObject.toJSON(ResultDto.hasCodeFail("token失效","204")));
            return false;
        }else {
           Object o= tokenUtils.getLoginToken(token);
            if(null==o){
                logger.info("未查询到token记录："+token);
                //登录失效
                response.getWriter().print(JSONObject.toJSON(ResultDto.hasCodeFail("token失效","204")));
                return false;
            }
            LmUserEntity userEntity=tokenUtils.getUserByToken(o.toString());
            if (userEntity ==null ){
                logger.info("未查询到用户信息token："+token+",userId:"+o.toString());
                response.getWriter().print(JSONObject.toJSON(ResultDto.hasCodeFail("token失效","204")));
                return false;
            } 
        }
        return true;
    }

public String setLoginToken(String userId) throws Exception {
    String uuid = UUId.getUUid();
    redisService.set(LM_R_LOGIN + uuid, userId, 60*60*24*7);
    return uuid;
}

public boolean setUserByUserId(LmUserEntity userEntity) throws Exception {
    return redisService.set(LM_R_LOGIN + userEntity.getUserId(), JSON.toJSONString(userEntity),60*60*24*7);
}