首页 > 软件编程 > java > SpringBoot集成Redis6.0

SpringBoot集成Redis6.0的实现示例

2026-04-13 09:18:05 作者：亚历克斯神

本文主要介绍了SpringBoot集成Redis6.0的实现示例,包括多线程I/O、ACL权限控制、RESP3协议等新特性,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

前言

Redis 是一种高性能的键值存储数据库，被广泛应用于缓存、会话管理、消息队列等场景。Redis 6.0 带来了许多新特性，如多线程 I/O、ACL 权限控制、RESP3 协议等。本文将深入探讨 Spring Boot 与 Redis 6.0 的集成方法和最佳实践，帮助你构建更高效、更可靠的应用。

1. Redis 6.0 新特性

1.1 多线程 I/O

Redis 6.0 引入了多线程 I/O，提高了网络处理能力，特别是在高并发场景下。

# 查看 Redis 版本
redis-server --version
# 配置多线程 I/O
# 在 redis.conf 中设置
io-threads 4
io-threads-do-reads yes

1.2 ACL 权限控制

Redis 6.0 引入了 ACL（Access Control List），提供了更细粒度的权限控制。

# 创建用户并设置权限
ACL SETUSER alice on >password ~* +@all
# 查看用户权限
ACL GETUSER alice
# 登录验证
AUTH alice password

1.3 RESP3 协议

Redis 6.0 引入了 RESP3 协议，提供了更丰富的数据类型和更高效的通信方式。

1.4 其他新特性

客户端缓存：支持客户端缓存，减少网络往返
SSL 支持：内置 SSL 支持，提高安全性
时间序列数据结构：优化时间序列数据的存储和查询

2. Spring Boot 与 Redis 集成

2.1 添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- 可选：使用 Lettuce 作为 Redis 客户端 -->
<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
</dependency>
<!-- 可选：使用 Jedis 作为 Redis 客户端 -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

2.2 配置 Redis

spring:
  redis:
    host: localhost
    port: 6379
    password: password
    database: 0
    timeout: 10000
    lettuce:
      pool:
        max-active: 8
        max-wait: -1
        max-idle: 8
        min-idle: 0

2.3 Redis 模板配置

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        // 设置序列化器
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
        template.afterPropertiesSet();
        return template;
    }
    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

3. Redis 操作示例

3.1 基本操作

@Service
public class RedisService {
    private final RedisTemplate<String, Object> redisTemplate;
    private final StringRedisTemplate stringRedisTemplate;
    @Autowired
    public RedisService(RedisTemplate<String, Object> redisTemplate, StringRedisTemplate stringRedisTemplate) {
        this.redisTemplate = redisTemplate;
        this.stringRedisTemplate = stringRedisTemplate;
    }
    // 字符串操作
    public void setString(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }
    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
    // 哈希操作
    public void setHash(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }
    public Object getHash(String key, String hashKey) {
        return redisTemplate.opsForHash().get(key, hashKey);
    }
    // 列表操作
    public void addToList(String key, Object value) {
        redisTemplate.opsForList().rightPush(key, value);
    }
    public List<Object> getList(String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }
    // 集合操作
    public void addToSet(String key, Object value) {
        redisTemplate.opsForSet().add(key, value);
    }
    public Set<Object> getSet(String key) {
        return redisTemplate.opsForSet().members(key);
    }
    // 有序集合操作
    public void addToZSet(String key, Object value, double score) {
        redisTemplate.opsForZSet().add(key, value, score);
    }
    public Set<Object> getZSet(String key) {
        return redisTemplate.opsForZSet().range(key, 0, -1);
    }
}

3.2 事务操作

@Service
public class RedisTransactionService {
    private final RedisTemplate<String, Object> redisTemplate;
    @Autowired
    public RedisTransactionService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    public void executeTransaction() {
        redisTemplate.execute(new SessionCallback<Object>() {
            @Override
            public Object execute(RedisOperations operations) throws DataAccessException {
                operations.multi();
                // 执行多个操作
                operations.opsForValue().set("key1", "value1");
                operations.opsForValue().set("key2", "value2");
                operations.opsForValue().set("key3", "value3");
                // 提交事务
                return operations.exec();
            }
        });
    }
}

3.3 管道操作

@Service
public class RedisPipelineService {
    private final RedisTemplate<String, Object> redisTemplate;
    @Autowired
    public RedisPipelineService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    public List<Object> executePipeline() {
        return redisTemplate.executePipelined(new RedisCallback<Object>() {
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
                // 执行多个操作
                connection.set(serializer.serialize("key1"), serializer.serialize("value1"));
                connection.set(serializer.serialize("key2"), serializer.serialize("value2"));
                connection.set(serializer.serialize("key3"), serializer.serialize("value3"));
                return null;
            }
        });
    }
}

4. Redis 缓存集成

4.1 缓存配置

@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))
            .prefixCacheNameWith("cache:")
            .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new Jackson2JsonRedisSerializer<>(Object.class)));
        return RedisCacheManager.builder(redisConnectionFactory)
            .cacheDefaults(config)
            .build();
    }
}

4.2 使用缓存

@Service
public class UserService {
    private final UserRepository userRepository;
    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    @Cacheable(value = "users", key = "#id")
    public User getUserById(Long id) {
        return userRepository.findById(id)
            .orElseThrow(() -> new UsernameNotFoundException("User not found"));
    }
    @CachePut(value = "users", key = "#user.id")
    public User saveUser(User user) {
        return userRepository.save(user);
    }
    @CacheEvict(value = "users", key = "#id")
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

5. Redis 消息队列

5.1 配置消息监听器

@Configuration
public class RedisMessageListenerConfig {
    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory redisConnectionFactory) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(redisConnectionFactory);
        return container;
    }
    @Bean
    public MessageListenerAdapter messageListenerAdapter() {
        return new MessageListenerAdapter(new RedisMessageListener());
    }
}

5.2 消息监听器

public class RedisMessageListener implements MessageListener {
    @Override
    public void onMessage(Message message, byte[] pattern) {
        String channel = new String(message.getChannel());
        String body = new String(message.getBody());
        System.out.println("Received message from channel " + channel + ": " + body);
    }
}

5.3 发送消息

@Service
public class RedisMessageService {
    private final RedisTemplate<String, Object> redisTemplate;
    @Autowired
    public RedisMessageService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    public void sendMessage(String channel, Object message) {
        redisTemplate.convertAndSend(channel, message);
    }
}

6. Redis 分布式锁

6.1 实现分布式锁

@Service
public class RedisLockService {
    private final RedisTemplate<String, Object> redisTemplate;
    @Autowired
    public RedisLockService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    public boolean acquireLock(String lockKey, String requestId, long expireTime) {
        Boolean result = redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, expireTime, TimeUnit.MILLISECONDS);
        return result != null && result;
    }
    public boolean releaseLock(String lockKey, String requestId) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        RedisScript<Long> redisScript = RedisScript.of(script, Long.class);
        Long result = redisTemplate.execute(redisScript, Collections.singletonList(lockKey), requestId);
        return result != null && result > 0;
    }
}

6.2 使用分布式锁

@Service
public class OrderService {
    private final RedisLockService redisLockService;
    @Autowired
    public OrderService(RedisLockService redisLockService) {
        this.redisLockService = redisLockService;
    }
    public void createOrder(Order order) {
        String lockKey = "order:lock:" + order.getProductId();
        String requestId = UUID.randomUUID().toString();
        try {
            if (redisLockService.acquireLock(lockKey, requestId, 5000)) {
                // 执行业务逻辑
                System.out.println("Acquired lock, processing order");
                // 模拟业务处理
                Thread.sleep(2000);
            } else {
                throw new RuntimeException("Failed to acquire lock");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        } finally {
            redisLockService.releaseLock(lockKey, requestId);
        }
    }
}

7. Redis 6.0 高级特性

7.1 客户端缓存

@Service
public class RedisClientCacheService {
    private final RedisTemplate<String, Object> redisTemplate;
    @Autowired
    public RedisClientCacheService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    public void enableClientCache() {
        // 启用客户端缓存
        redisTemplate.execute((RedisCallback<Void>) connection -> {
            connection.setClientName("client1");
            return null;
        });
    }
}

7.2 ACL 权限控制

@Configuration
public class RedisAclConfig {
    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName("localhost");
        config.setPort(6379);
        config.setPassword(RedisPassword.of("password"));
        config.setDatabase(0);
        LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
            .commandTimeout(Duration.ofSeconds(10))
            .build();
        return new LettuceConnectionFactory(config, clientConfig);
    }
}

8. 最佳实践

8.1 连接池配置

spring:
  redis:
    lettuce:
      pool:
        max-active: 100
        max-wait: 10000
        max-idle: 50
        min-idle: 10

8.2 序列化配置

@Configuration
public class RedisSerializationConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        // 使用 Jackson2JsonRedisSerializer 序列化值
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(serializer);
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);
        template.afterPropertiesSet();
        return template;
    }
}

8.3 错误处理

@Service
public class RedisErrorHandlingService {
    private final RedisTemplate<String, Object> redisTemplate;
    @Autowired
    public RedisErrorHandlingService(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    public Object getWithErrorHandling(String key) {
        try {
            return redisTemplate.opsForValue().get(key);
        } catch (RedisConnectionFailureException e) {
            // 处理连接失败
            System.err.println("Redis connection failed: " + e.getMessage());
            return null;
        } catch (RedisSystemException e) {
            // 处理系统错误
            System.err.println("Redis system error: " + e.getMessage());
            return null;
        }
    }
}

9. 案例分析

9.1 缓存系统

某电商系统使用 Redis 作为缓存，主要包括：

商品缓存：缓存商品信息，提高查询性能
用户缓存：缓存用户信息，减少数据库查询
订单缓存：缓存订单信息，提高订单处理速度
热点数据缓存：缓存热点商品数据，应对高并发

9.2 会话管理

某 Web 应用使用 Redis 管理会话，主要包括：

会话存储：将会话数据存储在 Redis 中
会话过期：设置会话过期时间，自动清理过期会话
会话共享：在多实例部署中实现会话共享

9.3 消息队列

某系统使用 Redis 作为消息队列，主要包括：

任务队列：处理异步任务
事件通知：发送系统事件通知
消息广播：向多个消费者广播消息

10. 性能优化

10.1 连接管理

使用连接池：配置合理的连接池大小
连接超时：设置合理的连接超时时间
连接验证：定期验证连接有效性

10.2 数据结构选择

选择合适的数据结构：根据业务场景选择合适的 Redis 数据结构
避免大键：避免存储过大的键值对
使用管道：批量执行命令，减少网络往返

10.3 缓存策略

缓存过期：设置合理的缓存过期时间
缓存预热：在系统启动时预热缓存
缓存更新：使用合适的缓存更新策略

11. 监控与维护

11.1 监控指标

内存使用：监控 Redis 内存使用情况
命令执行：监控命令执行次数和耗时
连接数：监控 Redis 连接数
命中率：监控缓存命中率

11.2 维护操作

数据备份：定期备份 Redis 数据
数据清理：清理过期数据和无用数据
性能优化：根据监控结果优化 Redis 配置

12. 未来趋势

12.1 Redis 7.0 新特性

Redis 7.0 带来了许多新特性，如：

时间序列数据结构：更强大的时间序列数据支持
RDB 快照改进：更高效的 RDB 快照
内存管理改进：更智能的内存管理

12.2 Spring Data Redis 改进

Spring Data Redis 不断改进，提供更强大的功能：

反应式支持：更好的反应式编程支持
函数式编程：支持函数式编程风格
更丰富的 API：提供更丰富的 Redis 操作 API

结语

Spring Boot 与 Redis 6.0 的集成是构建高性能、可扩展应用的重要组成部分。通过本文的介绍，你应该对 Spring Boot 与 Redis 6.0 的集成方法和最佳实践有了更深入的了解。

Redis 6.0 的新特性为我们提供了更强大的功能和更好的性能，通过合理使用这些特性，我们可以构建更高效、更可靠的应用。

到此这篇关于SpringBoot集成Redis6.0的实现示例的文章就介绍到这了,更多相关SpringBoot集成Redis6.0内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！