Oracle【详解】Spring整合Redis - Powered by Discuz! Archiver

商道如狼道 发表于 2025-2-17 13:48:03

【详解】Spring整合Redis

目次
Spring整合Redis
1. 环境准备
1.1 技能栈
1.2 工具
2. 添加依靠
3. 配置Redis
4. 创建Redis配置类
5. 使用RedisTemplate
6. 测试
7. 总结
1. 添加依靠
2. 配置Redis毗连
3. 创建Redis配置类
4. 创建服务类
5. 创建控制器
6. 启动应用
7. 测试API
1. 添加依靠
2. 配置Redis毗连
application.properties
application.yml
3. 创建Redis配置类
4. 使用RedisTemplate
5. 运行和测试

Spring整合Redis

在现代Web应用开发中，缓存技能是提高应用性能的关键因素之一。Redis作为一个高性能的键值存储体系，被广泛应用于各种场景中，如数据缓存、消息队列等。本文将介绍怎样在Spring框架中整合Redis，实现数据的高效读取和存储。
1. 环境准备

1.1 技能栈

[*]Spring Boot：2.5.0
[*]Redis：6.0.9
[*]Java：11
1.2 工具

[*]IDEA：2021.1
[*]Maven：3.8.1
2. 添加依靠

首先，在pom.xml文件中添加Spring Data Redis和Jedis（Redis客户端）的依靠：
<dependencies>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<dependency>
   <groupId>redis.clients</groupId>
   <artifactId>jedis</artifactId>
</dependency>
</dependencies> 3. 配置Redis

在application.properties或application.yml文件中配置Redis毗连信息：
spring:
redis:
host: 127.0.0.1
port: 6379
password:
database: 0
jedis:
   pool:
   max-active: 8
   max-wait: -1ms
   max-idle: 8
   min-idle: 0 4. 创建Redis配置类

创建一个配置类来配置RedisTemplate，以便在项目中使用自定义的序列化方式：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
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 {

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
   RedisTemplate<String, Object> template = new RedisTemplate<>();
   template.setConnectionFactory(factory);

   // 设置键的序列化方式
   template.setKeySerializer(new StringRedisSerializer());
   // 设置值的序列化方式
   template.setValueSerializer(new GenericJackson2JsonRedisSerializer());

   // 设置哈希键的序列化方式
   template.setHashKeySerializer(new StringRedisSerializer());
   // 设置哈希值的序列化方式
   template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());

   template.afterPropertiesSet();
   return template;
}
} 5. 使用RedisTemplate

在需要使用Redis的地方，通过@Autowired注入RedisTemplate，并使用其提供的方法进行操纵：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class UserService {

@Autowired
private RedisTemplate<String, Object> redisTemplate;

public void setUser(String key, User user) {
   redisTemplate.opsForValue().set(key, user);
}

public User getUser(String key) {
   return (User) redisTemplate.opsForValue().get(key);
}
} 6. 测试

创建一个测试类来验证Redis的集成是否乐成：
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class UserServiceTest {

@Autowired
private UserService userService;

@Test
public void testSetAndGetUser() {
   User user = new User("1", "张三");
   userService.setUser("user:1", user);

   User retrievedUser = userService.getUser("user:1");
   System.out.println(retrievedUser);
}
} 7. 总结

通过上述步调，我们乐成地在Spring Boot项目中集成了Redis，并实现了基本的数据存储和读取功能。Redis的强大之处在于其高性能和丰富的数据结构支持，这使得它成为缓存和消息队列等场景的抱负选择。
希望本文对大家有所帮助，如果有任何题目或建议，接待留言交流！
以上就是关于Spring整合Redis的技能博客文章，希望能对你的学习和工作有所帮助。当然可以！Spring框架与Redis的整合在现代Web应用中非常常见，特别是在需要缓存数据以提高性能的环境下。下面是一个简单的示例，展示怎样在Spring Boot应用中集成Redis，并使用它来存储和检索数据。
1. 添加依靠

首先，在你的pom.xml文件中添加Spring Boot Starter Data Redis依靠：
<dependencies>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>


<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>


<dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   <optional>true</optional>
</dependency>
</dependencies> 2. 配置Redis毗连

在application.properties或application.yml文件中配置Redis毗连信息：
# application.properties
spring.redis.host=localhost
spring.redis.port=6379 或者使用YAML格式：
# application.yml
spring:
redis:
host: localhost
port: 6379 3. 创建Redis配置类

创建一个配置类来配置RedisTemplate，这将用于与Redis进行交互：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
   RedisTemplate<String, Object> template = new RedisTemplate<>();
   template.setConnectionFactory(factory);
   template.setKeySerializer(new StringRedisSerializer());
   template.setValueSerializer(new StringRedisSerializer());
   return template;
}
} 4. 创建服务类

创建一个服务类来处理与Redis的交互逻辑：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class CacheService {

@Autowired
private RedisTemplate<String, Object> redisTemplate;

public void setCacheData(String key, Object value) {
   redisTemplate.opsForValue().set(key, value);
}

public Object getCacheData(String key) {
   return redisTemplate.opsForValue().get(key);
}

public void deleteCacheData(String key) {
   redisTemplate.delete(key);
}
} 5. 创建控制器

创建一个控制器来暴露REST API，以便客户端可以与缓存服务进行交互：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/cache")
public class CacheController {

@Autowired
private CacheService cacheService;

@PostMapping("/set")
public String setCacheData(@RequestParam String key, @RequestParam String value) {
   cacheService.setCacheData(key, value);
   return "Data cached successfully";
}

@GetMapping("/get")
public Object getCacheData(@RequestParam String key) {
   return cacheService.getCacheData(key);
}

@DeleteMapping("/delete")
public String deleteCacheData(@RequestParam String key) {
   cacheService.deleteCacheData(key);
   return "Data deleted from cache";
}
} 6. 启动应用

最后，创建一个主类来启动Spring Boot应用：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RedisDemoApplication {

public static void main(String[] args) {
   SpringApplication.run(RedisDemoApplication.class, args);
}
} 7. 测试API

你可以使用Postman或其他HTTP客户端来测试这些API：

[*]Set Cache Data: POST /cache/set?key=myKey&value=myValue
[*]Get Cache Data: GET /cache/get?key=myKey
[*]Delete Cache Data: DELETE /cache/delete?key=myKey
这样，你就完成了一个简单的Spring Boot应用与Redis的整合示例。希望这个示例对你有帮助！如果有任何题目或需要进一步的解释，请随时告诉我。在Spring框架中整合Redis可以极大地提升应用的性能和相应速度，尤其是在处理高并发场景时。Redis作为一款高性能的键值对存储体系，常被用作缓存、消息队列等。Spring框架提供了spring-data-redis模块来简化与Redis的集成工作。
1. 添加依靠

首先，在你的项目中添加Spring Data Redis的依靠。如果你使用的是Maven，可以在pom.xml文件中添加如下依靠：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>2.7.0</version> 
</dependency> 如果使用Gradle，可以在build.gradle文件中添加：
implementation 'org.springframework.boot:spring-boot-starter-data-redis:2.7.0' // 请根据实际情况调整版本 2. 配置Redis毗连

在application.properties或application.yml中配置Redis的毗连信息：
application.properties

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=
spring.redis.database=0 application.yml

spring:
redis:
host: localhost
port: 6379
password:
database: 0 3. 创建Redis配置类

你可以创建一个配置类来配置RedisTemplate，这是Spring提供的用于操纵Redis的模板类。通过自定义RedisTemplate，你可以指定序列化方式等配置。
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

@Configuration
public class RedisConfig {

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
   RedisTemplate<String, Object> template = new RedisTemplate<>();
   template.setConnectionFactory(factory);

   // 使用Jackson2JsonRedisSerializer来序列化和反序列化value对象
   Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);

   // 设置key和hashKey的序列化方式为StringRedisSerializer
   template.setKeySerializer(new StringRedisSerializer());
   template.setHashKeySerializer(new StringRedisSerializer());

   // 设置value和hashValue的序列化方式为Jackson2JsonRedisSerializer
   template.setValueSerializer(jackson2JsonRedisSerializer);
   template.setHashValueSerializer(jackson2JsonRedisSerializer);

   template.afterPropertiesSet();
   return template;
}
} 4. 使用RedisTemplate

在需要使用Redis的地方，可以通过@Autowired注解注入RedisTemplate，然后使用它来进行各种操纵，如设置、获取、删除等。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class UserService {

@Autowired
private RedisTemplate<String, Object> redisTemplate;

public void setUser(String key, User user) {
   redisTemplate.opsForValue().set(key, user);
}

public User getUser(String key) {
   return (User) redisTemplate.opsForValue().get(key);
}

public void deleteUser(String key) {
   redisTemplate.delete(key);
}
} 5. 运行和测试

启动你的Spring Boot应用，并进行相应的测试，确保Redis能够正常工作。你可以在控制台中看到Redis的操纵日志，也可以使用Redis客户端工具（如Redis Desktop Manager）来查看Redis中的数据。
以上就是Spring整合Redis的基本步调和示例代码。希望这些信息对你有帮助！如果有任何题目或需要进一步的帮助，请随时告诉我。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

页: [1]

IT评测·应用市场-qidao123.com技术社区's Archiver

【详解】Spring整合Redis