Redis实现会话管理和token认证的示例代码_Redis

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

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

一、使用场景

分布式系统：当系统部署在多个服务实例上时，服务器本地的session无法跨实例共享，而redis能作为集中式存储，帮助管理所有实例的会话信息。
无状态认证：基于token认证机制的实现，特别是jwt（json web token），适用于用户登录后通过token进行认证，避免在每次请求时重新查询数据库或读取session。
高并发场景：在高并发的情况下，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) &amp;&amp; !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. 请求流程示例

用户登录：用户提供用户名和密码，通过/auth/login接口进行登录。成功后，服务器生成jwt token并存入redis，并返回给客户端。
token携带请求：客户端在后续的请求中，将token放在authorization头部中，发送到服务器。服务器在收到请求后，通过jwt解析token，验证有效性。
登出操作：用户在登出时，前端请求/auth/logout接口，服务器将用户的token从redis中移除，token失效。

四、redis会话管理与token认证效果

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

五、总结

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

到此这篇关于redis实现会话管理和token认证的示例代码的文章就介绍到这了,更多相关redis 会话管理和token认证内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

Redis实现会话管理和token认证的示例代码

2025年04月22日 • Redis •我要评论