12. Redis实现会话管理和token认证

最新推荐文章于 2025-04-05 07:15:00 发布
最新推荐文章于 2025-04-05 07:15:00 发布
阅读量1.1k 收藏 13
点赞数 19
分类专栏： # Redis 文章标签： redis 数据库 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/imdeity/article/details/143177178
版权

在现代Web应用中，会话管理和身份认证是实现用户登录、权限管理等功能的基础。传统的会话管理通过服务器端保存会话信息来实现，但随着应用的扩展，尤其在分布式系统中，这种方式的局限性逐渐显现。Redis作为分布式缓存系统，具备高性能和高可用性，能够很好地解决分布式环境下的会话管理和Token认证问题。

本教程将介绍如何基于Redis和Spring Boot 实现会话管理与Token认证，确保应用在高并发、分布式架构中具备良好的性能和扩展性。

一、使用场景

  1. 分布式系统：当系统部署在多个服务实例上时，服务器本地的Session无法跨实例共享，而Redis能作为集中式存储，帮助管理所有实例的会话信息。
  2. 无状态认证：基于Token认证机制的实现，特别是JWT（JSON Web Token），适用于用户登录后通过Token进行认证，避免在每次请求时重新查询数据库或读取Session。
  3. 高并发场景：在高并发的情况下，Redis的高吞吐量和低延迟能够保证会话管理和认证机制的高效性。

二、原理解析

1. 会话管理

传统的会话管理通过在服务器端保存用户的会话状态（Session），并通过客户端（通常是浏览器）保存的Session ID与服务器进行匹配，来确定用户身份。在分布式环境下，本地Session机制无法保证跨实例共享，而Redis作为集中式存储，能够提供跨服务实例的会话共享机制。

2. Token认证

Token认证，尤其是基于JWT的认证方式，是一种无状态认证方案。与传统的Session机制不同，JWT将用户信息封装在Token中，发送给客户端，客户端在后续请求中携带该Token进行认证，服务器通过验证Token来确定用户身份。Redis可以用作存储Token的有效期或与其他用户数据的映射。

3. Redis在会话管理和Token认证中的角色
  • 会话管理：将用户的会话信息存储在Redis中，保证分布式系统中不同实例对会话的共享访问。
  • Token认证：存储Token的有效性和用户信息，或用于存储黑名单Token（已失效或已注销的Token）。

三、解决方案实现

1. 环境配置

首先，在pom.xml中添加Redis和Spring Security相关依赖：

<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

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

    <!-- JWT Token -->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-api</artifactId>
        <version>0.11.2</version>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-impl</artifactId>
        <version>0.11.2</version>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-jackson</artifactId>
        <version>0.11.2</version>
    </dependency>
</dependencies>

在application.yml中配置Redis：

spring:
  redis:
    host: localhost
    port: 6379
    timeout: 6000ms
2. Redis会话管理实现

在Spring Boot中，我们可以通过Redis来管理会话信息，下面的示例代码展示如何使用Redis来存储用户会话信息。

配置Redis序列化器

为了使得对象能够存储在Redis中，我们需要配置Redis的序列化方式。

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        
        // 设置Key和Value的序列化器
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        
        return template;
    }
}
使用Redis存储Session信息

我们可以在用户登录后将会话信息存入Redis中。

@Service
public class SessionService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void saveSession(String sessionId, Object sessionData) {
        redisTemplate.opsForValue().set(sessionId, sessionData, 30, TimeUnit.MINUTES); // 会话有效期30分钟
    }

    public Object getSession(String sessionId) {
        return redisTemplate.opsForValue().get(sessionId);
    }

    public void deleteSession(String sessionId) {
        redisTemplate.delete(sessionId);
    }
}
3. Token认证实现
JWT生成与解析

JWT是无状态的认证方式，将用户信息封装在Token中，通过数字签名保证Token的安全性。我们使用jjwt库来生成和解析JWT。

JWT工具类
@Service
public class JwtTokenProvider {

    private static final String SECRET_KEY = "yourSecretKey";

    // 生成Token
    public String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + 3600000)) // Token有效期1小时
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }

    // 解析Token
    public String getUsernameFromToken(String token) {
        return Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
    }

    // 验证Token是否过期
    public boolean isTokenExpired(String token) {
        Date expiration = Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody()
                .getExpiration();
        return expiration.before(new Date());
    }
}
JWT拦截器实现

为了在每次请求时验证Token的有效性，我们可以通过拦截器在请求到达控制器之前进行校验。

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    @Autowired
    private JwtTokenProvider jwtTokenProvider;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String token = getTokenFromRequest(request);
        
        if (token != null && !jwtTokenProvider.isTokenExpired(token)) {
            String username = jwtTokenProvider.getUsernameFromToken(token);
            // 在SecurityContext中设置认证信息
            UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(username, null, new ArrayList<>());
            SecurityContextHolder.getContext().setAuthentication(authentication);
        }
        
        filterChain.doFilter(request, response);
    }

    private String getTokenFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}
将拦截器添加到Spring Security配置中

我们需要将JwtAuthenticationFilter加入到Spring Security的过滤器链中。

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private JwtAuthenticationFilter jwtAuthenticationFilter;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .antMatchers("/login", "/register").permitAll()  // 登录、注册请求不需要认证
            .anyRequest().authenticated()
            .and()
            .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
    }
}
4. Token与Redis的结合

为了进一步增强安全性，我们可以将生成的Token存储在Redis中，并设置一个过期时间。当Token失效或用户登出时，将其从Redis中移除。

@Service
public class TokenService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private JwtTokenProvider jwtTokenProvider;

    public String createToken(String username) {
        String token = jwtTokenProvider.generateToken(username);
        redisTemplate.opsForValue().set(username, token, 1, TimeUnit.HOURS);  // Token存储在Redis中，1小时过期
        return token;
    }

    public boolean validateToken(String token) {
        String username = jwt

        String username = jwtTokenProvider.getUsernameFromToken(token);
        String redisToken = (String) redisTemplate.opsForValue().get(username);
        return token.equals(redisToken) && !jwtTokenProvider.isTokenExpired(token);
    }

    public void invalidateToken(String username) {
        redisTemplate.delete(username);  // 从Redis中移除Token
    }
}
5. 登录接口实现

用户登录成功后，生成Token并存储到Redis中，同时将Token返回给客户端。客户端在后续的请求中携带此Token。

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

    @Autowired
    private TokenService tokenService;
    @Autowired
    private AuthenticationManager authenticationManager;

    @PostMapping("/login")
    public ResponseEntity<?> login(@RequestBody LoginRequest loginRequest) {
        try {
            // 认证用户
            Authentication authentication = authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(
                    loginRequest.getUsername(), loginRequest.getPassword()));
            
            SecurityContextHolder.getContext().setAuthentication(authentication);
            
            // 生成Token并存储到Redis
            String token = tokenService.createToken(loginRequest.getUsername());
            
            return ResponseEntity.ok(new JwtResponse(token));
        } catch (AuthenticationException e) {
            return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Authentication failed");
        }
    }

    @PostMapping("/logout")
    public ResponseEntity<?> logout(HttpServletRequest request) {
        String token = getTokenFromRequest(request);
        if (token != null) {
            String username = jwtTokenProvider.getUsernameFromToken(token);
            tokenService.invalidateToken(username);  // 从Redis中移除Token
        }
        return ResponseEntity.ok("Logout successful");
    }

    private String getTokenFromRequest(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (StringUtils.hasText(bearerToken) && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }
}
6. 请求流程示例
  1. 用户登录：用户提供用户名和密码，通过/auth/login接口进行登录。成功后，服务器生成JWT Token并存入Redis，并返回给客户端。
  2. Token携带请求：客户端在后续的请求中，将Token放在Authorization头部中，发送到服务器。服务器在收到请求后，通过JWT解析Token，验证有效性。
  3. 登出操作：用户在登出时，前端请求/auth/logout接口，服务器将用户的Token从Redis中移除，Token失效。

四、Redis会话管理与Token认证效果

  1. 高效性能：Redis的高并发读写能力保证了在高并发场景下的会话存储与Token验证的高效性。
  2. 分布式支持：使用Redis作为集中存储，可以确保在多实例或分布式部署环境中共享会话数据，避免本地Session的局限性。
  3. 安全性增强：通过Redis存储Token以及Token的有效期控制，可以快速实现Token的失效处理，增强了安全性。

五、总结

Redis不仅能解决分布式环境下会话共享的问题，也能通过高效存储和快速读取实现了Token认证的高性能处理。在Spring Boot 中，使用Redis与JWT结合的方案为分布式架构提供了强大的认证与授权支持。

使用Spring Boot和Redis实现会话管理
m0_71777195的博客
06-17 518
本文介绍了如何使用Spring Boot和Redis实现会话管理。通过使用Redis作为会话存储介质，可以提供高性能、可靠性和灵活性的会话管理功能。通过配置Redis连接和会话管理器，以及使用HttpSession对象操作会话数据，我们可以在Spring Boot应用程序中轻松实现会话管理的需求。希望本文对你理解如何使用Spring Boot和Redis实现会话管理有所帮助。在实际开发中，根据具体的业务需求和性能要求，可以进一步优化和扩展会话管理的实现。
Redis实现分布式会话 使用Token实现登录注册 分布式会话拦截器 Token实现请求拦截 SpringBoot整合拦截器
weixin_43700943的博客
09-17 730
1.用户注册时生成Token @ApiOperation(value = "用户注册", notes = "用户注册", httpMethod = "POST") @PostMapping("/regist") public IMOOCJSONResult regist(@RequestBody UserBO userBO, HttpServletRequest request,
distributed-session:基于Redis实现的分布式会话管理
05-02
distributed-session 基于Redis实现的分布式会话管理，如您觉得该项目对您有用，欢迎点击右上方的Star按钮，给予支持！ 更新 使用客户端jedis的一致性哈稀进行分片存储 兼容浏览器禁止cookie的情况，从请求中获取 本地运行说明 应用启动前，需要在本地启动两个redis实例或修改applicationContext.xml中redisSessionManager的redisServer属性值。
Redis最佳实践——用户会话管理详解
最新发布
专注分享技术、实用优质教程、资源
04-05 1164
Redis最佳实践——用户会话管理详解
滚雪球学Redis[7.0讲]：Redis在Web应用中的会话管理：实现、优化与安全性！
**My Coding Family**
10-16 1069
在上期内容【6.4 Redis消息队列】中，我们深入探讨了Redis作为消息队列的应用。在分布式系统中，消息队列通过异步处理提高了系统的扩展性和解耦能力。Redis的发布/订阅机制和队列结构使得它成为高效的消息处理工具。我们学习了如何利用Redis处理大规模并发请求及流量激增场景。然而，消息队列只是Redis众多应用中的一部分。在Web应用开发中，另一个关键功能是会话管理。会话管理在Web应用中用于跟踪用户状态，确保在用户与服务器的交互中维持连续的身份验证信息。
Redis应用实战---结合Spring Session实现会话管理
自律使我自由
12-29 362
会话（Session）管理在web开发中是一种不可或缺的功能，Redis集合Spring Session可以轻松便捷的实现分布式集群中的会话管理。 背景信息 由于HTTP的特征之一就是无状态，即用户在访问同一个网站的不同页面时进行的某些交互性操作将毫无意义 ...
Redis实现用户会话
TOMORROW6COME的博客
07-20 1636
Springsession框架就是解决方案，提供一组API和实现，用于管理用户的session信息，它把servlet容器实现的httpsession替换成Springsession，专注于解决session管理问题，Session信息存储在Redis中，可简单快速无缝的集成到我们的应用中。SpringSession的特性：提供用户session管理的API和实现；提供HttpSession，以中立的方式取代web容器的session，比如tomcat中的session；
Shiro学习（4）整合Redis统一会话管理
leonsccott的博客
07-13 785
一、shiro的会话管理 SessionManager 会话管理器：管理所有Subject的session创建、删除、失效、验证、维护等工作。 由SecurityManager管理，可以把SessionManager看作为接口。 Shiro提供了三种默认实现： DefaultSessionManager：用于JavaSE环境 ServletContainerSessionManager（默认存放位置HttpSession）：用于Web环境，直接使用servlet容器的会话。 DefaultWebSessi
springboot整和jwt、shiro、redis实现token自动刷新
08-19
Shiro是Java的一个安全框架，提供了会话管理、权限控制、身份认证等特性，与Spring Boot结合可以轻松实现权限控制。在Spring Boot中集成Shiro，我们可以通过编写自定义的Realm，对接JWT的验证逻辑，使得Shiro能够...
Springboot前后端分离，JWT+Security+Redis实现登录拦截及权限认证，包含全局异常处理以及统一返回风格
12-25
在本项目中，我们将探讨如何利用Spring Boot、JWT（JSON Web Token）、Spring Security和Redis来实现一个高效的登录拦截和权限认证系统，同时实现全局异常处理和统一的API返回风格。 1. **Spring Boot**：Spring ...
Java架构直通车——用Redis实现分布式会话
01-20
总之，分布式会话管理是分布式系统设计中的关键环节，而Redis作为高效的数据存储系统，是实现这一目标的有效工具。通过理解会话的本质和Redis的工作原理，开发者能够构建出更稳定、可扩展的分布式应用。
SpringBoot_Shiro_JWT_Redis:SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新
05-14
SpringBoot_Shiro_JWT_Redis SpringBoot整合Shiro、JWT和Redis实现token登录授权验证以及token刷新 前端代码为一个博客页面，使用了Semantic UI框架结合thymeleaf模板 SpringBoot结合JWT+Shiro+Redis实现token无状态登录授权 [TOC] 一、引言 ​ 在微服务中我们一般采用的是无状态登录，而传统的session方式，在前后端分离的微服务架构下，如继续使用则必将要解决跨域sessionId问题、集群session共享问题等等。这显然是费力不讨好的，而整合shiro，却很不恰巧的与我们的期望有所违背，原因： 　　（1）shiro默认的拦截跳转都是跳转url页面，而前后端分离后，后端并无权干涉页面跳转。 　　（2）shiro默认使用的登录拦截校验机制恰恰就是使用的session。 　　这当然不是我们
Session+Redis，Token+Redis，JWT+Redis，用户身份认证，到底选择哪种更合适？
Java程序员专栏
05-31 1543
在选择用户身份认证方案时，需要根据具体的应用场景和需求进行评估和选择。如果应用需要长时间保持用户登录状态，且对性能要求不是特别高，可以选择Session+Redis方案。如果应用需要频繁验证用户身份，且对性能要求较高，可以选择Token+Redis方案。如果应用是分布式系统或微服务架构，需要实现无状态的身份验证和授权，可以选择JWT+Redis方案。需要注意的是，以上方案并不是孤立的，可以根据实际情况进行组合和优化，以满足特定的业务需求。同时，无论选择哪种方案，都需要确保系统的安全性和稳定性。
Redis-Token
weixin_30549657的博客
07-10 207
比较redis、数据库、文件存token https://www.cnblogs.com/penglei-it/p/wx_yh.html 转载于:https://www.cnblogs.com/wzdnwyyu/p/11163649.html
Spring专区-梳理Spring-Session Redis分布式会话管理的实现
lidelin10的博客
04-12 451
Spring-Session 2.1.x中对spring-session-data-redis中分布式会话设计的一些理解 文章目录Redis存储结构Session信息存储Principal与Session之间的映射同一时刻过期会话集合会话有效key会话事件PUB/SUBKeyspace event notificationsRedisSessionRedisOperationsSessionR...
分布式应用中session会话管理-基于redis
Diors222的博客
05-14 314
session会话在单台服务器的情况下不会出现共享问题，然而在集群或者分布式应用中，则会出现session共享问题。 解决方案 基于cookie存储，但是存在安全问题； 基于数据库存储，用户量大的情况下对db压力大； 服务器内置的session复制，如was提供复制功能，但是会损耗服务器内存； 采用Nginx请求分发，绑定ip，只能访问用户第一次访问的服务器，不能支持负载均衡； 基于noSql，...
Shiro + Redis自定义session会话管理
iLeeHan
01-23 1275
Shiro + Redis自定义session会话管理 博客：Shiro + Redis自定义session会话管理 此图非常重要！！！镇楼 0x001 重写SessionManager shiro提供了三种默认实现： DefaultSessionManager： 用于java se 环境 ServletContainerSessionManager：默认使用的实现，Servlet容器管理 D...
redis对token的管理
若星汉灿烂
11-21 2737
实现 登陆时 //存储key到redis shi效未1920秒 RedisUtils.setObject(id,key,1920); 接口判断读取时 /** * 验证token * @param id * @param version_code * @return int * @throws ParseException *...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值