Spring Boot集成RedisTemplate进行数据存储教程

spring:
  redis:
    host: localhost
    port: 6379
    # password: your_redis_password # 如果Redis有密码
    # database: 0 # 选择Redis数据库，默认为0

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class TokenService {

    private final RedisTemplate<String, Object> redisTemplate;

    // 推荐使用构造器注入
    public TokenService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public void storeToken(String userId, String token) {
        // 使用opsForValue()存储简单的键值对
        redisTemplate.opsForValue().set("user:token:" + userId, token);
    }

    public String getToken(String userId) {
        // 获取令牌
        return (String) redisTemplate.opsForValue().get("user:token:" + userId);
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    /**
     * 配置Jedis连接工厂。
     * 推荐使用LettuceConnectionFactory作为更现代的选择，但此处沿用JedisConnectionFactory以匹配原始问题背景。
     */
    @Bean
    public JedisConnectionFactory jedisConnectionFactory() {
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setHostName("localhost"); // 确保与application.yml一致或直接硬编码
        redisStandaloneConfiguration.setPort(6379);
        // redisStandaloneConfiguration.setPassword(RedisPassword.of("your_password")); // 如果有密码

        return new JedisConnectionFactory(redisStandaloneConfiguration);
    }

    /**
     * 配置RedisTemplate，指定键和值的序列化方式。
     * 对于存储字符串或JSON对象，推荐使用StringRedisSerializer和GenericJackson2JsonRedisSerializer。
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(jedisConnectionFactory());

        // 使用StringRedisSerializer来序列化和反序列化Redis的key值
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer); // Hash的key也使用String序列化

        // 使用GenericJackson2JsonRedisSerializer来序列化和反序列化Redis的value值（默认使用JDK序列化）
        // 这使得存储的对象以JSON字符串形式存储，易于阅读和跨语言互操作
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer); // Hash的value也使用JSON序列化

        template.setEnableTransactionSupport(false); // 根据需要开启或关闭事务支持
        template.afterPropertiesSet();
        return template;
    }
}

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;

@Service
public class AuthenticationService {

    private final RedisTemplate<String, Object> redisTemplate;

    public AuthenticationService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    // 假设AuthenticationSuccessDto是一个包含accessToken等信息的DTO
    public static class AuthenticationSuccessDto {
        private String accessToken;
        private String refreshToken;
        private String tokenType;
        private Object user; // 示例，可以是User对象或其他
        private Long expiresIn;

        // 省略构造器、getter、setter、builder等
        public String getAccessToken() { return accessToken; }
        public String getRefreshToken() { return refreshToken; }
        public String getTokenType() { return tokenType; }
        public Object getUser() { return user; }
        public Long getExpiresIn() { return expiresIn; }
        public AuthenticationSuccessDto setAccessToken(String accessToken) { this.accessToken = accessToken; return this; }
        public AuthenticationSuccessDto setRefreshToken(String refreshToken) { this.refreshToken = refreshToken; return this; }
        public AuthenticationSuccessDto setTokenType(String tokenType) { this.tokenType = tokenType; return this; }
        public AuthenticationSuccessDto setUser(Object user) { this.user = user; return this; }
        public AuthenticationSuccessDto setExpiresIn(Long expiresIn) { this.expiresIn = expiresIn; return this; }
    }

    private static final String USER_TOKENS_KEY_PREFIX = "user:tokens:";

    /**
     * 存储用户认证信息，使用Redis的Hash结构。
     *
     * @param userId 用户ID
     * @param authDto 认证成功DTO
     */
    public AuthenticationSuccessDto storeAuthenticationInfo(String userId, AuthenticationSuccessDto authDto) {
        String hashKey = USER_TOKENS_KEY_PREFIX + userId;

        try {
            // 使用opsForHash().putAll()存储整个DTO，或者opsForHash().put()存储单个字段
            // 这里为了演示，我们存储accessToken到Hash中
            redisTemplate.opsForHash().put(hashKey, "accessToken", authDto.getAccessToken());
            redisTemplate.opsForHash().put(hashKey, "refreshToken", authDto.getRefreshToken());
            redisTemplate.opsForHash().put(hashKey, "expiresIn", authDto.getExpiresIn());

            // 设置整个Hash的过期时间
            if (authDto.getExpiresIn() != null && authDto.getExpiresIn() > 0) {
                redisTemplate.expire(hashKey, authDto.getExpiresIn(), TimeUnit.SECONDS);
            }

        } catch (Exception e) {
            System.err.println("存储认证信息到Redis失败: " + e.getMessage());
            e.printStackTrace();
            // 根据业务需求抛出自定义异常
            throw new RuntimeException("Failed to store authentication info in Redis.", e);
        }
        return authDto;
    }

    /**
     * 从Redis获取用户的访问令牌。
     *
     * @param userId 用户ID
     * @return 访问令牌，如果不存在则返回null
     */
    public String getAccessToken(String userId) {
        String hashKey = USER_TOKENS_KEY_PREFIX + userId;
        return (String) redisTemplate.opsForHash().get(hashKey, "accessToken");
    }
}