服务器之家：专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|JAVA教程|ASP教程|编程技术|正则表达式|

服务器之家 - 编程语言 - JAVA教程 - 详解SpringBoot Redis自适应配置(Cluster Standalone Sentinel)

详解SpringBoot Redis自适应配置(Cluster Standalone Sentinel)

2020-07-08 14:28洛书i JAVA教程

这篇文章主要介绍了详解SpringBoot Redis自适应配置(Cluster Standalone Sentinel)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

核心代码段

提供一个JedisConnectionFactory  根据配置来判断 单点 集群 还是哨兵

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
@Bean
@ConditionalOnMissingBean
public JedisConnectionFactory jedisConnectionFactory() {
 JedisConnectionFactory factory = null;
 
 String[] split = node.split(",");
 Set<HostAndPort> nodes = new LinkedHashSet<>();
 for (int i = 0; i < split.length; i++) {
  try {
   String[] split1 = split[i].split(":");
   nodes.add(new HostAndPort(split1[0], Integer.parseInt(split1[1])));
  } catch (Exception e) {
   throw new RuntimeException(String.format("出现配置错误!请确认node=[%s]是否正确", node));
  }
 }
 //获得默认的连接池构造器(怎么设计的，为什么不抽象出单独类，供用户使用呢) 有毒
 JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcb =
   (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder) JedisClientConfiguration.builder();
 //指定jedisPoolConifig来修改默认的连接池构造器（真麻烦，滥用设计模式！） ！！！！
 jpcb.poolConfig(jedisPoolConfig);
 //通过构造器来构造jedis客户端配置
 JedisClientConfiguration jedisClientConfiguration = jpcb.build();
 
 //如果是哨兵的模式
 if (!StringUtils.isEmpty(sentinel)) {
  logger.info("Redis use SentinelConfiguration");
  RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration();
  String[] sentinelArray = sentinel.split(",");
  for (String s : sentinelArray) {
   try {
    String[] split1 = s.split(":");
    redisSentinelConfiguration.addSentinel(new RedisNode(split1[0], Integer.parseInt(split1[1])));
   } catch (Exception e) {
    throw new RuntimeException(String.format("出现配置错误!请确认node=[%s]是否正确", node));
   }
  }
  factory = new JedisConnectionFactory(redisSentinelConfiguration, jedisClientConfiguration);
 
 }
 //如果是单个节点 用Standalone模式
 else if (nodes.size() == 1) {
  logger.info("Redis use RedisStandaloneConfiguration");
  for (HostAndPort n : nodes) {
   RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
   if (!StringUtils.isEmpty(password)) {
    redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
   }
   redisStandaloneConfiguration.setPort(n.getPort());
   redisStandaloneConfiguration.setHostName(n.getHost());
   factory = new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
  }
 }
 //集群配置信息实现
 else {
  logger.info("Redis use RedisStandaloneConfiguration");
  RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
  nodes.forEach(n -> {
   redisClusterConfiguration.addClusterNode(new RedisNode(n.getHost(), n.getPort()));
  });
  if (!StringUtils.isEmpty(password)) {
   redisClusterConfiguration.setPassword(RedisPassword.of(password));
  }
  redisClusterConfiguration.setMaxRedirects(maxRedirect);
  factory = new JedisConnectionFactory(redisClusterConfiguration, jedisClientConfiguration);
 }
 return factory;
}

Configration

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.*;
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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.util.StringUtils;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisPoolConfig;
 
import java.util.LinkedHashSet;
import java.util.Set;
 
/**
 * @Author foxzzz
 * @Class SelfAdaptionRedisConfig
 * @Description 自适应redis配置
 * 适用于 单点[主从] 哨兵模式 集群模式
 * @Date 2020/7/6 14:34
 */
 
@Configuration
@EnableCaching
public class SelfAdaptionRedisConfig<K, V> extends CachingConfigurerSupport {
 private final static Logger logger = LoggerFactory.getLogger(SelfAdaptionRedisConfig.class);
 
 @Value("${spring.redis.node}")
 private String node;
 @Value("${spring.redis.timeout:0}")
 private int timeout;
 @Value("${spring.redis.password:}")
 private String password;
 @Value("${spring.redis.sentinel:}")
 private String sentinel;
 
 @Value("${spring.redis.jedis.pool.max-total:8}")
 private int maxTotal;
 @Value("${spring.redis.jedis.pool.max-idle:8}")
 private int maxIdle;
 @Value("${spring.redis.jedis.pool.min-idle:0}")
 private int minIdle;
 @Value("${spring.redis.jedis.pool.max-wait:-1}")
 private long maxWaitMillis;
 @Value("${spring.redis.jedis.pool.test-on-borrow:true}")
 private boolean testOnBorrow;
 @Value("${spring.redis.jedis.factory.max-redirects:5}")
 private int maxRedirect;
 
 
 @Autowired
 private JedisPoolConfig jedisPoolConfig;
 @Autowired
 private JedisConnectionFactory jedisConnectionFactory;
 
 
 @Bean
 @ConditionalOnMissingBean
 @Override
 public CacheManager cacheManager() {
  // 初始化缓存管理器，在这里我们可以缓存的整体过期时间什么的，我这里默认没有配置
  logger.info("初始化 -> [{}]", "CacheManager RedisCacheManager Start");
  RedisCacheManager.RedisCacheManagerBuilder builder = RedisCacheManager
    .RedisCacheManagerBuilder
    .fromConnectionFactory(jedisConnectionFactory);
  return builder.build();
 }
 
 
 @Bean
 @ConditionalOnMissingBean
 @Override
 public CacheErrorHandler errorHandler() {
  // 异常处理，当Redis发生异常时，打印日志，但是程序正常走
  logger.info("初始化 -> [{}]", "Redis CacheErrorHandler");
  CacheErrorHandler cacheErrorHandler = new CacheErrorHandler() {
   @Override
   public void handleCacheGetError(RuntimeException e, Cache cache, Object key) {
    logger.error("Redis occur handleCacheGetError：key -> [{}]", key, e);
   }
 
   @Override
   public void handleCachePutError(RuntimeException e, Cache cache, Object key, Object value) {
    logger.error("Redis occur handleCachePutError：key -> [{}]；value -> [{}]", key, value, e);
   }
 
   @Override
   public void handleCacheEvictError(RuntimeException e, Cache cache, Object key) {
    logger.error("Redis occur handleCacheEvictError：key -> [{}]", key, e);
   }
 
   @Override
   public void handleCacheClearError(RuntimeException e, Cache cache) {
    logger.error("Redis occur handleCacheClearError：", e);
   }
  };
  return cacheErrorHandler;
 }
 
 
 @Bean
 @ConditionalOnMissingBean
 public JedisPoolConfig jedisPoolConfig() {
  JedisPoolConfig config = new JedisPoolConfig();
  // 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间, 默认-1
  config.setMaxWaitMillis(maxWaitMillis);
  //最小空闲连接数, 默认0
  config.setMinIdle(minIdle);
  // 最大空闲连接数, 默认8个
  config.setMaxIdle(maxIdle);
  // 最大连接数, 默认值8个
  config.setMaxTotal(maxTotal);
  //对拿到的connection进行validateObject校验
  config.setTestOnBorrow(testOnBorrow);
  return config;
 }
 
// private JedisCluster getJedisCluster() {
//  String[] split = node.split(",");
//  Set<HostAndPort> nodes = new LinkedHashSet<>();
//  for (int i = 0; i < split.length; i++) {
//   try {
//    String[] split1 = split[i].split(":");
//    nodes.add(new HostAndPort(split1[0], Integer.parseInt(split1[1]))));
//   } catch (Exception e) {
//   }
//  }
//  JedisCluster jedisCluster = null;
//  if (StringUtils.isEmpty(password)) {
//   jedisCluster = new JedisCluster(nodes, 5000, 3000, 10, jedisPoolConfig);
//  } else {
//   jedisCluster = new JedisCluster(nodes, 5000, 3000, 10, password, jedisPoolConfig);
//  }
// }
 
 
 @Bean
 @ConditionalOnMissingBean
 public JedisConnectionFactory jedisConnectionFactory() {
  JedisConnectionFactory factory = null;
 
  String[] split = node.split(",");
  Set<HostAndPort> nodes = new LinkedHashSet<>();
  for (int i = 0; i < split.length; i++) {
   try {
    String[] split1 = split[i].split(":");
    nodes.add(new HostAndPort(split1[0], Integer.parseInt(split1[1])));
   } catch (Exception e) {
    throw new RuntimeException(String.format("出现配置错误!请确认node=[%s]是否正确", node));
   }
  }
  //获得默认的连接池构造器(怎么设计的，为什么不抽象出单独类，供用户使用呢) 有毒
  JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcb =
    (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder) JedisClientConfiguration.builder();
  //指定jedisPoolConifig来修改默认的连接池构造器（真麻烦，滥用设计模式！） ！！！！
  jpcb.poolConfig(jedisPoolConfig);
  //通过构造器来构造jedis客户端配置
  JedisClientConfiguration jedisClientConfiguration = jpcb.build();
 
  //如果是哨兵的模式
  if (!StringUtils.isEmpty(sentinel)) {
   logger.info("Redis use SentinelConfiguration");
   RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration();
   String[] sentinelArray = sentinel.split(",");
   for (String s : sentinelArray) {
    try {
     String[] split1 = s.split(":");
     redisSentinelConfiguration.addSentinel(new RedisNode(split1[0], Integer.parseInt(split1[1])));
    } catch (Exception e) {
     throw new RuntimeException(String.format("出现配置错误!请确认node=[%s]是否正确", node));
    }
   }
   factory = new JedisConnectionFactory(redisSentinelConfiguration, jedisClientConfiguration);
 
  }
  //如果是单个节点 用Standalone模式
  else if (nodes.size() == 1) {
   logger.info("Redis use RedisStandaloneConfiguration");
   for (HostAndPort n : nodes) {
    RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
    if (!StringUtils.isEmpty(password)) {
     redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
    }
    redisStandaloneConfiguration.setPort(n.getPort());
    redisStandaloneConfiguration.setHostName(n.getHost());
    factory = new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
   }
  }
  //集群配置信息实现
  else {
   logger.info("Redis use RedisStandaloneConfiguration");
   RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
   nodes.forEach(n -> {
    redisClusterConfiguration.addClusterNode(new RedisNode(n.getHost(), n.getPort()));
   });
   if (!StringUtils.isEmpty(password)) {
    redisClusterConfiguration.setPassword(RedisPassword.of(password));
   }
   redisClusterConfiguration.setMaxRedirects(maxRedirect);
   factory = new JedisConnectionFactory(redisClusterConfiguration, jedisClientConfiguration);
  }
  return factory;
 }
 
 
 @Bean
 @ConditionalOnMissingBean
 public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory jedisConnectionFactory) {
  //设置序列化
  Jackson2JsonRedisSerializer 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);
  // 配置redisTemplate
  RedisTemplate<String, Object> redisTemplate = new RedisTemplate<String, Object>();
  redisTemplate.setConnectionFactory(jedisConnectionFactory);
  RedisSerializer stringSerializer = new StringRedisSerializer();
  // key序列化
  redisTemplate.setKeySerializer(stringSerializer);
  // value序列化
  redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
//  redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
  // Hash key序列化
  redisTemplate.setHashKeySerializer(stringSerializer);
  // Hash value序列化
  redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
  redisTemplate.afterPropertiesSet();
  return redisTemplate;
 }
}

pom依赖

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
<dependencies>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
   <version>${springboot.version}</version>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter</artifactId>
   <scope>provided</scope>
  </dependency>
  <dependency>
   <groupId>redis.clients</groupId>
   <artifactId>jedis</artifactId>
   <version>${redis.version}</version>
  </dependency>
 
  <dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-annotations</artifactId>
   <scope>provided</scope>
  </dependency>
  <dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <scope>provided</scope>
  </dependency>
  <dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-core</artifactId>
   <scope>provided</scope>
  </dependency>
 </dependencies>

配置文件

1.yml配置

1.1支持 Cluster模式 集群

  • node有多个redis的地址,以逗号分隔
  • 如果redis没有密码直接去掉配置就可以了 yml配置
?
1
2
3
4
spring:
 redis:
 node: 127.0.0.1:1001,127.0.0.1:1002,127.0.0.1:1003
 password: 123456

properties配置

?
1
2
spring.redis.node=127.0.0.1:1001,127.0.0.1:1002,127.0.0.1:1003
spring.redis.password=123456

1.2支持 Standalone模式 单点

node里只有一个redis地址的时候,会自动变成单点模式 yml配置

?
1
2
3
4
spring:
 redis:
 node: 127.0.0.1:1001
 password: 123456

properties配置

?
1
2
spring.redis.node=127.0.0.1:1001
spring.redis.password=123456

1.3支持 Sentinel模式 哨兵

当配置上sentinel以后就变成了哨兵模式 多个哨兵可以以逗号分割 yml配置

?
1
2
3
4
5
spring:
 redis:
 node: 127.0.0.1:1001
 sentinel:127.0.0.1:1002,127.0.0.1:1003
 password: 123456

properties配置

?
1
2
3
spring.redis.node=127.0.0.1:1001
spring.redis.sentinel:127.0.0.1:1002,127.0.0.1:1003
spring.redis.password=123456

1.4覆盖默认配置

如果没有配置这些信息,就会走默认配置 也可以在properties或者yml覆盖默认配置

?
1
2
3
4
5
6
7
8
9
10
11
12
#最大连接数, 默认值8个
spring.redis.jedis.pool.max-total=8
#最大空闲连接数, 默认8个
spring.redis.jedis.pool.max-idle=8
#最小空闲连接数, 默认0
spring.redis.jedis.pool.min-idle=0
#获取连接时的最大等待毫秒数,如果超时就抛异常, 小于零:阻塞不确定的时间, 默认-1
spring.redis.jedis.pool.max-wait=-1
#对拿到的connection进行validateObject校验
spring.redis.jedis.pool.test-on-borrow=true
#集群时最大重定向个数默认5
spring.redis.jedis.factory.max-redirects=5

使用 

代码使用

?
1
2
@Autowired
 private RedisTemplate<String, Object> redisTemplate;

到此这篇关于详解SpringBoot Redis自适应配置(Cluster Standalone Sentinel)的文章就介绍到这了,更多相关SpringBoot Redis自适应配置内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/qq_21078159/article/details/107180642

  • redis
  • springboot
  • 自适应配置

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    501 　 2000 　 1433 　 415 　 内存卡 　 随机抽取 　 选择排序法 　 对象池模式 　 子线程 　 下载器 　 十六进制字符 　 响应 　 静态工厂 　 构造函数 　 swt 　 Overview 　 短信猫 　 作业调度 　 空心菱形 　 htmlparser 　 支票 　 金额大写转换 　 终止循环体 　 AspectJ 　 面向切面编程 　 方法名 　 网址信息 　 动态代理模式 　 线程安全 　 自适应配置 　
    © 2019-2020 服务器之家 版权所有 www.zzvips.com 关于我们联系我们版权申明网站地图