java 连接redis 我们都使用的 是jedis ，对于redis这种频繁请求的场景我们一般需要对其池化避免重复创建，即创建一个连接池 ，打开jedis的 jar包我们发现，jedis对池已经有了相关的 实现，根据pom 依赖可以清楚的知道 这是基于common-pool2连接池实现的。jedis的jar包中包含了三个连接池 JedisPool与JedisSentinelPool与ShardedJedisPool 。那么 jedis 为什么会包含三种实现方式呢 ？其实归根结底还是因为redis环境的 不同。单节点模式还是哨兵模式、还是集群共享模式
首先JedisPool 我们可以清晰的看见这是为单节点模式实现的连接池 ：
public JedisPool(final GenericObjectPoolConfig poolConfig, final String host, int port,
int timeout, final String password, final int database) {
this(poolConfig, host, port, timeout, password, database, null);
}
再打开JedisSentinelPool，我们可以看到这是基于哨兵模式的单节点的 连接池实现：
public JedisSentinelPool(String masterName, Set<String> sentinels,
final GenericObjectPoolConfig poolConfig, final String password) {
this(masterName, sentinels, poolConfig, Protocol.DEFAULT_TIMEOUT, password);
}
再打开ShardedJedisPool ，我们可以看到这是基于多个节点的 ，基于客户端分片的 redis组的连接池，具体原理是基于hash将不同的key 分配到不同的节点上，即提高了吞吐量，也可以一定程度避免单机风险。
public ShardedJedisPool(final GenericObjectPoolConfig poolConfig, List<JedisShardInfo> shards,
Hashing algo) {
this(poolConfig, shards, algo, null);
}
查看同时我们打开其节点信息JedisShardInfo，可以看见这是基于直连ip与端口的实现方式，生产环境一般不会直接提供这样的信息 。
public class JedisShardInfo extends ShardInfo<Jedis> {
public String toString() {
return host + ":" + port + "*" + getWeight();
}
private int timeout;
private String host;
private int port;
private String password = null;
private String name = null;
public String getHost() {
return host;
}
public int getPort() {
return port;
}
public JedisShardInfo(String host) {
super(Sharded.DEFAULT_WEIGHT);
URI uri = URI.create(host);
if (uri.getScheme() != null && uri.getScheme().equals("redis")) {
this.host = uri.getHost();
this.port = uri.getPort();
this.password = uri.getUserInfo().split(":", 2)[1];
} else {
this.host = host;
this.port = Protocol.DEFAULT_PORT;
}
}
在此，jedis链接池到上面就告一段落了 ，如果你的 环境信息与上面的一致，那么你可以放心的使用jedis连接池。
当然，ShardedJedisPool也会存在扩容的 问题详情见我的 下一篇文章。
来到我们的正文：
如果生产环境的redis是致力于高可用，我们一般是使用的哨兵模式，但是为避免单点风险，我们会创建多个redis服务使其形成一组redis集群（非集群模式），即是使哨兵模式，又是多节点的，那么你的链接池是否就应该是ShardedJedisSentinelPool了，这种JedisSentinelPool与ShardedJedisPool 构建的混合体。
那么其就应该是一下结构，以此来创建一个链接池：
public ShardedJedisSentinelPoolExt(Set<String> masters, Set<String> sentinels, GenericObjectPoolConfig poolConfig, String password) {
this((Set)masters, (Set)sentinels, poolConfig, 2000, password);
}
在此基础上按照JedisSentinel实现哨兵的加载与ShardedJedis实现客户端分片。
示例代码如下：
public class ShardedJedisSentinelPoolExt extends Pool<ShardedJedis> {
private static final int MAX_RETRY_SENTINEL = 10;
private static final Logger logger = LoggerFactory.getLogger(ShardedJedisSentinelPoolExt.class);
private GenericObjectPoolConfig poolConfig;
private int timeout;
private int sentinelRetry;
private String password;
private Set<ShardedJedisSentinelPoolExt.MasterListener> masterListeners;
private volatile List<HostAndPort> currentHostMasters;
private String redisMasterName;
private static Pattern pattern = Pattern.compile("^[A-Z0-9_]{5,200}\\$[0-9]{2,4}-[0-9]{2,4}([A-Z0-9_]{5,200})?");
public ShardedJedisSentinelPoolExt(Set<String> masters, Set<String> sentinels) {
this(masters, sentinels, new GenericObjectPoolConfig(), 2000, (String)null, 0);
}
public ShardedJedisSentinelPoolExt(Set<String> masters, Set<String> sentinels, String password) {
this((Set)masters, (Set)sentinels, new GenericObjectPoolConfig(), 2000, password);
}
public ShardedJedisSentinelPoolExt(GenericObjectPoolConfig poolConfig, Set<String> masters, Set<String> sentinels) {
this(masters, sentinels, poolConfig, 2000, (String)null, 0);
}
public ShardedJedisSentinelPoolExt(String mastersStr, String sentinelsStr, GenericObjectPoolConfig poolConfig, int timeout, String password) {
this.timeout = 2000;
this.sentinelRetry = 0;
this.masterListeners = new HashSet();
String[] splitMasters = mastersStr.split(",");
String[] splitSentinels = sentinelsStr.split(",");
List<String> masters = new ArrayList();
String[] var9 = splitMasters;
int var10 = splitMasters.length;
for(int var11 = 0; var11 < var10; ++var11) {
String splitMaster = var9[var11];
List<String> stringList = convertToMatch(splitMaster);
if (stringList != null) {
masters.addAll(stringList);
}
}
Set<String> setSentinels = new HashSet(Arrays.asList(splitSentinels));
this.poolConfig = poolConfig;
this.timeout = timeout;
this.password = password;
this.redisMasterName = mastersStr;
List<HostAndPort> masterList = this.initSentinels(setSentinels, masters);
this.initPool(masterList);
}
public ShardedJedisSentinelPoolExt(String mastersStr, Set<String> sentinels, GenericObjectPoolConfig poolConfig, int timeout, String password) {
this.timeout = 2000;
this.sentinelRetry = 0;
this.masterListeners = new HashSet();
String[] splitMasters = mastersStr.split(",");
Set<String> masters = new HashSet();
String[] var8 = splitMasters;
int var9 = splitMasters.length;
for(int var10 = 0; var10 < var9; ++var10) {
String splitMaster = var8[var10];
List<String> stringList = convertToMatch(splitMaster);
if (stringList != null) {
masters.addAll(stringList);
}
}
this.poolConfig = poolConfig;
this.timeout = timeout;
this.password = password;
this.redisMasterName = mastersStr;
List<String> masterStrList = new ArrayList(masters);
Collections.sort(masterStrList);
List<HostAndPort> masterList = this.initSentinels(sentinels, masterStrList);
this.initPool(masterList);
}
public ShardedJedisSentinelPoolExt(Set<String> masters, Set<String> sentinels, GenericObjectPoolConfig poolConfig, int timeout, String password) {
this(masters, sentinels, poolConfig, timeout, password, 0);
}
public ShardedJedisSentinelPoolExt(Set<String> masters, Set<String> sentinels, GenericObjectPoolConfig poolConfig, int timeout) {
this(masters, sentinels, poolConfig, timeout, (String)null, 0);
}
public ShardedJedisSentinelPoolExt(Set<String> masters, Set<String> sentinels, GenericObjectPoolConfig poolConfig, String password) {
this((Set)masters, (Set)sentinels, poolConfig, 2000, password);
}
public ShardedJedisSentinelPoolExt(Set<String> masters, Set<String> sentinels, GenericObjectPoolConfig poolConfig, int timeout, String password, int database) {
this.timeout = 2000;
this.sentinelRetry = 0;
this.masterListeners = new HashSet();
this.poolConfig = poolConfig;
this.timeout = timeout;
this.password = password;
List<String> masterStrList = new ArrayList(masters);
Collections.sort(masterStrList);
List<HostAndPort> masterList = this.initSentinels(sentinels, masterStrList);
this.initPool(masterList);
}
public void destroy() {
Iterator var1 = this.masterListeners.iterator();
while(var1.hasNext()) {
ShardedJedisSentinelPoolExt.MasterListener m = (ShardedJedisSentinelPoolExt.MasterListener)var1.next();
m.shutdown();
}
super.destroy();
}
public List<HostAndPort> getCurrentHostMaster() {
return this.currentHostMasters;
}
private void initPool(List<HostAndPort> masters) {
if (!masterEquals(this.currentHostMasters, masters)) {
StringBuilder sb = new StringBuilder();
Iterator var3 = masters.iterator();
while(var3.hasNext()) {
HostAndPort master = (HostAndPort)var3.next();
sb.append(master.toString());
sb.append(" ");
}
logger.info("Created ShardedJedisPool to master at [" + sb.toString() + "]");
List<JedisShardInfo> shardMasters = this.makeShardInfoList(masters);
this.initPool(this.poolConfig, new ShardedJedisSentinelPoolExt.ShardedJedisFactory(shardMasters, Hashing.MURMUR_HASH, (Pattern)null));
this.currentHostMasters = masters;
}
}
private static boolean masterEquals(List<HostAndPort> currentShardMasters, List<HostAndPort> shardMasters) {
if (currentShardMasters != null && shardMasters != null && currentShardMasters.size() == shardMasters.size()) {
for(int i = 0; i < currentShardMasters.size(); ++i) {
if (!((HostAndPort)currentShardMasters.get(i)).equals(shardMasters.get(i))) {
return false;
}
}
return true;
} else {
return false;
}
}
private List<JedisShardInfo> makeShardInfoList(List<HostAndPort> masters) {
List<JedisShardInfo> shardMasters = new ArrayList();
Iterator var3 = masters.iterator();
while(var3.hasNext()) {
HostAndPort master = (HostAndPort)var3.next();
JedisShardInfo jedisShardInfo = new JedisShardInfo(master.getHost(), master.getPort(), this.timeout);
jedisShardInfo.setPassword(this.password);
shardMasters.add(jedisShardInfo);
}
return shardMasters;
}
private List<HostAndPort> initSentinels(Set<String> sentinels, List<String> masters) {
Map<String, HostAndPort> masterMap = new HashMap();
List<HostAndPort> shardMasters = new ArrayList();
logger.info("Trying to find all master:" + masters + "from available Sentinels:" + sentinels);
Iterator var5 = masters.iterator();
boolean fetched;
do {
String masterName;
if (!var5.hasNext()) {
if (!masters.isEmpty() && masters.size() == shardMasters.size()) {
var5 = sentinels.iterator();
while(var5.hasNext()) {
masterName = (String)var5.next();
String threadName = "master-listener-sentinel-" + masterName;
logger.info("Starting Sentinel listeners thread " + masterName);
HostAndPort hap = toHostAndPort(Arrays.asList(masterName.split(":")));
ShardedJedisSentinelPoolExt.MasterListener masterListener = new ShardedJedisSentinelPoolExt.MasterListener(masters, hap.getHost(), hap.getPort(), threadName);
this.masterListeners.add(masterListener);
masterListener.start();
}
}
return shardMasters;
}
masterName = (String)var5.next();
HostAndPort master = null;
fetched = false;
while(!fetched && this.sentinelRetry < 10) {
Iterator var9 = sentinels.iterator();
while(var9.hasNext()) {
String sentinel = (String)var9.next();
HostAndPort hap = toHostAndPort(Arrays.asList(sentinel.split(":")));
logger.info("Connecting to Sentinel " + hap);
try {
Jedis jedis = new Jedis(hap.getHost(), hap.getPort());
Throwable var13 = null;
try {
master = (HostAndPort)masterMap.get(masterName);
if (master == null) {
List<String> hostAndPort = jedis.sentinelGetMasterAddrByName(masterName);
if (hostAndPort != null && !hostAndPort.isEmpty()) {
master = toHostAndPort(hostAndPort);
logger.info("Found Redis master " + masterName + " at " + master);
shardMasters.add(master);
masterMap.put(masterName, master);
fetched = true;
jedis.disconnect();
break;
}
}
} catch (Throwable var27) {
var13 = var27;
throw var27;
} finally {
if (jedis != null) {
if (var13 != null) {
try {
jedis.close();
} catch (Throwable var26) {
var13.addSuppressed(var26);
}
} else {
jedis.close();
}
}
}
} catch (JedisException var29) {
logger.error("Cannot connect to sentinel :{} ,Trying next one sentinel , errorMsg:{}", new Object[]{hap, var29.getMessage(), var29});
}
}
if (null == master) {
try {
logger.warn("All sentinels down, cannot determine where is " + masterName + " master is running... sleeping 1000ms, Will try again.");
Thread.sleep(1000L);
} catch (InterruptedException var25) {
logger.error(var25.getMessage(), var25);
}
fetched = false;
++this.sentinelRetry;
}
}
} while(fetched);
logger.error("All sentinels down and try 10 times, Abort.");
throw new JedisConnectionException("Cannot connect all sentinels, Abort.");
}
private static HostAndPort toHostAndPort(List<String> getMasterAddrByNameResult) {
String host = (String)getMasterAddrByNameResult.get(0);
int port = Integer.parseInt((String)getMasterAddrByNameResult.get(1));
return new HostAndPort(host, port);
}
public static List<String> convertToMatch(String str) {
List<String> stringList = new ArrayList();
Matcher matcher = pattern.matcher(str);
if (!matcher.matches()) {
stringList.add(str);
return stringList;
} else {
String prefix = str.substring(0, str.indexOf("$"));
String suffix = str.substring(str.indexOf("$") + 1);
String[] split = suffix.split("-");
if (split.length != 2) {
return Collections.emptyList();
} else {
String startStr = split[0];
boolean isBeginWithZero = startStr.indexOf("0") == 0;
Integer beginNumber = Integer.valueOf(startStr);
String endStr = split[1];
int endStrLength = endStr.length();
int lastNumberIndex = 0;
for(int i = 0; i < endStrLength; ++i) {
char c = endStr.charAt(i);
if (!Character.isDigit(c)) {
lastNumberIndex = i;
break;
}
}
String endSuffix = "";
if (lastNumberIndex > 0) {
endSuffix = endStr.substring(lastNumberIndex);
endStr = endStr.substring(0, lastNumberIndex);
}
for(Integer endNumber = Integer.valueOf(endStr); beginNumber <= endNumber; beginNumber = beginNumber + 1) {
StringBuilder stringBuilder = new StringBuilder(prefix);
if (isBeginWithZero && beginNumber < 10) {
stringBuilder.append("0");
}
stringBuilder.append(beginNumber);
stringBuilder.append(endSuffix);
stringList.add(stringBuilder.toString());
}
return stringList;
}
}
}
public String getRedisMasterName() {
return this.redisMasterName;
}
public void setRedisMasterName(String redisMasterName) {
this.redisMasterName = redisMasterName;
}
public GenericObjectPoolConfig getPoolConfig() {
return this.poolConfig;
}
public void setPoolConfig(GenericObjectPoolConfig poolConfig) {
this.poolConfig = poolConfig;
}
protected class MasterListener extends Thread {
protected List<String> masters;
protected String host;
protected int port;
protected long subscribeRetryWaitTimeMillis;
protected Jedis jedis;
protected AtomicBoolean running;
public MasterListener(List<String> masters, String host, int port) {
this.subscribeRetryWaitTimeMillis = 5000L;
this.running = new AtomicBoolean(false);
this.masters = masters;
this.host = host;
this.port = port;
}
public MasterListener(List<String> masters, String host, int port, String threadName) {
super(threadName);
this.subscribeRetryWaitTimeMillis = 5000L;
this.running = new AtomicBoolean(false);
this.masters = masters;
this.host = host;
this.port = port;
}
public MasterListener(List<String> masters, String host, int port, long subscribeRetryWaitTimeMillis) {
this(masters, host, port);
this.subscribeRetryWaitTimeMillis = subscribeRetryWaitTimeMillis;
}
public void run() {
this.running.set(true);
if (this.running.get()) {
do {
this.jedis = new Jedis(this.host, this.port);
try {
this.jedis.subscribe(new ShardedJedisSentinelPoolExt.JedisPubSubAdapter() {
public void onMessage(String channel, String message) {
ShardedJedisSentinelPoolExt.logger.info("Sentinel " + MasterListener.this.host + ":" + MasterListener.this.port + " published: " + message + ".");
String[] switchMasterMsg = message.split(" ");
if (switchMasterMsg.length > 3) {
int index = MasterListener.this.masters.indexOf(switchMasterMsg[0]);
if (index >= 0) {
HostAndPort newHostMaster = ShardedJedisSentinelPoolExt.toHostAndPort(Arrays.asList(switchMasterMsg[3], switchMasterMsg[4]));
List<HostAndPort> newHostMasters = new ArrayList();
for(int i = 0; i < MasterListener.this.masters.size(); ++i) {
newHostMasters.add((Object)null);
}
Collections.copy(newHostMasters, ShardedJedisSentinelPoolExt.this.currentHostMasters);
newHostMasters.set(index, newHostMaster);
ShardedJedisSentinelPoolExt.this.initPool(newHostMasters);
} else {
StringBuilder sb = new StringBuilder();
Iterator var9 = MasterListener.this.masters.iterator();
while(var9.hasNext()) {
String masterName = (String)var9.next();
sb.append(masterName);
sb.append(",");
}
ShardedJedisSentinelPoolExt.logger.info("Ignoring message on +switch-master for master name " + switchMasterMsg[0] + ", our monitor master name are [" + sb + "]");
}
} else {
ShardedJedisSentinelPoolExt.logger.warn("Invalid message received on Sentinel " + MasterListener.this.host + ":" + MasterListener.this.port + " on channel +switch-master: " + message);
}
}
}, new String[]{"+switch-master"});
} catch (JedisConnectionException var4) {
ShardedJedisSentinelPoolExt.logger.error("Lost connection to Sentinel at {}:{},{}", new Object[]{this.host, this.port, var4.getMessage(), var4});
if (this.running.get()) {
ShardedJedisSentinelPoolExt.logger.warn("Lost connection to Sentinel at " + this.host + ":" + this.port + ". Sleeping 5000ms and retrying.");
try {
Thread.sleep(this.subscribeRetryWaitTimeMillis);
} catch (InterruptedException var3) {
ShardedJedisSentinelPoolExt.logger.error(var3.getMessage(), var3);
}
} else {
ShardedJedisSentinelPoolExt.logger.error("Unsubscribing from Sentinel at " + this.host + ":" + this.port);
}
}
} while(this.running.get());
}
}
public void shutdown() {
try {
ShardedJedisSentinelPoolExt.logger.info("Shutting down listener on " + this.host + ":" + this.port);
this.running.set(false);
this.jedis.disconnect();
} catch (Exception var2) {
ShardedJedisSentinelPoolExt.logger.error("Caught exception while shutting down: " + var2.getMessage());
throw new CcspRuntimeException(var2);
}
}
}
protected class JedisPubSubAdapter extends JedisPubSub {
protected JedisPubSubAdapter() {
}
}
protected static class ShardedJedisFactory implements PooledObjectFactory<ShardedJedis> {
private List<JedisShardInfo> shards;
private Hashing algo;
private Pattern keyTagPattern;
public ShardedJedisFactory(List<JedisShardInfo> shards, Hashing algo, Pattern keyTagPattern) {
this.shards = shards;
this.algo = algo;
this.keyTagPattern = keyTagPattern;
}
public PooledObject<ShardedJedis> makeObject() throws Exception {
ShardedJedis jedis = new ShardedJedis(this.shards, this.algo, this.keyTagPattern);
return new DefaultPooledObject(jedis);
}
public void destroyObject(PooledObject<ShardedJedis> pooledShardedJedis) throws Exception {
ShardedJedis shardedJedis = (ShardedJedis)pooledShardedJedis.getObject();
Iterator var3 = shardedJedis.getAllShards().iterator();
while(var3.hasNext()) {
Jedis jedis = (Jedis)var3.next();
try {
jedis.quit();
} catch (Exception var7) {
ShardedJedisSentinelPoolExt.logger.error(var7.getMessage(), var7);
}
try {
jedis.disconnect();
} catch (Exception var6) {
ShardedJedisSentinelPoolExt.logger.error(var6.getMessage(), var6);
}
}
}
public boolean validateObject(PooledObject<ShardedJedis> pooledShardedJedis) {
try {
ShardedJedis jedis = (ShardedJedis)pooledShardedJedis.getObject();
Iterator var3 = jedis.getAllShards().iterator();
Jedis shard;
do {
if (!var3.hasNext()) {
return true;
}
shard = (Jedis)var3.next();
} while("PONG".equals(shard.ping()));
return false;
} catch (Exception var5) {
ShardedJedisSentinelPoolExt.logger.error(var5.getMessage(), var5);
return false;
}
}
public void activateObject(PooledObject<ShardedJedis> p) throws Exception {
}
public void passivateObject(PooledObject<ShardedJedis> p) throws Exception {
}
}
}