springboot连接redis哨兵模式 - 好文

*
jar包
<dependency> <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId> </dependency>  <dependency>
<groupId>redis.clients</groupId> <artifactId>jedis</artifactId>
<version>2.9.0</version> </dependency>
*
配置文件yml
redis: maxIdle: 300 #最大空闲数 maxTotal: 1000 #连接池的最大数据库连接数。设为0表示无限制,如果是jedis
2.4以后用redis.maxTotal maxWaitMillis : 1000 # 最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
minEvictableIdleTimeMillis: 300000 #连接的最小空闲时间默认1800000毫秒(30分钟)
numTestsPerEvictionRun: 1024 # 每次逐出检查时逐出的最大数目如果为负数就是 : 1/abs(n), 默认3
timeBetweenEvictionRunsMillis: 30000 #逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
testOnBorrow: true #是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个 testWhileIdle: true
#在空闲时检查有效性, 默认false mymaster: masterName: mymaster sentinel: hostName:
127.0.0.1 port: 26379
3.config类配置redis信息
@Configuration public class RedisConfig { @Value("${redis.maxIdle}") private
Integer maxIdle; @Value("${redis.maxTotal}") private Integer maxTotal;
@Value("${redis.maxWaitMillis}") private Integer maxWaitMillis;
@Value("${redis.minEvictableIdleTimeMillis}") private Integer
minEvictableIdleTimeMillis; @Value("${redis.numTestsPerEvictionRun}") private
Integer numTestsPerEvictionRun;
@Value("${redis.timeBetweenEvictionRunsMillis}") private long
timeBetweenEvictionRunsMillis; @Value("${redis.testOnBorrow}") private boolean
testOnBorrow; @Value("${redis.testWhileIdle}") private boolean testWhileIdle;
@Value("${redis.mymaster.masterName}") private String masterName;
@Value("${redis.sentinel.hostName}") private String sentinelHostName;
@Value("${redis.sentinel.port}") private int sentinelport; /** *
JedisPoolConfig 连接池 * * @return */ @Bean public JedisPoolConfig
jedisPoolConfig() { JedisPoolConfig jedisPoolConfig = new JedisPoolConfig(); //
最大空闲数 jedisPoolConfig.setMaxIdle(maxIdle); // 连接池的最大数据库连接数
jedisPoolConfig.setMaxTotal(maxTotal); // 最大建立连接等待时间
jedisPoolConfig.setMaxWaitMillis(maxWaitMillis); // 逐出连接的最小空闲时间
默认1800000毫秒(30分钟)
jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis); //
每次逐出检查时逐出的最大数目如果为负数就是 : 1/abs(n), 默认3
jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun); //
逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
// 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
jedisPoolConfig.setTestOnBorrow(testOnBorrow); // 在空闲时检查有效性, 默认false
jedisPoolConfig.setTestWhileIdle(testWhileIdle); return jedisPoolConfig; } /**
* 配置redis的哨兵 * */ @Bean public RedisSentinelConfiguration
sentinelConfiguration() { RedisSentinelConfiguration redisSentinelConfiguration
= new RedisSentinelConfiguration(); // 配置redis的哨兵sentinel RedisNode
senRedisNode = new RedisNode(sentinelHostName, sentinelport); Set<RedisNode>
redisNodeSet = new HashSet<>(); redisNodeSet.add(senRedisNode);
redisSentinelConfiguration.setSentinels(redisNodeSet);
redisSentinelConfiguration.setMaster(masterName); return
redisSentinelConfiguration; } /** * 配置工厂 * * @param jedisPoolConfig * @return
*/ @Bean public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig
jedisPoolConfig, RedisSentinelConfiguration sentinelConfig) {
JedisConnectionFactory jedisConnectionFactory = new
JedisConnectionFactory(sentinelConfig, jedisPoolConfig); return
jedisConnectionFactory; } /** * 实例化 RedisTemplate 对象 * * @return */ @Bean
public RedisTemplate<String, Object>
functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
initDomainRedisTemplate(redisTemplate, redisConnectionFactory); return
redisTemplate; } /** * 设置数据存入 redis 的序列化方式,并开启事务 * * @param redisTemplate *
@param factory */ private void initDomainRedisTemplate(RedisTemplate<String,
Object> redisTemplate, RedisConnectionFactory factory) {
//如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to
String！ redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer()); //
开启事务 redisTemplate.setEnableTransactionSupport(true);
redisTemplate.setConnectionFactory(factory); } /** * 封装RedisTemplate * */
@Bean(name = "redisUtils") public RedisUtils redisUtil(RedisTemplate<String,
Object> redisTemplate) { RedisUtils redisUtil = new RedisUtils();
redisUtil.setRedisTemplate(redisTemplate); return redisUtil; } }
4.utils 配置 redisTemplate并且书写工具类
import org.springframework.data.redis.core.*; import java.io.Serializable;
import java.util.List; import java.util.Set; import
java.util.concurrent.TimeUnit; public class RedisUtils { private RedisTemplate
redisTemplate; public void setRedisTemplate(RedisTemplate redisTemplate) {
this.redisTemplate = redisTemplate; } public String buildStringToken(String
preString , String token){ StringBuilder sb = new StringBuilder();
sb.append(preString); sb.append(":"); sb.append(token); return sb.toString(); }
/** * 写入缓存 * @param key * @param value * @return */ public boolean set(final
String key, Object value) { boolean result = false; try {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value); result = true; } catch (Exception e) {
e.printStackTrace(); } return result; } /** * 写入缓存设置时效时间 * @param key * @param
value * @return */ public boolean set(final String key, Object value, Long
expireTime ,TimeUnit timeUnit) { boolean result = false; try {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value,5555L,TimeUnit.DAYS); redisTemplate.expire(key,
expireTime, timeUnit); result = true; } catch (Exception e) {
e.printStackTrace(); } return result; } /** * 批量删除对应的value * @param keys */
public void remove(final String... keys) { for (String key : keys) {
remove(key); } } /** * 批量删除key * @param pattern */ public void
removePattern(final String pattern) { Set<Serializable> keys =
redisTemplate.keys(pattern); if (keys.size() > 0){ redisTemplate.delete(keys);
} } /** * 删除对应的value * @param key */ public void remove(final String key) { if
(exists(key)) { redisTemplate.delete(key); } } /** * 判断缓存中是否有对应的value * @param
key * @return */ public boolean exists(final String key) { return
redisTemplate.hasKey(key); } /** * 读取缓存 * @param key * @return */ public Object
get(final String key) { Object result = null; ValueOperations<Serializable,
Object> operations = redisTemplate.opsForValue(); result = operations.get(key);
return result; } /** * 哈希添加 * @param key * @param hashKey * @param value */
public void hmSet(String key, Object hashKey, Object value){
HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
hash.put(key,hashKey,value); } /** * 哈希获取数据 * @param key * @param hashKey *
@return */ public Object hmGet(String key, Object hashKey){
HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
return hash.get(key,hashKey); } /** * 列表添加 * @param k * @param v */ public void
lPush(String k,Object v){ ListOperations<String, Object> list =
redisTemplate.opsForList(); list.rightPush(k,v); } /** * 列表获取 * @param k *
@param l * @param l1 * @return */ public List<Object> lRange(String k, long l,
long l1){ ListOperations<String, Object> list = redisTemplate.opsForList();
return list.range(k,l,l1); } /** * 集合添加 * @param key * @param value */ public
void add(String key,Object value){ SetOperations<String, Object> set =
redisTemplate.opsForSet(); set.add(key,value); } /** * 集合获取 * @param key *
@return */ public Set<Object> setMembers(String key){ SetOperations<String,
Object> set = redisTemplate.opsForSet(); return set.members(key); } /** *
有序集合添加 * @param key * @param value * @param scoure */ public void zAdd(String
key,Object value,double scoure){ ZSetOperations<String, Object> zset =
redisTemplate.opsForZSet(); zset.add(key,value,scoure); } /** * 有序集合获取 * @param
key * @param scoure * @param scoure1 * @return */ public Set<Object>
rangeByScore(String key,double scoure,double scoure1){ ZSetOperations<String,
Object> zset = redisTemplate.opsForZSet(); return zset.rangeByScore(key,
scoure, scoure1); } }

热门工具换一换