springboot集成redis的方法

1. pom.xml添加依赖

<
dependencies>

<
dependency>

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

<
artifactId>
spring-boot-starter<
/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>

<
dependency>

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

<
artifactId>
spring-boot-starter-test<
/artifactId>

<
scope>
test<
/scope>

<
/dependency>


<
!--集成redis-->

<
dependency>

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

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

<
/dependency>

<
/dependencies>

2. application-dev.xml配置

#单机模式
spring:
redis:
host: 192.168.56.101 # Redis服务器地址
database: 0 # Redis数据库索引(默认为0)
port: 6379 # Redis服务器连接端口
password: redis # Redis服务器连接密码(默认为空)
timeout: 300ms # 连接超时时间(毫秒)

# 哨兵模式

spring:
redis:
sentinel:
master: mymaster
nodes: 192.168.56.101:26379,192.168.56.102:26379,192.168.56.103:26379
password: redis

SpringBoot集成Redis:一种高效便捷的解决方案

3. java config配置(单节点)

package com.powertrade.redis.common.config;


import com.fasterxml.jackson.annotation.JsonAutoDetect;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;

import org.springframework.cache.annotation.EnableCaching;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.cache.RedisCacheConfiguration;

import org.springframework.data.redis.cache.RedisCacheManager;

import org.springframework.data.redis.cache.RedisCacheWriter;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.RedisSerializationContext;

import org.springframework.data.redis.serializer.RedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;


import java.time.Duration;


/**
* Redis单机配置
*/
@EnableCaching
@Configuration
public class BaseRedisConfig {

@Bean
public RedisTemplate<
String, Object>
redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisSerializer<
Object>
serializer = redisSerializer();

RedisTemplate<
String, Object>
redisTemplate = new RedisTemplate<
>
();

redisTemplate.setConnectionFactory(redisConnectionFactory);

redisTemplate.setKeySerializer(new StringRedisSerializer());

redisTemplate.setValueSerializer(serializer);

redisTemplate.setHashKeySerializer(new StringRedisSerializer());

redisTemplate.setHashValueSerializer(serializer);

redisTemplate.afterPropertiesSet();

return redisTemplate;

}

@Bean
public RedisSerializer<
Object>
redisSerializer() {
//创建JSON序列化器
Jackson2JsonRedisSerializer<
Object>
serializer = new Jackson2JsonRedisSerializer<
>
(Object.class);

ObjectMapper objectMapper = new ObjectMapper();

objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

//必须设置,否则无法将JSON转化为对象,会转化成Map类型
objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL);

serializer.setObjectMapper(objectMapper);

return serializer;

}

@Bean
public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);

//设置Redis缓存有效期为1天
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer())).entryTtl(Duration.ofDays(1));

return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);

}


}

4. 哨兵机制 (多节点配置)

package com.powertrade.redis.common.config;


import com.fasterxml.jackson.annotation.JsonAutoDetect;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.cache.annotation.EnableCaching;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.data.redis.cache.RedisCacheConfiguration;

import org.springframework.data.redis.cache.RedisCacheManager;

import org.springframework.data.redis.cache.RedisCacheWriter;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.connection.RedisNode;

import org.springframework.data.redis.connection.RedisPassword;

import org.springframework.data.redis.connection.RedisSentinelConfiguration;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.RedisSerializationContext;

import org.springframework.data.redis.serializer.RedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;


import java.time.Duration;


/**
* Redis哨兵机制配置
*/
@EnableCaching
@Configuration
public class BaseRedisConfig {

@Value("
${spring.redis.sentinel.nodes}"
)
private String redisNodes;


@Value("
${spring.redis.sentinel.master}"
)
private String master;


@Value("
${spring.redis.sentinel.password}"
)
private String password;



/**
* redis哨兵配置
*/
@Bean
public RedisSentinelConfiguration redisSentinelConfiguration(){
RedisSentinelConfiguration configuration = new RedisSentinelConfiguration();

String[] host = redisNodes.split("
,"
);

for(String redisHost : host){
String[] item = redisHost.split("
:"
);

String ip = item[0];

String port = item[1];

configuration.addSentinel(new RedisNode(ip, Integer.parseInt(port)));

}
configuration.setPassword(RedisPassword.of(password));

configuration.setMaster(master);

return configuration;

}

@Bean
public RedisTemplate<
String, Object>
redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisSerializer<
Object>
serializer = redisSerializer();

RedisTemplate<
String, Object>
redisTemplate = new RedisTemplate<
>
();

redisTemplate.setConnectionFactory(redisConnectionFactory);

redisTemplate.setKeySerializer(new StringRedisSerializer());

redisTemplate.setValueSerializer(serializer);

redisTemplate.setHashKeySerializer(new StringRedisSerializer());

redisTemplate.setHashValueSerializer(serializer);

redisTemplate.afterPropertiesSet();

return redisTemplate;

}

@Bean
public RedisSerializer<
Object>
redisSerializer() {
//创建JSON序列化器
Jackson2JsonRedisSerializer<
Object>
serializer = new Jackson2JsonRedisSerializer<
>
(Object.class);

ObjectMapper objectMapper = new ObjectMapper();

objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

//必须设置,否则无法将JSON转化为对象,会转化成Map类型
objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL);

serializer.setObjectMapper(objectMapper);

return serializer;

}

@Bean
public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);

//设置Redis缓存有效期为1天
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer())).entryTtl(Duration.ofDays(1));

return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);

}

}

5. redis工具类

package com.powertrade.redis.common.utils;


import lombok.RequiredArgsConstructor;

import org.springframework.data.redis.core.BoundSetOperations;

import org.springframework.data.redis.core.HashOperations;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.core.ValueOperations;

import org.springframework.stereotype.Component;


import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.TimeUnit;


@Component
@RequiredArgsConstructor
public class RedisCache
{
public final RedisTemplate redisTemplate;


/**
* 缓存基本的对象,Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
*/
public <
T>
void setCacheObject(final String key, final T value)
{
redisTemplate.opsForValue().set(key, value);

}

/**
* 缓存基本的对象,Integer、String、实体类等
*
* @param key 缓存的键值
* @param value 缓存的值
* @param timeout 时间
* @param timeUnit 时间颗粒度
*/
public <
T>
void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
{
redisTemplate.opsForValue().set(key, value, timeout, timeUnit);

}

/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @return true=设置成功;false=设置失败
*/
public boolean expire(final String key, final long timeout)
{
return expire(key, timeout, TimeUnit.SECONDS);

}

/**
* 设置有效时间
*
* @param key Redis键
* @param timeout 超时时间
* @param unit 时间单位
* @return true=设置成功;false=设置失败
*/
public boolean expire(final String key, final long timeout, final TimeUnit unit)
{
return redisTemplate.expire(key, timeout, unit);

}

/**
* 获得缓存的基本对象。
*
* @param key 缓存键值
* @return 缓存键值对应的数据
*/
public <
T>
T getCacheObject(final String key)
{
ValueOperations<
String, T>
operation = redisTemplate.opsForValue();

return operation.get(key);

}

/**
* 删除单个对象
*
* @param key
*/
public boolean deleteObject(final String key)
{
return redisTemplate.delete(key);

}

/**
* 删除集合对象
*
* @param collection 多个对象
* @return
*/
public long deleteObject(final Collection collection)
{
return redisTemplate.delete(collection);

}

/**
* 缓存List数据
*
* @param key 缓存的键值
* @param dataList 待缓存的List数据
* @return 缓存的对象
*/
public <
T>
long setCacheList(final String key, final List<
T>
dataList)
{
Long count = redisTemplate.opsForList().rightPushAll(key, dataList);

return count == null ? 0 : count;

}

/**
* 获得缓存的list对象
*
* @param key 缓存的键值
* @return 缓存键值对应的数据
*/
public <
T>
List<
T>
getCacheList(final String key)
{
return redisTemplate.opsForList().range(key, 0, -1);

}

/**
* 缓存Set
*
* @param key 缓存键值
* @param dataSet 缓存的数据
* @return 缓存数据的对象
*/
public <
T>
BoundSetOperations<
String, T>
setCacheSet(final String key, final Set<
T>
dataSet)
{
BoundSetOperations<
String, T>
setOperation = redisTemplate.boundSetOps(key);

Iterator<
T>
it = dataSet.iterator();

while (it.hasNext())
{
setOperation.add(it.next());

}
return setOperation;

}

/**
* 获得缓存的set
*
* @param key
* @return
*/
public <
T>
Set<
T>
getCacheSet(final String key)
{
return redisTemplate.opsForSet().members(key);

}

/**
* 缓存Map
*
* @param key
* @param dataMap
*/
public <
T>
void setCacheMap(final String key, final Map<
String, T>
dataMap)
{
if (dataMap != null) {
redisTemplate.opsForHash().putAll(key, dataMap);

}
}

/**
* 获得缓存的Map
*
* @param key
* @return
*/
public <
T>
Map<
String, T>
getCacheMap(final String key)
{
return redisTemplate.opsForHash().entries(key);

}

/**
* 往Hash中存入数据
*
* @param key Redis键
* @param hKey Hash键
* @param value 值
*/
public <
T>
void setCacheMapValue(final String key, final String hKey, final T value)
{
redisTemplate.opsForHash().put(key, hKey, value);

}

/**
* 获取Hash中的数据
*
* @param key Redis键
* @param hKey Hash键
* @return Hash中的对象
*/
public <
T>
T getCacheMapValue(final String key, final String hKey)
{
HashOperations<
String, String, T>
opsForHash = redisTemplate.opsForHash();

return opsForHash.get(key, hKey);

}

/**
* 获取多个Hash中的数据
*
* @param key Redis键
* @param hKeys Hash键集合
* @return Hash对象集合
*/
public <
T>
List<
T>
getMultiCacheMapValue(final String key, final Collection<
Object>
hKeys)
{
return redisTemplate.opsForHash().multiGet(key, hKeys);

}

/**
* 获得缓存的基本对象列表
*
* @param pattern 字符串前缀
* @return 对象列表
*/
public Collection<
String>
keys(final String pattern)
{
return redisTemplate.keys(pattern);

}

}

Redis是目前非常流行的内存数据库,常用于缓存、消息队列和分布式锁等场景,具有性能高、使用方便等优点,因此成为了开发中不可或缺的工具。在SpringBoot中使用Redis也非常方便,本文将向大家介绍前人经验,分享如何快速搭建一个高效便捷的SpringBoot+Redis架构。
1. 依赖引入:简单实现SpringBoot集成Redis
首先,我们需要在pom.xml中引入Redis的相关依赖:
```

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

```
然后添加Redis的配置文件application.properties:
```
#redis
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=
spring.redis.database=redis
```
仅以上两个步骤,即可完成Spring Boot与Redis的集成。我们可以通过@Autowired来获取对应的RedisTemplate对象,便可以进行一系列Redis操作。
2. 常用功能:如何在SpringBoot中完成Redis的常用操作
借助SpringBoot封装的RedisTemplate,我们可以在代码中快速实现Redis的常用操作:
- 字符串操作:
```
// 写入字符串
redisTemplate.opsForValue().set(\"key\", \"value\");
// 读取字符串
redisTemplate.opsForValue().get(\"key\");
```
- 列表操作:
```
// 添加值到list尾部
redisTemplate.opsForList().rightPush(\"listKey\", \"value\");
// 从list头部取出第一个值
redisTemplate.opsForList().leftPop(\"listKey\");
// 获取list长度
redisTemplate.opsForList().size(\"listKey\");
```
- 哈希操作:
```
// 向哈希表中添加元素
redisTemplate.opsForHash().put(\"hashKey\", \"field\", \"value\");
//从哈希表中获取元素
redisTemplate.opsForHash().get(\"hashKey\", \"field\");
// 获取哈希表中所有字段和值
redisTemplate.opsForHash().entries(\"hashKey\");
```
- 集合操作:
```
// 向集合中添加多个元素
redisTemplate.opsForSet().add(\"setKey\", \"value1\", \"value2\", \"value3\");
// 从集合中随机弹出一个元素
redisTemplate.opsForSet().pop(\"setKey\");
// 获取集合大小
redisTemplate.opsForSet().size(\"setKey\");
```
3. 高级话题:Redis中的持久化机制
Redis提供了两种持久化机制:RDB和AOF。
RDB机制将Redis在内存中的数据定时或时候触发快照保存到磁盘中,便于数据的恢复和迁移。而AOF机制则是将Redis接收到写命令的操作追加存储到文件中,以此来保证数据的持久化。
如何选择合适的持久化机制,需要根据业务需求进行技术选型。RDB机制适合对数据要求不是非常高、且对数据完整性要求不高的场景,而AOF机制适合对数据完整性有较高要求的场景,比如金融服务和电子商务等。
在应用中启用Redis的持久化,只需在配置文件中添加以下设置代码即可:
```
spring.redis.redis-config=confs/redis.conf
```
以上就是Spring Boot集成Redis的完整流程,我们可以运用这些技巧帮助我们更高效地操作Redis,提供了一个简单易懂且集成化的解决方案,希望可以帮助到大家。