SpringBoot如何配置Redis高并发缓存

1.引入依赖

<
dependency>

<
groupId>
org.springframework.boot<
/groupId>

<
artifactId>
spring-boot-starter-data-redis<
/artifactId>

<
/dependency>

2.配置

#启动redis
#redis的数据库索引(默认为0)
spring.redis.database=2
#redis的服务器地址
spring.redis.host=127.0.0.1
#密码(没有就为空)
spring.redis.password=
#连接池的最大连接数
spring.redis.jedis.pool.max-active=2000
#连接池的最大阻塞等待时间(使用负值表示无限制)
spring.redis.jedis.pool.max-wait=-1
#连接池的最小空闲连接
spring.redis.jedis.pool.min-idle=50
#连接超时时间(毫秒)
spring.redis.timeout=1000



#集群模式配置
#spring.redis.cluster.nodes=106.54.79.43:7001,106.54.79.43:7002,106.54.79.43:7003,106.54.79.43:7004,106.54.79.43:7005,106.54.79.43:7006

3.自动装配的对象

@AutowiredStringRedisTemplate stringRedisTemplate;

享用SpringBoot框架,Redis高并发缓存的完美配置


//仅支持字符串的数据@AutowiredRedisTemplate redisTemplate;
//支持对象的数据,但需要对对象进行序列化

4.序列化

什么是序列化?

序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化,它将流转换为对象。这两个过程结合起来,可以轻松地存储和传输数据。

为什么要序列化对象

把对象转换为字节序列的过程称为对象的序列化把字节序列恢复为对象的过程称为对象的反序列化

@Configuration@AutoConfigureAfter(RedisAutoConfiguration.class)public class RedisConfig {/**java项目www.1b23.com
* 对属性进行序列化和创建连接工厂
* @param connectionFactory
* @return
*/@Beanpublic RedisTemplate<
String, Serializable>
redisTemplate(LettuceConnectionFactory connectionFactory) {RedisTemplate<
String, Serializable>
template = new RedisTemplate<
>
();
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
template.setConnectionFactory(connectionFactory);
return template;
}}

5.测试

//java项目www.1b23.com@RequestMapping("
/user"
)@RestControllerpublic class UserController {@AutowiredStringRedisTemplate stringRedisTemplate;
//仅支持字符串的数据@AutowiredRedisTemplate redisTemplate;
//支持对象的数据,前提需要进行序列化@GetMappingpublic User user(){User user = new User();
user.setId("
1"
);
user.setName("
zhangshan"
);
user.setPhone("
133333333"
);
//插入数据 stringRedisTemplate.opsForValue().set("
1"
,user.toString());
redisTemplate.opsForValue().set("
user"
,user);
// return stringRedisTemplate.opsForValue().get("
1"
);
return (User)redisTemplate.opsForValue().get("
user"
);
}}

大型系统在处理高并发流量时很容易崩溃,因此使用缓存是必不可少的。在SpringBoot框架下,缓存配置变得非常简单。本文将教您如何使用SpringBoot快速配置Redis高并发缓存。
第一步:引入Redis依赖
在pom.xml中添加以下依赖:
```

org.springframework.boot
spring-boot-starter-data-redis

```
第二步:配置Redis
在application.properties中添加以下配置:
```
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
spring.redis.timeout=5000
spring.redis.pool.max-active=100
spring.redis.pool.max-wait=1000
spring.redis.database=0
```
第三步:创建RedisTemplate Bean
您需要为每个数据类型创建一个RedisTemplate Bean。以下代码展示了如何创建一个RedisTemplate Bean:
```
@Bean
public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
RedisTemplate redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(factory);
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(new GenericToStringSerializer(Object.class));
return redisTemplate;
}
```
第四步:缓存支持
在您的SpringBoot应用程序中添加@Cacheable注释,并将数据缓存在Redis中。以下是使用SpringBoot配置Redis缓存的示例代码:
```
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserRepository userRepository;
@Cacheable(value = \"userCache\", key = \"#userId\")
public User getUserById(Long userId) {
return userRepository.findById(userId).orElse(null);
}
}
```
第五步:使用缓存
现在您可以从Redis缓存中获取数据了。如果缓存中没有数据,则会读取数据库中的数据,并将结果存储在缓存中。
```
public User getUserById(Long userId) {
User user = userService.getUserById(userId);
if (user != null) {
return user;
}
return new User();
}
```
第六步:添加缓存更新
在应用程序更新数据时,缓存中的数据也必须更新。使用@CachePut注释可以更新缓存中的数据。
```
@CachePut(value = \"userCache\", key = \"#user.id\")
public User updateUser(User user) {
return userRepository.save(user);
}
```
第七步:删除缓存
当应用程序删除数据时,必须同时删除缓存。使用@CacheEvict注释可以从缓存中删除数据。
```
@CacheEvict(value = \"userCache\", key = \"#userId\")
public void deleteUser(Long userId) {
userRepository.deleteById(userId);
}
```
总结
SpringBoot为我们简化了Redis高并发缓存的配置。我们学习了如何配置Redis以及如何使用@Cacheable、@CachePut和@CacheEvict等缓存注释。这些可以帮助我们在处理高并发流量时更好地使用缓存。
返回顶部