JedisSentinelPool的相关配置与操作

最新推荐文章于 2023-07-13 14:49:40 发布
最新推荐文章于 2023-07-13 14:49:40 发布
阅读量2.2k 收藏 2
点赞数 1
文章标签： 数据库 python java
原文链接：https://my.oschina.net/visionit/blog/756319
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

前面文章《一步步实现redis+sentinel双机热备》中已经分享了如何配置使用redis自带监听程序sentinel实现双机热备，这篇文章将继续分享，客户端程序需要做哪些调整。

Spring配置文件

<context:property-placeholder ignore-unresolvable="true" location="classpath:redis.properties" />
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
	<property name="maxTotal" value="${redis.maxTotal}" />
	<property name="minIdle" value="${redis.minIdle}" />
	<property name="maxWaitMillis" value="${redis.maxWaitTime}" />
	<property name="maxIdle" value="${redis.maxIdle}" />
	<property name="testOnBorrow" value="${redis.testOnBorrow}" />
	<property name="testOnReturn" value="true" />
	<property name="testWhileIdle" value="true" />
</bean>
<bean id="jedisSentinelPool" class="redis.clients.jedis.JedisSentinelPool">
	<constructor-arg index="0" value="mymaster" />
	<constructor-arg index="1">
		<set>
			<value>${redis.sentinel1.host}:${redis.sentinel1.port}</value>
			<value>${redis.sentinel2.host}:${redis.sentinel2.port}</value>
		</set>
	</constructor-arg>
	<constructor-arg index="2" ref="poolConfig" />
	<constructor-arg index="3" value="${redis.password}" />
</bean>

 Redis配置信息

#sentinel1的IP和端口
redis.sentinel1.host=192.168.231.130
redis.sentinel1.port=26379
#sentinel2的IP和端口  
redis.sentinel2.host=192.168.231.130
redis.sentinel2.port=26380
redis.password=123456
 
redis.maxIdle=500
redis.maxTotal=5000
redis.maxWaitTime=1000 
redis.testOnBorrow=true
redis.minIdle=300

注意：这里的端口和地址都是sentinel的配置，不要用成redis的了

Jedis工具类

import java.util.List;
import java.util.Map;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.powercn.fcity.common.base.Global;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisSentinelPool;
import redis.clients.jedis.exceptions.JedisException;

public class JedisUtils {

	private static Logger logger = LoggerFactory.getLogger(JedisUtils.class);
	
//	private static JedisPool jedisPool = SpringContextHolder.getBean(JedisPool.class);
	private static JedisSentinelPool jedisPool=SpringContextHolder.getBean(JedisSentinelPool.class);;
	public static final String KEY_PREFIX = Global.getConfig("redis.keyPrefix");

	public static String get(String key) {
		String value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				value = jedis.get(key);
				value = StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value) ? value : null;
			}
			logger.debug("get {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("get {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}
	
	public static Set<String> keys(String pattern) {
		Set<String> value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			value=jedis.keys(pattern);
			logger.debug("keys {} = {}", pattern, value);
			return value;
		} catch (Exception e) {
			logger.warn("keys {} = {}", pattern, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}

	public static Object getObject(String key) {
		Object value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				value = toObject(jedis.get(getBytesKey(key)));
				logger.debug("getObject {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObject {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}

	public static String set(String key, String value, int cacheSeconds) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.set(key, value);
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("set {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("set {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static String setObject(String key, Object value, int cacheSeconds) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.set(getBytesKey(key), toBytes(value));
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setObject {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObject {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static List<String> getList(String key) {
		List<String> value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				value = jedis.lrange(key, 0, -1);
				logger.debug("getList {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getList {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}

	public static List<Object> getObjectList(String key) {
		List<Object> value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				List<byte[]> list = jedis.lrange(getBytesKey(key), 0, -1);
				value = Lists.newArrayList();
				for (byte[] bs : list){
					value.add(toObject(bs));
				}
				logger.debug("getObjectList {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObjectList {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}

	public static long setList(String key, List<String> value, int cacheSeconds) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				jedis.del(key);
			}
			result = jedis.rpush(key, (String[])value.toArray());
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setList {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setList {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static long setObjectList(String key, List<Object> value, int cacheSeconds) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				jedis.del(key);
			}
			List<byte[]> list = Lists.newArrayList();
			for (Object o : value){
				list.add(toBytes(o));
			}
			result = jedis.rpush(getBytesKey(key), (byte[][])list.toArray());
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setObjectList {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObjectList {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static long listAdd(String key, String... value) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.rpush(key, value);
			logger.debug("listAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("listAdd {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static long listObjectAdd(String key, Object... value) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			List<byte[]> list = Lists.newArrayList();
			for (Object o : value){
				list.add(toBytes(o));
			}
			result = jedis.rpush(getBytesKey(key), (byte[][])list.toArray());
			logger.debug("listObjectAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("listObjectAdd {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static Set<String> getSet(String key) {
		Set<String> value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				value = jedis.smembers(key);
				logger.debug("getSet {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getSet {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}

	public static Set<Object> getObjectSet(String key) {
		Set<Object> value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				value = Sets.newHashSet();
				Set<byte[]> set = jedis.smembers(getBytesKey(key));
				for (byte[] bs : set){
					value.add(toObject(bs));
				}
				logger.debug("getObjectSet {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObjectSet {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}

	public static long setSet(String key, Set<String> value, int cacheSeconds) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				jedis.del(key);
			}
			result = jedis.sadd(key, (String[])value.toArray());
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setSet {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setSet {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static long setObjectSet(String key, Set<Object> value, int cacheSeconds) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				jedis.del(key);
			}
			Set<byte[]> set = Sets.newHashSet();
			for (Object o : value){
				set.add(toBytes(o));
			}
			result = jedis.sadd(getBytesKey(key), (byte[][])set.toArray());
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setObjectSet {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObjectSet {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static long setSetAdd(String key, String... value) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.sadd(key, value);
			logger.debug("setSetAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setSetAdd {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static long setSetObjectAdd(String key, Object... value) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			Set<byte[]> set = Sets.newHashSet();
			for (Object o : value){
				set.add(toBytes(o));
			}
			result = jedis.rpush(getBytesKey(key), (byte[][])set.toArray());
			logger.debug("setSetObjectAdd {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setSetObjectAdd {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static Map<String, String> getMap(String key) {
		Map<String, String> value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				value = jedis.hgetAll(key);
				logger.debug("getMap {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getMap {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}

	public static Map<String, Object> getObjectMap(String key) {
		Map<String, Object> value = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				value = Maps.newHashMap();
				Map<byte[], byte[]> map = jedis.hgetAll(getBytesKey(key));
				for (Map.Entry<byte[], byte[]> e : map.entrySet()){
					value.put(StringUtils.toString(e.getKey()), toObject(e.getValue()));
				}
				logger.debug("getObjectMap {} = {}", key, value);
			}
		} catch (Exception e) {
			logger.warn("getObjectMap {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return value;
	}

	public static String setMap(String key, Map<String, String> value, int cacheSeconds) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)) {
				jedis.del(key);
			}
			result = jedis.hmset(key, value);
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setMap {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setMap {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static String setObjectMap(String key, Map<String, Object> value, int cacheSeconds) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))) {
				jedis.del(key);
			}
			Map<byte[], byte[]> map = Maps.newHashMap();
			for (Map.Entry<String, Object> e : value.entrySet()){
				map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
			}
			result = jedis.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
			if (cacheSeconds != 0) {
				jedis.expire(key, cacheSeconds);
			}
			logger.debug("setObjectMap {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("setObjectMap {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static String mapPut(String key, Map<String, String> value) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.hmset(key, value);
			logger.debug("mapPut {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("mapPut {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static String mapObjectPut(String key, Map<String, Object> value) {
		String result = null;
		Jedis jedis = null;
		try {
			jedis = getResource();
			Map<byte[], byte[]> map = Maps.newHashMap();
			for (Map.Entry<String, Object> e : value.entrySet()){
				map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
			}
			result = jedis.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
			logger.debug("mapObjectPut {} = {}", key, value);
		} catch (Exception e) {
			logger.warn("mapObjectPut {} = {}", key, value, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static long mapRemove(String key, String mapKey) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.hdel(key, mapKey);
			logger.debug("mapRemove {}  {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapRemove {}  {}", key, mapKey, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static long mapObjectRemove(String key, String mapKey) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.hdel(getBytesKey(key), getBytesKey(mapKey));
			logger.debug("mapObjectRemove {}  {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapObjectRemove {}  {}", key, mapKey, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static boolean mapExists(String key, String mapKey) {
		boolean result = false;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.hexists(key, mapKey);
			logger.debug("mapExists {}  {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapExists {}  {}", key, mapKey, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static boolean mapObjectExists(String key, String mapKey) {
		boolean result = false;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.hexists(getBytesKey(key), getBytesKey(mapKey));
			logger.debug("mapObjectExists {}  {}", key, mapKey);
		} catch (Exception e) {
			logger.warn("mapObjectExists {}  {}", key, mapKey, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static long del(String key) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(key)){
				result = jedis.del(key);
				logger.debug("del {}", key);
			}else{
				logger.debug("del {} not exists", key);
			}
		} catch (Exception e) {
			logger.warn("del {}", key, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static long delObject(String key) {
		long result = 0;
		Jedis jedis = null;
		try {
			jedis = getResource();
			if (jedis.exists(getBytesKey(key))){
				result = jedis.del(getBytesKey(key));
				logger.debug("delObject {}", key);
			}else{
				logger.debug("delObject {} not exists", key);
			}
		} catch (Exception e) {
			logger.warn("delObject {}", key, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static boolean exists(String key) {
		boolean result = false;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.exists(key);
			logger.debug("exists {}---{}", key,result);
		} catch (Exception e) {
			logger.warn("exists {}", key, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static boolean existsObject(String key) {
		boolean result = false;
		Jedis jedis = null;
		try {
			jedis = getResource();
			result = jedis.exists(getBytesKey(key));
			logger.debug("existsObject {}", key);
		} catch (Exception e) {
			logger.warn("existsObject {}", key, e);
		} finally {
			returnResource(jedis);
		}
		return result;
	}

	public static Jedis getResource() throws JedisException {
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
//			logger.debug("getResource.", jedis);
		} catch (JedisException e) {
			logger.warn("getResource.", e);
			returnBrokenResource(jedis);
			throw e;
		}
		return jedis;
	}

	public static void returnBrokenResource(Jedis jedis) {
		if (jedis != null) {
			jedisPool.returnBrokenResource(jedis);
		}
	}

	public static void returnResource(Jedis jedis) {
		if (jedis != null) {
			jedisPool.returnResource(jedis);
		}
	}

	public static byte[] getBytesKey(Object object){
		if(object instanceof String){
    		return StringUtils.getBytes((String)object);
    	}else{
    		return ObjectUtils.serialize(object);
    	}
	}

	public static byte[] toBytes(Object object){
    	return ObjectUtils.serialize(object);
	}

	public static Object toObject(byte[] bytes){
		return ObjectUtils.unserialize(bytes);
	}

}

实际上需要调整的部分并不多，只需要将JedisPool换成JedisSentinelPool，其他操作部分基本可以不变。

转载于:https://my.oschina.net/visionit/blog/756319

weixin_34302798
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
jedis通过JedisSentinelPool获取jedis操作redis
11-14
jedis通过JedisSentinelPool获取jedis操作redis，通过配置sentienl，获取sentinel连接池，通过sentinel，获取jedis信息
redis 哨兵连接池 JedisSentinelPool 实现对redis集群操作（一般是 一主二从三哨兵）
Kurumi
07-22 4540
1.配置基本参数 在 yml 文件中配置基本参数 myjedis: redis: config: #集群节点 nodes: 172.21.1.111:26379,172.21.2.111:26379 masterName: mymaster password: 123456 database: 8 #总数 maxTotal: 100 #最大空闲数 maxIdle: 50 #
redis实战第五篇 jedis 连接 redis sentinel详解
热门推荐
超人不会飞
02-13 1万+
jedis针对redis sentinel给出了一个JedisSentinelPool，jedis给出了很多的构造方法，其中比较全的是下面这个，注意，这个连接池争对的连接还是主节点: public JedisSentinelPool(String masterName, Set&amp;amp;lt;String&amp;amp;gt; sentinels,final GenericObjectPoolConfig poolCo...
redis哨兵
weixin_44655181的博客
10-28 474
在主从复制模式下， 一旦主节点宕机， 需要人工干预进行故障转移， 给应用方和运维带来了使用的不便。 引入哨兵， 主节点故障后，重新选举新的主节点， 实现了风险转移。 9.1 基本概念 redis数据节点： 主节点和从节点 sentinel节点： 用来监控redis数据节点 sentinel节点集合：若干 sentinel 节点组成的抽象组合 1 sentinel的架构 sentinel架构和主从复...
JedisSentinelPool 配置文件设置
不思海的专栏
07-19 7245
spring-mvc中通过JedisSentinelPool配置redis数据库. 1、配置单节点的reidis服务器<beans> 2、配置主从配置的reidis服务器
jedispool连redis高并发卡死的问题
08-27
本篇文章主要介绍了jedispool连redis高并发卡死的问题，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Jedis出现connection timeout问题解决方法（JedisPool连接池使用实例）
09-04
主要介绍了Jedis出现connection timeout问题解决方法,使用Jedis的JedisPool连接池解决了这个问题,需要的朋友可以参考下
redis，jedis，sentinel需要的两个jar包
09-29
jedis所需jar包.rar 包括commons-pool2-2.4.2.jar 和 jedis-2.9.0.jar
redis源码以及哨片分片连接池实现
06-15
包含redis源码，哨兵多节点分片连接池扩展实现代码，ShardedJedisPool分片连接池测试类实现，JedisSentinelPool哨兵连接池测试类实现，JedisPool连接池测试实现类，
Redis 集群的三种方案
oyc的博客
09-16 786
Redis 集群的三种方案 一、主从复制 slave of 二、哨兵模式（Sentinel） 三、集群（Cluster）
Redis Jedis 之 JedisSentinelPool 源码分析
Heqianqian的博客
10-04 2626
概述Jedis是Redis官网推荐的Java客户端，Redis-Sentinel作为官方推荐的HA解决方案，Jedis也在客户端角度实现了对Sentinel的支持，主要实现在JedisSentinelPool.java这个类中，Jedis的JedisSentinelPool的实现仅仅适用于单个master-slave。属性JedisSentinelPool类有以下属性 //基于apache的comm
jedispool redis哨兵_sentinel、JedisSentinelPool实战
weixin_35658042的博客
01-13 1455
一、最小sentinel集群配置Redis 2.8，其Sentinel版本称为Sentinel 2，是在Sentinel 1的基础上重写的。因为Sentinel 1已经废弃而且BUG太多，所以强烈建议将Redis和Sentinel均升级到2.8版本，本文中安装的版本为最新的2.8.23。1、环境：centos主机的IP：172.30.37.73在centos上安装redis软件，然后添加配置文件，...
jedispool redis哨兵_通过java哨兵JedisSentinelPool代码示例连接对配置的redis哨兵主从模式进行测试验证...
weixin_39771987的博客
12-22 374
一、前言本文章通过关于java的jedis(2.6.0)的redis客户端连接驱动包，对配置的redis哨兵+主从读写模式配置进行示例代码验证，详细参见具体配置步骤&示例代码说明部分。二、配置步骤1. 安装redis(参考其他文章教程),并配置主从模式(参考其他相关文章，这里分别在本地通过配置进行模拟三台主从服务器，端口分别为6379、7380、6381)2. 从解压安装文件复制senti...
JedisSentinelPool配置说明
汐日南莘的博客
03-21 8366
Jedis是Java最常用的用于连接Redis的客户端。也是Redis官方推荐的Redis连接客户端之一。一般在项目中是使用Spring来管理jedis的连接池的，利用Spring ioc容器来管理。 <!--配置Jedis连接池--> <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig"> <pr
python现在版本强势英雄_Python - - 项目实战 - - 英雄登场
weixin_39752880的博客
12-20 119
目标设计 英雄 和 子弹 类使用 pygame.key.get_pressed() 移动英雄发射 子弹01，设计 英雄 和 子弹 类英雄需求1，游戏启动后，英雄 出现在屏幕的 水平中间 位置，距离 屏幕底部 120 像素2，英雄 每隔 0.5 秒 发射一次子弹，每次 连发三枚子弹3，英雄 默认不会移动，需要通过 左/右 方向键，控制 英雄 在水平方向移动子弹需求1，子弹 从 英雄 的正上方发射 沿...
从JedisSentinelPool获取jedis
developer
03-18 338
@Bean public Jedis getjedis() { JedisSentinelPool redisSentinelPool = null; redisSentinelPool = new JedisSentinelPool(master, set, redis_password, sentinel_password); Jedis jedis = null; try { jedis = redisSentinelPool.getResource(); re...
Jedis哨兵模式如何实现主从的读写分离
最新发布
cj_eryue的博客
07-13 305
redis的主从和哨兵模式，在官方的功能模式下，从实例只有数据备份和作为主实例的备机作用，并不具备我们想象中的主实例负责写，从实例负责读的职责分工。 Jedis哨兵模式如何实现主从的读写分离？
java(JedisSentinelPool)+redis集群（主从复制+哨兵模式）的心得
qq_40259907的博客
10-24 8701
一，使用的java + redis的集群（主从复制+哨兵模式）时，redis的的配置注意事项。  1，redis.conf配置文件    ①关闭保护模式  protected-mode  no  在高版本的Redis的中才有这个配置，本文用的是redis4.0.10 ②设置为守护线程 ③bind配置注释掉 2，sentinel.conf ①关闭保护模式  protected-...
jedis连接池JedisSentinelPool企业级应用（示例以及踩过的坑）
qq_43151441的博客
06-05 2543
在使用客户端jedis去操作redis的时候，通常来说，企业一般会标配集群+哨兵模式。使用jidis连接池的重要性不亚于mysql的Druid，良好的连接池性能，对redis读写性能是非常友好的。 话不多说，直接上代码（固定架构） public class Test { public static void main(String args[]) { //连接池配置 JedisPoolConfig jedisPoolConfig = new JedisPoolCo.
new JedisSentinelPool怎么使用
06-08
使用 JedisSentinelPool，需要以下步骤： 1. 导入依赖 ```xml <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>${jedis.version}</version> </dependency> ``` 2. 创建 JedisSentinelPool 对象 ```java Set<String> sentinels = new HashSet<String>(); sentinels.add("127.0.0.1:26379"); JedisSentinelPool jedisSentinelPool = new JedisSentinelPool("mymaster", sentinels); ``` 其中，第一个参数是 Redis Sentinel 的主节点名称，第二个参数是一个 Set 集合，包含了所有 Redis Sentinel 的地址和端口号信息。 3. 获取 Jedis 对象 ```java Jedis jedis = jedisSentinelPool.getResource(); ``` 4. 使用 Jedis 对象进行操作 ```java jedis.set("key", "value"); String value = jedis.get("key"); ``` 5. 关闭 Jedis 对象和 JedisSentinelPool 对象 ```java jedis.close(); jedisSentinelPool.close(); ``` 注意：在使用 JedisSentinelPool 时，需要注意线程安全问题，因为 JedisSentinelPool 对象是线程安全的，但是获取的 Jedis 对象就不是线程安全的了。因此，建议每个线程都创建自己的 Jedis 对象，并在使用完毕后将其关闭。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值