devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

如何使用Spring Boot框架整合Redis：超详细案例教程_spring-boot-starter-data-redis

作者：知新_RL | 2024-07-17 08:01:54

赞

踩

spring-boot-starter-data-redis

目录

# 为什么选择Spring Boot与Redis整合？

1. 更新 pom.xml

2. 配置application.yml

3. 创建 Redis 配置类

4. Redis 操作类

5. 创建控制器

6. 启动应用程序

7. 测试

# 为什么选择Spring Boot与Redis整合？

将Spring Boot与Redis整合可以充分利用两者的优势，简化开发并提升应用性能。具体好处包括：

  1. 缓存支持：使用Redis作为缓存层可以极大提高应用的响应速度和可扩展性。
  2. 会话管理：将用户会话存储在Redis中，可以实现分布式会话管理。
  3. 数据持久性：Redis的持久化功能可以确保数据的可靠性。
  4. 简化配置：Spring Boot的自动配置和Redis Starter可以简化配置工作。

了解了这些基础知识后，接下来将详细介绍如何在Spring Boot项目中整合Redis，包括依赖配置、连接设置、基本操作和应用案例。

1. 更新 pom.xml

确保你的项目包含了以下依赖。如果使用 Spring Initializr 已经添加了 spring-boot-starter-data-redis，这里就无需再次添加。

  1. <dependencies>
  2.     <dependency>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-data-redis</artifactId>
  5.     </dependency>
  6.     <dependency>
  7.         <groupId>org.apache.commons</groupId>
  8.         <artifactId>commons-pool2</artifactId>
  9.     </dependency>
  10. </dependencies>

commons-pool2 是用于 Lettuce 连接池配置的依赖。

2. 配置application.yml

补充：

  • Spring Boot 1.x 和 Spring Boot 2.x 中，spring.redis.host 用于配置 Redis 连接属性。

  • Spring Boot 3.x 中，spring.redis.host 已经弃用。

  • 从 Spring Boot 2.x 开始，引入了 spring.data.redis 作为配置 Redis 连接的方式，并且在 Spring Boot 3.x 中也可以使用 spring.data.redis 进行配置。

在 src/main/resources 目录下，添加 Redis 连接池的配置。

application.yml:

  1. server:
  2.   port: 8080
  3.  
  4. spring:
  5.   redis:
  6.     host: 127.0.0.1  # 地址
  7.     port: 6379  # 端口号
  8.     database: 0  # 数据库索引（默认为0）
  9.     timeout: 1800000  # 连接超时时间（毫秒）
  10.     lettuce:
  11.       pool:
  12.         max-active: 20  # 连接池最大连接数（使用负值表示没有限制）
  13.         max-wait: -1  # 最大阻塞等待时间（负数表示没有限制）
  14.         max-idle: 5  # 连接池中最大空闲连接
  15.         min-idle: 0  # 连接池中最小空闲连接

3. 创建 Redis 配置类

在 com.lei.my_redis.config 包中创建或更新 RedisConfig 类，使用连接池配置 LettuceConnectionFactory。

  1. package com.lei.my_redis.config;
  2.  
  3. import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
  4. import org.springframework.cache.annotation.CachingConfigurerSupport;
  5. import org.springframework.cache.annotation.EnableCaching;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
  9. import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
  10. import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
  11. import org.springframework.data.redis.core.RedisTemplate;
  12. import org.springframework.data.redis.serializer.StringRedisSerializer;
  13.  
  14. @EnableCaching  // 开启缓存
  15. @Configuration  // 配置类
  16. public class RedisConfig extends CachingConfigurerSupport {
  17.  
  18.  
  19.     /**
  20.      * 配置 Redis 连接工厂
  21.      * 意义: LettuceConnectionFactory 是连接 Redis 服务器的入口，它使用了 Lettuce 客户端，并且配置了连接池来提高性能和资源管理
  22.      * @return LettuceConnectionFactory
  23.      */
  24.     @Bean
  25.     public LettuceConnectionFactory redisConnectionFactory() {
  26.         // 配置 Redis 服务器的连接信息
  27.         RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
  28.         redisStandaloneConfiguration.setHostName("localhost");
  29.         redisStandaloneConfiguration.setPort(6379);
  30.         // redisStandaloneConfiguration.setPassword("password"); // 取消注释以设置密码
  31.  
  32.         // 配置连接池
  33.         GenericObjectPoolConfig<Object> poolConfig = new GenericObjectPoolConfig<>();
  34.         poolConfig.setMaxTotal(10);       // 连接池中的最大连接数
  35.         poolConfig.setMaxIdle(5);         // 连接池中的最大空闲连接数
  36.         poolConfig.setMinIdle(1);         // 连接池中的最小空闲连接数
  37.         poolConfig.setMaxWaitMillis(2000); // 连接池获取连接的最大等待时间
  38.  
  39.         // 创建一个带有连接池配置的 Lettuce 客户端配置
  40.         LettucePoolingClientConfiguration lettucePoolingClientConfiguration =
  41.                 LettucePoolingClientConfiguration.builder()
  42.                         .poolConfig(poolConfig)
  43.                         .build();
  44.  
  45.         // 返回带有连接池配置的 Redis 连接工厂
  46.         return new LettuceConnectionFactory(redisStandaloneConfiguration, lettucePoolingClientConfiguration);
  47.     }
  48.  
  49.     /**
  50.      * 配置并返回一个 RedisTemplate 实例，用于执行 Redis 操作
  51.      * 意义: RedisTemplate 提供了一种高级抽象，使得开发者可以通过模板方法操作 Redis，而无需直接处理底层的 Redis 命令。
  52.      * 它支持多种 Redis 操作，例如值操作、哈希操作、列表操作等
  53.      * @return RedisTemplate
  54.      */
  55.     @Bean
  56.     public RedisTemplate<String, Object> redisTemplate() {
  57.         /*
  58.             1.创建 RedisTemplate: 这是 Spring 用于与 Redis 交互的核心类，简化了与 Redis 的交互。
  59.             2.设置连接工厂: 使用前面定义的 LettuceConnectionFactory。
  60.             3.设置序列化器: 设置键和值的序列化器，这里使用 StringRedisSerializer 来将键和值序列化为字符串。
  61.          */
  62.         RedisTemplate<String, Object> template = new RedisTemplate<>();
  63.         template.setConnectionFactory(redisConnectionFactory());  // 设置连接工厂
  64.         template.setKeySerializer(new StringRedisSerializer());  // 设置键的序列化器
  65.         template.setValueSerializer(new StringRedisSerializer()); // 设置值的序列化器
  66.         return template;
  67.     }
  68. }

4. Redis 操作类

保持 Redis 操作类和控制器不变。它们已经实现了基本的 Redis 操作。这里只需更新 RedisService 类以支持连接池即可。

  1. package com.lei.my_redis.service;
  2.  
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.data.redis.core.RedisTemplate;
  5. import org.springframework.stereotype.Service;
  6.  
  7. import java.util.concurrent.TimeUnit;
  8.  
  9. /**
  10.  * RedisService 类提供了简化的 Redis 操作接口，用于在 Spring Boot 应用中存储和检索数据。
  11.  * 它通过 RedisTemplate 与 Redis 服务器交互，执行常见的操作如设置值、获取值、设置值带过期时间和删除值。
  12.  */
  13. @Service
  14. public class RedisService {
  15.  
  16.     /*
  17.         意义: RedisTemplate 是 Spring 提供的一个 Redis 操作模板，它抽象了 Redis 的底层访问，
  18.         使开发者可以用 Java 对象操作 Redis。使用 @Autowired 注解，Spring 自动将配置好的 RedisTemplate 注入到 RedisService 类中
  19.      */
  20.     @Autowired
  21.     private RedisTemplate<String, Object> redisTemplate;
  22.  
  23.     // 作用: 向 Redis 中存储一个键值对
  24.     public void setValue(String key, Object value) {
  25.         redisTemplate.opsForValue().set(key, value);
  26.     }
  27.  
  28.     // 作用: 从 Redis 中获取指定键的值
  29.     public Object getValue(String key) {
  30.         return redisTemplate.opsForValue().get(key);
  31.     }
  32.  
  33.     // 作用: 向 Redis 中存储一个键值对，并设置其过期时间
  34.     // timeout 指定时间量，timeUnit 指定时间单位
  35.     public void setValueWithExpiry(String key, Object value, long timeout, TimeUnit timeUnit) {
  36.         redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
  37.     }
  38.  
  39.     // 作用: 从 Redis 中删除指定键及其对应的值
  40.     public void deleteValue(String key) {
  41.         redisTemplate.delete(key);
  42.     }
  43. }

5. 创建控制器

RedisController 类的实现保持不变。

  1. package com.lei.my_redis.controller;
  2.  
  3. import com.lei.my_redis.service.RedisService;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.web.bind.annotation.GetMapping;
  6. import org.springframework.web.bind.annotation.PostMapping;
  7. import org.springframework.web.bind.annotation.RequestParam;
  8. import org.springframework.web.bind.annotation.RestController;
  9.  
  10. /**
  11.  * RedisController 是一个 REST 控制器类，用于处理客户端发来的 HTTP 请求，并通过调用 RedisService
  12.  * 执行 Redis 数据操作。它提供了三个 API 端点：设置值、获取值和删除值
  13.  * RestController注解作用: 表示这个类是一个 RESTful 控制器，它的所有方法的返回值都会直接作为 HTTP 响应体返回。
  14.  * RestController注解意义: 结合 @Controller 和 @ResponseBody 的功能，简化了返回 JSON 格式数据的开发工作。
  15.  */
  16. @RestController
  17. public class RedisController {
  18.  
  19.     @Autowired
  20.     private RedisService redisService;
  21.  
  22.  
  23.     /**
  24.      * 作用: 处理 HTTP POST 请求，设置 Redis 中的键值对
  25.      * 1.使用 @RequestParam 注解获取请求参数 key 和 value
  26.      * 2.调用 redisService.setValue(key, value) 方法，将 key 和 value 存储到 Redis 中
  27.      * 3.返回一个简单的字符串 "Value set" 作为响应
  28.      * 请求：POST /set?key=myKey&value=myValue
  29.      * 响应："Value set"
  30.      * RequestParam注解：获取请求参数: 它从 HTTP 请求中获取参数，并将这些参数绑定到控制器方法的参数上
  31.      */
  32. //    @PostMapping("/set")
  33.     @GetMapping("/set")
  34.     public String setValue(@RequestParam String key, @RequestParam String value) {
  35.         redisService.setValue(key, value);
  36.         return "Value：(" + key + ") set";
  37.     }
  38.  
  39.     /**
  40.      * 作用: 处理 HTTP GET 请求，从 Redis 中获取指定键的值
  41.      * 1.使用 @RequestParam 注解获取请求参数 key
  42.      * 2.调用 redisService.getValue(key) 方法，从 Redis 中获取 key 对应的值，并将结果转换为 String 类型
  43.      * 3.返回获取的值
  44.      * 请求：GET /get?key=myKey
  45.      * 响应："myValue" // Redis 中对应 `myKey` 的值
  46.      */
  47.     @GetMapping("/get")
  48.     public String getValue(@RequestParam String key) {
  49.         return (String) redisService.getValue(key);
  50.     }
  51.  
  52.     /**
  53.      * 作用: 处理 HTTP POST 请求，删除 Redis 中指定键的值
  54.      * 1.使用 @RequestParam 注解获取请求参数 key
  55.      * 2.调用 redisService.deleteValue(key) 方法，从 Redis 中删除 key 对应的键值对
  56.      * 3.返回一个简单的字符串 "Value deleted" 作为响应
  57.      * 请求：POST /delete?key=myKey
  58.      * 响应："Value deleted"
  59.      */
  60. //    @PostMapping("/delete")
  61.     @GetMapping("/delete")
  62.     public String deleteValue(@RequestParam String key) {
  63.         redisService.deleteValue(key);
  64.         return "Value：(" + key + ") deleted";
  65.     }
  66. }

6. 启动应用程序

SpringBootRedisApplication 主类保持不变。

  1. package com.lei.my_redis;
  2.  
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5.  
  6. @SpringBootApplication
  7. public class MyRedisApplication {
  8.  
  9.     public static void main(String[] args) {
  10.         SpringApplication.run(MyRedisApplication.class, args);
  11.     }
  12.  
  13. }

7. 测试

启动应用程序后，可以选中通过 Postman 或浏览器访问以下 URL，验证 Redis 操作是否成功。

  • 设置值: POST http://localhost:8080/set?key=mykey&value=myvalue
  • 获取值: GET http://localhost:8080/get?key=mykey
  • 删除值: POST http://localhost:8080/delete?key=mykey

案例1：设置值

案例2：获取值

案例3：删除值

成功在 Spring Boot 项目中整合了 Redis 并配置了连接池。我们使用连接池可以显著提高 Redis 操作的性能和资源管理效率。

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号