Konfigurationsparameter
Da in diesem Artikel nicht der Aufbau eines Redis-Clusters vorgestellt wird, gehen wir hier davon aus, dass wir bereits über eine Redis-Clusterumgebung verfügen und die folgenden Teile in unserem Projekt anpassen müssenRedis 集群的搭建，这里我们假设已经有了一个 Redis 的集群环境，我们项目中需要调整以下几个部分
修改配置参数，集群的节点和密码配置；
确保引入的 Jedis 版本支持设置密码，spring-data-redis 1.8 以上，SpringBoot 1.5 以上才支持设置密码；
注入 RedisTemplate；
编写工具类；
修改配置参数
############### Redis 集群配置 #########################
spring.custome.redis.cluster.nodes=172.20.0.1:7001,172.20.0.2:7002,172.20.0.3:7003
spring.custome.redis.cluster.max-redirects=3
spring.custome.redis.cluster.max-active=500
spring.custome.redis.cluster.max-wait=-1
spring.custome.redis.cluster.max-idle=500
spring.custome.redis.cluster.min-idle=20
spring.custome.redis.cluster.timeout=3000
spring.custome.redis.cluster.password=redis.cluster.password
Nach dem Login kopieren
引入依赖（如果需要）
确保 SpringBoot 的版本大于 1.4.x 如果不是的话，采用如下配置，先排除 SpringBoot 中旧版本 Jedis 和 spring-data-redis，再依赖高版本的 Jedis 和 spring-data-redis。
org.springframework.boot
spring-boot-starter-data-redis
redis.clients
jedis
org.springframework.data
spring-data-redis
redis.clients
jedis
2.9.0
org.springframework.data
spring-data-redis
1.8.0.RELEASE
Nach dem Login kopieren
注入 RedisTemplate
注入 RedisTemplate 我们需要三个组件，分别是JedisConnectionFactory 、RedisClusterConfiguration、JedisPoolConfig，下面是注入RedisTempalte 的代码。先根据配置创建 JedisConnectFactory 同时需要配置 RedisClusterConfiguration、JedisPoolConfig，最后将JedisConnectionFactory 返回用于创建RedisTemplate
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
public class RedisClusterConfig {
@Bean(name = "redisTemplate")
@Primary
public RedisTemplate redisClusterTemplate(@Value("${spring.custome.redis.cluster.nodes}") String host,
@Value("${spring.custome.redis.cluster.password}") String password,
@Value("${spring.custome.redis.cluster.timeout}") long timeout,
@Value("${spring.custome.redis.cluster.max-redirects}") int maxRedirect,
@Value("${spring.custome.redis.cluster.max-active}") int maxActive,
@Value("${spring.custome.redis.cluster.max-wait}") int maxWait,
@Value("${spring.custome.redis.cluster.max-idle}") int maxIdle,
@Value("${spring.custome.redis.cluster.min-idle}") int minIdle) {
JedisConnectionFactory connectionFactory = jedisClusterConnectionFactory(host, password,
timeout, maxRedirect, maxActive, maxWait, maxIdle, minIdle);
return createRedisClusterTemplate(connectionFactory);
}
private JedisConnectionFactory jedisClusterConnectionFactory(String host, String password,
long timeout, int maxRedirect, int maxActive, int maxWait, int maxIdle, int minIdle) {
RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
List nodeList = new ArrayList();
String[] cNodes = host.split(",");
//分割出集群节点
for (String node : cNodes) {
String[] hp = node.split(":");
nodeList.add(new RedisNode(hp[0], Integer.parseInt(hp[1])));
}
redisClusterConfiguration.setClusterNodes(nodeList);
redisClusterConfiguration.setPassword(password);
redisClusterConfiguration.setMaxRedirects(maxRedirect);
// 连接池通用配置
GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
genericObjectPoolConfig.setMaxIdle(maxIdle);
genericObjectPoolConfig.setMaxTotal(maxActive);
genericObjectPoolConfig.setMinIdle(minIdle);
genericObjectPoolConfig.setMaxWaitMillis(maxWait);
genericObjectPoolConfig.setTestWhileIdle(true);
genericObjectPoolConfig.setTimeBetweenEvictionRunsMillis(300000);
JedisClientConfiguration.DefaultJedisClientConfigurationBuilder builder = (JedisClientConfiguration.DefaultJedisClientConfigurationBuilder) JedisClientConfiguration
.builder();
builder.connectTimeout(Duration.ofSeconds(timeout));
builder.usePooling();
builder.poolConfig(genericObjectPoolConfig);
JedisConnectionFactory connectionFactory = new JedisConnectionFactory(redisClusterConfiguration, builder.build());
// 连接池初始化
connectionFactory.afterPropertiesSet();
return connectionFactory;
}
private RedisTemplate createRedisClusterTemplate(JedisConnectionFactory redisConnectionFactory) {
RedisTemplate redisTemplate = new RedisTemplate();
redisTemplate.setConnectionFactory(redisConnectionFactory);
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// key采用String的序列化方式
redisTemplate.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
redisTemplate.setHashKeySerializer(stringRedisSerializer);
// value序列化方式采用jackson
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
// hash的value序列化方式采用jackson
redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
}Nach dem Login kopieren
编写工具类
其实到这里基本上已经完成了，我们可以看到 SpringBoot 项目接入 Redis 集群还是比较简单的，而且如果之前单机环境就是采用RedisTemplate
- Ändern Sie die Konfigurationsparameter, den Clusterknoten und die Passwortkonfiguration. 🎜
- 🎜Stellen Sie sicher, dass die eingeführte
Jedis-Version das Festlegen von Passwörtern unterstützt , spring-data-redis 1.8 oder höher, SpringBoot 1.5 oder höher unterstützt nur das Festlegen von Passwörtern 🎜
- 🎜Inject
RedisTemplate; 🎜
- 🎜Werkzeugklassen schreiben;🎜
🎜Konfigurationsparameter ändern🎜
/**
* 删除KEY
* @param key
* @return
*/
public boolean delete(String key) {
try {
return getTemplate().delete(key);
} catch (Exception e) {
log.error("redis hasKey() is error");
return false;
}
}
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : getTemplate().opsForValue().get(key);
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true成功 false失败
*/
public boolean set(String key, Object value) {
try {
getTemplate().opsForValue().set(key, value);
return true;
} catch (Exception e) {
log.error("redis set() is error");
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
* @return true成功 false 失败
*/
public boolean set(String key, Object value, long time) {
try {
if (time > 0) {
getTemplate().opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
log.error("redis set() is error");
return false;
}
}
/**
* 计数器
*
* @param key 键
* @return 值
*/
public Long incr(String key) {
return getTemplate().opsForValue().increment(key);
}
public Long incrBy(String key, long step) {
return getTemplate().opsForValue().increment(key, step);
}
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return 值
*/
public Object hget(String key, String item) {
return getTemplate().opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public Map hmget(String key) {
return getTemplate().opsForHash().entries(key);
}
/**
* 获取hashKey对应的批量键值
* @param key
* @param values
* @return
*/
public List<Object> hmget(String key, List values) {
return getTemplate().opsForHash().multiGet(key, values);
}Nach dem Login kopieren
🎜Abhängigkeiten einführen (falls erforderlich)🎜🎜Stellen Sie sicher, dass die Version von SpringBoot größer als 1.4 ist .x. Wenn nicht, verwenden Sie die folgende Konfiguration: Schließen Sie zuerst die alten Versionen von
Jedis und
spring-data-redis in
SpringBoot aus und dann Verlassen Sie sich auf die höheren Versionen von
Jedis und
spring-data-redis. 🎜rrreee🎜Inject
RedisTemplate🎜🎜Inject
RedisTemplate Wir benötigen drei Komponenten, nämlich
JedisConnectionFactory,
RedisClusterConfiguration,
JedisPoolConfig, das Folgende ist der Code, der
RedisTempalte einfügt. Erstellen Sie zuerst
JedisConnectFactory entsprechend der Konfiguration und müssen auch
RedisClusterConfiguration und
JedisPoolConfig konfigurieren und schließlich
JedisConnectionFactory zum Erstellen zurückgeben
RedisTemplate🎜rrreee🎜Writing-Tool-Klassen🎜🎜Tatsächlich ist es hier im Grunde abgeschlossen. Wir können sehen, dass es für das
SpringBoot-Projekt relativ einfach ist, eine Verbindung zu
herzustellen >Redis-Cluster, und wenn die eigenständige Umgebung zuvor
RedisTemplate verwendet hat, müssen jetzt keine Toolklassen geschrieben werden und die vorherigen Vorgänge sind weiterhin gültig. 🎜rrreee
Das obige ist der detaillierte Inhalt vonSo verbinden Sie das SpringBoot-Projekt mit dem Redis-Cluster. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
