Spring Boot结合Redis和Token来实现同一个账户同时只能有一处在线的方案

最新推荐文章于 2024-08-20 20:34:22 发布
最新推荐文章于 2024-08-20 20:34:22 发布
阅读量30 收藏
点赞数
文章标签： spring boot redis java
原文链接：https://mp.weixin.qq.com/s/E0PdbE9TKQ9JNXSowSZ55Q
版权

Spring Boot结合Redis和Token来实现同一个账户同时只能有一处在线的方案

以下具体步骤：

步骤1：添加依赖

首先，在你的pom.xml中添加必要的依赖。


<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Spring Boot Starter Security -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <!-- Spring Boot Starter Data Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- JWT -->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>
    <!-- Redisson -->
    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson-spring-boot-starter</artifactId>
        <version>3.13.6</version>
    </dependency>
</dependencies>

步骤 2: 配置Redis

在application.properties中配置Redis连接：


# application.properties 
spring.redis.host=localhost  
spring.redis.port=6379  
# 根据需要添加其他配置，如密码、数据库索引等

步骤 3: 创建JWT工具类

这个类将负责生成和验证JWT。

import io.jsonwebtoken.Claims;  
import io.jsonwebtoken.Jwts;  
import io.jsonwebtoken.SignatureAlgorithm;  
import java.util.Date;  
import java.util.HashMap;  
import java.util.Map;  

public class JwtTokenUtil {  

    private String secretKey;  

    // 构造函数，初始化密钥  
    public JwtTokenUtil(String secretKey) {  
        this.secretKey = secretKey;  
    }  

    // 生成JWT的方法  
    public String generateToken(Map<String, Object> claims) {  
        return Jwts.builder()  
                .setClaims(claims) // 设置claims  
                .setExpiration(new Date(System.currentTimeMillis() + 60 * 60 * 1000)) // 设置1小时后过期  
                .signWith(SignatureAlgorithm.HS512, secretKey) // 使用HS512算法和密钥签名  
                .compact(); // 生成token  
    }  

    // 验证JWT的方法  
    public boolean validateToken(String token, String username) {  
        try {  
            final Claims claims = extractClaims(token);  
            return claims != null && claims.getSubject().equals(username) && !isTokenExpired(claims.getExpiration());  
        } catch (Exception e) {  
            // 如果token无效，会抛出异常  
            return false;  
        }  
    }  

    // 提取JWT中的Claims的方法  
    public Claims extractClaims(String token) {  
        return Jwts.parser()  
                .setSigningKey(secretKey)  
                .parseClaimsJws(token)  
                .getBody();  
    }  

    // 辅助方法：检查token是否过期  
    private boolean isTokenExpired(Date expiration) {  
        return expiration.before(new Date());  
    }  

}

步骤 4: 配置Spring Security

你需要配置Spring Security以使用JWT进行身份验证，并添加自定义的过滤器来处理JWT。

@Configuration  
@EnableWebSecurity  
public class SecurityConfig extends WebSecurityConfigurerAdapter {  

    @Autowired  
    private JwtTokenUtil jwtTokenUtil;  

    // 其他Bean和方法...  

    @Override  
    protected void configure(HttpSecurity http) throws Exception {  
        http  
            .csrf().disable()  
            .authorizeRequests()  
            .antMatchers("/login", "/register").permitAll()  
            .anyRequest().authenticated()  
            .and()  
            .addFilterBefore(new JwtAuthenticationTokenFilter(jwtTokenUtil), UsernamePasswordAuthenticationFilter.class);  

        // 其他配置...  
    }  
}

步骤 5: 创建JWT认证过滤器

这个过滤器将检查每个请求中的JWT，并设置Spring Security的SecurityContextHolder。


import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;  
import org.springframework.security.core.Authentication;  
import org.springframework.security.core.context.SecurityContext;  
import org.springframework.security.core.context.SecurityContextHolder;  
import org.springframework.web.filter.OncePerRequestFilter;  

import javax.servlet.FilterChain;  
import javax.servlet.ServletException;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  
import java.io.IOException;  

public class JwtAuthenticationFilter extends OncePerRequestFilter {  

    private final JwtTokenUtil jwtTokenUtil;  

    public JwtAuthenticationFilter(JwtTokenUtil jwtTokenUtil) {  
        this.jwtTokenUtil = jwtTokenUtil;  
    }  

    @Override  
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)  
            throws ServletException, IOException {  

        // 从请求头中提取JWT  
        String jwt = extractJwtFromRequestHeader(request);  

        // 验证JWT  
        if (jwt != null && jwtTokenUtil.validateToken(jwt)) {  
            // 如果JWT有效，则提取用户名  
            String username = jwtTokenUtil.extractUsernameFromToken(jwt);  

            // 创建一个UsernamePasswordAuthenticationToken（虽然这里没有密码，但我们可以将其视为预认证的用户名）  
            // 注意：在实际应用中，你可能需要自定义Authentication类来存储更多信息  
            Authentication authentication = new UsernamePasswordAuthenticationToken(username, null, null);  

            // 设置SecurityContextHolder  
            SecurityContextHolder.getContext().setAuthentication(authentication);  
        }  

        // 继续过滤器链  
        chain.doFilter(request, response);  
    }  

    // 辅助方法：从请求头中提取JWT  
    private String extractJwtFromRequestHeader(HttpServletRequest request) {  
        String header = request.getHeader("Authorization");  
        if (header == null || !header.startsWith("Bearer ")) {  
            return null;  
        }  
        return header.substring(7);  
    }  
 
}

步骤 6: 创建会话管理器

这个管理器将使用Redis来跟踪用户的会话。

@Component  
public class SessionManager {  

    @Autowired  
    private RedisTemplate<String, String> redisTemplate;  

    public void login(String username, String tokenId) {  
        // 将username和tokenId存储到Redis中  
        // ...  
    }  

    public boolean checkSessionExists(String username, String tokenId) {  
        // 检查Redis中是否已存在该用户的session  
        // ...  
    }  
}

步骤 7: 整合JWT认证和会话管理

在JwtAuthenticationTokenFilter中，除了验证JWT之外，还需要调用SessionManager来检查会话是否已存在。

// 在doFilterInternal方法中  
// ...  
String jwt = extractToken(request);  
if (jwt != null && jwtTokenUtil.validateToken(jwt)) {  
    Claims claims = jwtTokenUtil.extractClaims(jwt);  
    String username = claims.getSubject();  
    if (!sessionManager.checkSessionExists(username, jwt)) {  
        // 处理会话冲突  
        // ...  
    }

步骤 8: 处理会话冲突

在JwtAuthenticationTokenFilter的doFilterInternal方法中，当检测到会话冲突时（即同一个用户名已有一个活动的会话），你可以决定是踢出旧会话还是拒绝新会话。以下是一个简单的示例，展示了如何拒绝新会话并返回一个错误响应给客户端。


@Override  
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)  
        throws ServletException, IOException {  
    String jwt = extractTokenFromRequest(request);  
    if (jwt != null && jwtTokenUtil.validateToken(jwt)) {  
        Claims claims = jwtTokenUtil.extractClaims(jwt);  
        String username = claims.getSubject();  

        // 检查会话是否已存在  
        if (!sessionManager.checkSessionExists(username, jwt)) {  
            // 标记当前会话为有效  
            sessionManager.login(username, jwt);  

            // 设置认证信息到SecurityContextHolder  
            // ...  

            chain.doFilter(request, response);  
        } else {  
            // 会话冲突处理  
            response.setStatus(HttpServletResponse.SC_CONFLICT);  
            response.getWriter().write("Session conflict: User is already logged in from another session.");  
            return;  
        }  
    }  

    // 如果没有JWT或JWT无效，可能需要进行其他处理（如重定向到登录页面）  
    // ...  

    chain.doFilter(request, response);  
}  

// 辅助方法，用于从请求中提取JWT  
private String extractTokenFromRequest(HttpServletRequest request) {  
    // 从请求头、Cookie或URL参数中提取JWT  
    // 示例：从HTTP头Authorization字段中提取  
    String bearerToken = request.getHeader("Authorization");  
    if (bearerToken != null && bearerToken.startsWith("Bearer ")) {  
        return bearerToken.substring(7);  
    }  
    return null;  
}

步骤 9: 登出处理

当用户登出时，你需要从Redis中删除该用户的会话记录。这可以通过在登出控制器中调用SessionManager的相应方法来实现。

@RestController  
@RequestMapping("/api/auth")  
public class AuthController {  

    @Autowired  
    private SessionManager sessionManager;  

    // 其他方法...  

    @PostMapping("/logout")  
    public ResponseEntity<?> logout(@RequestHeader(value = "Authorization", required = false) String jwt) {  
        if (jwt != null && jwt.startsWith("Bearer ")) {  
            jwt = jwt.substring(7);  
            Claims claims = jwtTokenUtil.extractClaims(jwt);  
            String username = claims.getSubject();  

            // 假设你有一个方法来获取与JWT关联的特定标识符（如tokenId）  
            // String tokenId = ...; // 从JWT的Claims中获取  

            // 从Redis中删除会话  
            sessionManager.logout(username, /* tokenId 如果需要的话 */);  

            // 返回成功响应  
            return ResponseEntity.ok("Logged out successfully");  
        }  

        // 如果没有提供JWT或其他错误情况  
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Invalid JWT for logout");  
    }  

    // 注意：上面的logout方法假设你可以从JWT中提取出足够的信息来唯一标识会话。
    // 在实际应用中，你可能需要更复杂的逻辑来确保正确地跟踪和识别会话。
}

总结下设计思路

1. JWT生成与验证

  • 生成JWT：在用户登录时，服务器验证用户名和密码后，生成一个包含用户信息的JWT，并将其发送给客户端。JWT中通常包含用户ID、过期时间等信息。

  • 验证JWT：客户端在每次请求时，将JWT放在请求头中发送给服务器。服务器使用JWT密钥验证JWT的有效性和完整性。

2. Redis会话管理

  • 存储Token标识：在服务器验证JWT后，可以提取JWT中的用户ID（或其他唯一标识符），并将这个标识符与当前JWT的Token（或其哈希值）作为键值对存储在Redis中。

  • 这个键可以设置为用户的唯一会话标识符，如user:session:userId。

  • 检查会话唯一性：在每次请求验证JWT后，检查Redis中是否已存在该用户ID的其他Token。如果存在，则说明该用户已在其他地方登录，此时可以选择：

    • 强制登出旧会话（删除Redis中的旧Token）。

    • 拒绝新会话的请求，提示用户已在其他地方登录。

  • 更新Redis：如果当前会话是有效的，更新Redis中的Token为最新的，以确保会话的时效性。

买女孩的火柴盒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot整和jwt、shiro、redis实现token自动刷新
08-19
结合JWT（JSON Web Token）和Shiro，我们可以构建一个高效的身份验证和授权系统，同时利用Redis缓存来提高性能和用户体验。下面将详细介绍如何在Spring Boot中整合JWT、Shiro和Redis实现Token自动刷新。 JWT是一种...
基于redis实现token验证用户是否登陆
01-19
基于项目需求， 我们要实现一个基于redis实现token登录验证，该如何实现呢： 后端实现： 1.引入redis相关的依赖 <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis <groupId>...
SpringBoot_Shiro_JWT_Redis:SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新
05-14
SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新 前端代码为一个博客页面，使用了Semantic UI框架结合thymeleaf模板 SpringBoot结合JWT+Shiro+Redis实现token无状态登录授权 [TOC] 一、引言 ​ ...
项目以Springboot集SpringSecurity、redis等多个中间件为载体，做出一个有app端、web端的酒店管理系
07-27
SpringSecurity使用token写入过期时间进行有效期管理（SpringSecurity结合Redis进行token有效期管理请移步我的另一个项目——小区智能管理系统） 可以通过角色权限或者指定人员授予菜单权限来实现动态菜单 引用第三...
spring-boot-redis-token 分布式锁 redis session
09-14
http://localhost:8080/ass/getUser 测试是否登录 http://localhost:8080/any/user/passLogin 登录测试 http://localhost:8080/lock redis分布式锁测试
Spring Boot集成钉钉群通知机器人
执笔写JAVA
08-17 470
本文讲述了在springboot中如何集成钉钉群机器人的相关方法及测试类，测试了群通知的关键字推送消息、加签推送消息等两种方式
苍穹外卖项目DAY01
qq_62892403的博客
08-12 1873
定位：专门为餐饮企业（餐厅、饭店）定制的一款软件产品功能架构：体现项目中的业务功能模块产品原型：用于展示项目的业务功能，一般由产品经理进行设计技术选型：展示项目中使用到的技术框架和中间件等使用Swagger你只需要按照它的规范去定义接口及接口相关的信息，就可以做到生成接口文档，以及在线接口调试页面。Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案。
Java面试题--分布式锁
qq_56438516的博客
08-14 710
分布式锁是在分布式/集群环境中解决多线程并发造成的一系列数据安全问题.所用到的锁就是分布式锁，这种锁需要被多个应用共享才可以，通常使用Redis和zookeeper来实现。
Spring Boot集成RabbitMQ
这河里吗l的博客
08-13 895
RabbitMQ是一个由Erlang语言编写的消息中间件，它遵循AMQP协议，提供了稳定可靠的消息传输服务。RabbitMQ通过其独特的架构和丰富的功能，帮助开发者解决分布式系统中的消息传递问题，提高系统的可扩展性、可靠性和响应速度。
使用双向 @OneToOne 注解避免 Spring Boot 中的 StackOverflowError
繁依Fanyi的博客
08-16 769
双向@OneToOne关系是指两个实体之间的一对一关系，双方都可以通过对方的引用来访问对方。例如，假设我们有一个User实体和一个Role实体，每个用户都有一个角色，每个角色也有一个用户。
【Spring Boot】定时任务
2401_83045332的博客
08-17 1485
在Spring Boot中，定时任务的实现通常使用@Scheduled注解。@Scheduled可以用于在指定的时间间隔或特定的时间点执行任务。Spring提供了多种方式来配置定时任务，如使用固定速率，固定延迟或Cron表达式等。如果是分布式系统或者想要时间可以灵活变化，可以选择一些定时任务框架xxl-job,elastic-job等在 Spring Boot 中，通过使用@Scheduled。
基于SpringBoot+Vue的常规应急物资管理系统
a253399414的博客
08-14 622
【代码】springboot基于SpringBoot+Vue的常规应急物资管理系统
SpringBoot日志整合
juanmiao的专栏
08-14 450
Spring Boot 对各种日志框架进行了自动配置，使得我们可以很容易地在 Spring Boot 应用中使用日志。Spring Boot 提供了自动配置的日志工厂，可以自动适配 Logback、Log4j2、Log4j 等日志框架。文件不存在，Spring Boot 会查找默认的日志配置，并应用默认的日志级别（通常是。Spring Boot 在类路径下寻找 Logback 的配置文件。依赖来实现的，它默认整合了 Logback 日志框架。，如果不存在，则会寻找标准的 Logback 配置文件。
基于Spring Boot的大学校园生活信息平台的设计与实现pf
weixin_43213064的博客
08-20 746
【代码】springboot基于Spring Boot的大学校园生活信息平台的设计与实现pf
Spring Boot解决循环注入问题
weixin_43822632的博客
08-14 641
有效地解决循环依赖问题并在中安全地调用的方法。推荐使用事件驱动的方法，这不仅解决了循环依赖问题，还能让你的代码更具扩展性和松耦合
Spring Boot
最新发布
weixin_45476535的博客
08-20 644
静态资源文件夹下的所有 index.html 被称为静态首页或者欢迎页，它们会被 /** 映射，换句话说就是，当我们访问"localhost:8080"时，都会跳转到静态首页（欢迎页）。同时当index.html 存在多个时，也遵循静态资源优先级原则。项目目录下config下的application.yml > 项目目录下的application.yml > resources目录下config下的application.yml >resources目录下的application.yml。
基于spring boot的小型诊疗预约平台的设计与开发
寒夜
08-16 465
【代码】springboot基于spring boot的小型诊疗预约平台的设计与开发
【速览】Redis（更新中）
椰子的职场成长记录
08-20 176
Redis 支持多种数据结构，如字符串（strings）、哈希（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）等。持久化：Redis 支持两种持久化方式，RDB（快照）和 AOF（追加文件），以确保数据在重启后不会丢失。原子操作：Redis 的所有操作都是原子的，这使得它非常适合于需要高并发和数据一致性的场景。Lua 脚本：Redis 支持在服务器端执行 Lua 脚本，可以用于实现复杂的业务逻辑。事务支持：Redis 支持事务，可以将多个命令打包在一起执行。
redis事件机制
笑笑布丁的博客
08-16 647
aeApiAddEvent、aeApiDelEvent：增加或删除一个监听对象。aeEventLoop：redis事件循环器，负责管理事件。aeFileEvent：存储一个文件描述符已注册的文件事件。aeApiPoll：阻塞进程，等待事件就绪或给定事件到期。aeApiCreate：初始化I/O复用机制上下文环境。aeTimeEvent：存储一个时间事件的信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值