脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → 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 作为缓存，主要包括：

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

9.2 会话管理

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

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

9.3 消息队列

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

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

10. 性能优化

10.1 连接管理

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

10.2 数据结构选择

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

10.3 缓存策略

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

11. 监控与维护

11.1 监控指标

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

11.2 维护操作

  1. 数据备份：定期备份 Redis 数据
  2. 数据清理：清理过期数据和无用数据
  3. 性能优化：根据监控结果优化 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内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • 手把手教你从零设计一个java日志框架

    手把手教你从零设计一个java日志框架

    Java里的各种日志框架，相信大家都不陌生。Log4j/Log4j2/Logback/jboss logging等等，其实这些日志框架核心结构没什么区别，只是细节实现上和其性能上有所不同。本文带你从零开始，一步一步的设计一个日志框架
    2021-02-02
  • Java中security与shiro的区别详解

    Java中security与shiro的区别详解

    这篇文章主要介绍了Java中security与shiro的区别详解,Spring Security在架构上将认证与授权分离,并提供了扩展点,它是一个轻量级的安全框架,它确保基于Spring的应用程序提供身份验证和授权支持,需要的朋友可以参考下
    2023-08-08
  • Spring中的@CrossOrigin注册处理方法源码解析

    Spring中的@CrossOrigin注册处理方法源码解析

    这篇文章主要介绍了Spring中的@CrossOrigin注册处理方法源码解析,@CrossOrigin是基于@RequestMapping,@RequestMapping注释方法扫描注册的起点是equestMappingHandlerMapping.afterPropertiesSet(),需要的朋友可以参考下
    2023-12-12
  • 详解SpringBoot 统一后端返回格式的方法

    详解SpringBoot 统一后端返回格式的方法

    今天我们来聊一聊在基于SpringBoot前后端分离开发模式下，如何友好的返回统一的标准格式以及如何优雅的处理全局异常，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友参考下吧
    2022-05-05
  • IntelliJ IDEA 创建 Java 项目及创建 Java 文件并运行的详细步骤

    IntelliJ IDEA 创建 Java 项目及创建 Java 文件并运行的详细步骤

    这篇文章主要介绍了IntelliJ IDEA 创建 Java 项目及创建 Java 文件并运行的详细步骤,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-11-11
  • java小程序火锅店点餐系统

    java小程序火锅店点餐系统

    这篇文章主要介绍了java小程序火锅店点餐系统,采用Java语言和Vue技术,以小程序模式实现的火锅点菜系统,文中提供了解决思路和部分实现代码,需要的朋友可以参考下
    2023-03-03
  • SpringBoot多种生产打包方式详解

    SpringBoot多种生产打包方式详解

    生产上发布 Spring Boot 项目时,流程颇为繁琐且低效,但凡代码有一丁点改动,就得把整个项目重新打包部署,耗时费力不说,生成的 JAR 包还特别臃肿,体积庞大,本文给大家介绍了SpringBoot多种生产打包方式,需要的朋友可以参考下
    2025-01-01
  • Log4j详细使用教程_动力节点Java学院整理

    Log4j详细使用教程_动力节点Java学院整理

    这篇文章主要为大家详细介绍了Log4j的使用教程，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2017-08-08
  • springboot的yml配置文件通过db2的方式整合mysql的教程

    springboot的yml配置文件通过db2的方式整合mysql的教程

    这篇文章主要介绍了springboot的yml配置文件通过db2的方式整合mysql的教程,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-09-09
  • Elasticsearch term 查询之精确值搜索功能实现

    Elasticsearch term 查询之精确值搜索功能实现

    term查询是Elasticsearch中用于精确值搜索的一种基本方式,通过了解 term 查询的工作原理和使用方法,你可以更好地利用 Elasticsearch 进行结构化数据的搜索和分析,本文将详细介绍 term 查询的工作原理、使用场景以及如何在 Elasticsearch 中应用它,感兴趣的朋友一起看看吧
    2024-06-06

最新评论