本文共 9605 字，大约阅读时间需要 32 分钟。
说明：
下面的示例基本都是基于Linux去实现，目的是为了环境的统一，以便于把性能调整到最优。且基于Java。建议生产环境不要使用Windows/Mac OS这些。
在Java领域，基于客户端进行分片最常用的库应该是Jedis，下面基本是基于Jedis进行实例实践。当然，除了这个还可以基于自己的业务去实现。
现在官方已经出到了4.0版本，也同样支持了集群功能，那么现在市面上基本不用客户端去实现分片做集群，主要集中在服务端来达到高可用的Redis集群，所以，是否有必要客户端去实现集群，需要在自己的业务上来深入考究。
同样的，除了官方集群外，还有很多成熟的方案去实现服务端集群，比如推特、豌豆荚这些官方开源的方案等。
在客户端进行分片来达到集群的效果，最简单的理解应该是这样：A和B两个Key，通过Hash得到A放在Redis1，B放在Redis2中。（先忽略Redis其中一台挂掉的问题，对于算法远没有在这里说的那么简单）。
分片的大致原理都是基于Hash算法来制定哪个Key放到哪个Redis中。
在这篇文章中提到的几款客户端中都已经实现了分片的操作。
下面是基于Jedis去实现了客户端分片功能配置：
对于单实例的Redis的使用，我们可以用Jedis，并发环境下我们可以用JedisPool。但是这两种方法否是针对于单实例的Redis的情况下使用的，但是有时候我们的业务可能不是单实例Redis能支撑的，那么我们这时候需要引入多个实例进行“数据分区”。其实好多人都说，用Redis集群不就搞定了吗？但是Redis集群无论部署还是维护成本都比较高，对于一些业务来说，使用起来还是成本很高。所以，对我们来说更好的方案可能是在客户端实现对数据的手动分区.
对于分区的方案，我感觉大多数人都会想到Hash，的确Hash是最简单最有效的方式。但是Hash的问题是：“单节点挂掉不可用，数据量大了不好扩容”。对于如果业务的可靠性要求不高同时数据可控的情况下可以考虑数据分区的方式。
其实数据分区就是Shard，其实Redis已经对Shard有很好的支持了，用到的是ShardedJedisPool，接下来简单的搞一下数据分片：
package redis.clients.jedis.tests;import org.junit.Before;import org.junit.Test;import redis.clients.jedis.*;import java.util.ArrayList;import java.util.List;/** * ShardJedis的测试类 */public class ShardJedisTest { private ShardedJedisPool sharedPool; @Before public void initJedis(){ JedisPoolConfig config =new JedisPoolConfig();//Jedis池配置 config.setTestOnBorrow(true); String hostA = "127.0.0.1"; int portA = 6381; String hostB = "127.0.0.1"; int portB = 6382; List jdsInfoList =new ArrayList (2); JedisShardInfo infoA = new JedisShardInfo(hostA, portA); JedisShardInfo infoB = new JedisShardInfo(hostB, portB); jdsInfoList.add(infoA); jdsInfoList.add(infoB); sharedPool =new ShardedJedisPool(config, jdsInfoList); } @Test public void testSetKV() throws InterruptedException { try { for (int i=0;i<50;i++){ String key = "test"+i; ShardedJedis jedisClient = sharedPool.getResource(); System.out.println(key+":"+jedisClient.getShard(key).getClient().getHost()+":"+jedisClient.getShard(key).getClient().getPort()); System.out.println(jedisClient.set(key,Math.random()+"")); jedisClient.close(); } }catch (Exception e){ e.printStackTrace(); } }} 这里我是用JUnit做的测试，我在本机开了两个Redis实例：
端口号分别是6381和6382。然后用ShardedJedisPool实现了一个Shard，主要是生成了50个Key，分别存到Redis中。运行结果如下：
test0:127.0.0.1:6382OKtest1:127.0.0.1:6382OKtest2:127.0.0.1:6381OKtest3:127.0.0.1:6382OKtest4:127.0.0.1:6382OKtest5:127.0.0.1:6382OKtest6:127.0.0.1:6382OKtest7:127.0.0.1:6382OKtest8:127.0.0.1:6381OKtest9:127.0.0.1:6381
可以看到，KV分别分发到了不同的Redis实例，这种Shard的方式需要我们提前计算好数据量的大小，便于决定实例的个数。同时这种shard的可靠性不是很好，如果单个Redis实例挂掉了，那么这个实例便不可用了。
其实Shard使用起来很简单，接下来我们看看ShardedJedisPool的具体的实现：
首先在初始化ShardedJedisPool的时候我们需要创建一个JedisShardInfo实例，JedisShardInfo主要是对单个连接的相关配置：
public class JedisShardInfo extends ShardInfo{ private static final String REDISS = "rediss"; private int connectionTimeout; private int soTimeout; private String host; private int port; private String password = null; private String name = null; // Default Redis DB private int db = 0; private boolean ssl; private SSLSocketFactory sslSocketFactory; private SSLParameters sslParameters; private HostnameVerifier hostnameVerifier;
像连接超时时间、发送超时时间、Host和port等。这些都是之前我们实例化Jedis用到的。
同时还需要进行JedisPoolConfig的设置，可以猜到ShardedJedisPool也是基于JedisPool来实现的。
看看ShardedJedisPool的构造：
public ShardedJedisPool(final GenericObjectPoolConfig poolConfig, Listshards) { this(poolConfig, shards, Hashing.MURMUR_HASH); } public ShardedJedisPool(final GenericObjectPoolConfig poolConfig, List shards, Hashing algo) { this(poolConfig, shards, algo, null); } public ShardedJedisPool(final GenericObjectPoolConfig poolConfig, List shards, Hashing algo, Pattern keyTagPattern) { super(poolConfig, new ShardedJedisFactory(shards, algo, keyTagPattern)); } public Pool(final GenericObjectPoolConfig poolConfig, PooledObjectFactory factory) { initPool(poolConfig, factory); } public void initPool(final GenericObjectPoolConfig poolConfig, PooledObjectFactory factory) { if (this.internalPool != null) { try { closeInternalPool(); } catch (Exception e) { } } this.internalPool = new GenericObjectPool (factory, poolConfig); }
构造方法很长，但是很清晰，关键点在ShardedJedisFactory的构建，因为这是使用commons-pool的必要工厂类。同时我们可以看到，这里分分片策略使用的确实是Hash，而且还是冲突率很低的MURMUR_HASH。
那么我们直接看ShardedJedisFactory类就好了，因为commons-pool就是基于这个工厂类来管理相关的对象的，这里缓存的对象是ShardedJedis
我们先看一下ShardedJedisFactory：
public ShardedJedisFactory(Listshards, Hashing algo, Pattern keyTagPattern) { this.shards = shards; this.algo = algo; this.keyTagPattern = keyTagPattern; } @Override public PooledObject makeObject() throws Exception { ShardedJedis jedis = new ShardedJedis(shards, algo, keyTagPattern); return new DefaultPooledObject (jedis); } @Override public void destroyObject(PooledObject pooledShardedJedis) throws Exception { final ShardedJedis shardedJedis = pooledShardedJedis.getObject(); for (Jedis jedis : shardedJedis.getAllShards()) { try { try { jedis.quit(); } catch (Exception e) { } jedis.disconnect(); } catch (Exception e) { } } } @Override public boolean validateObject(PooledObject pooledShardedJedis) { try { ShardedJedis jedis = pooledShardedJedis.getObject(); for (Jedis shard : jedis.getAllShards()) { if (!shard.ping().equals("PONG")) { return false; } } return true; } catch (Exception ex) { return false; } }
其实这里makeObject是创建一个ShardedJedis，同时ShardedJedis也是连接池里保存的对象。
可以看到destroyObject和validateObject都是将ShardedJedis里的redis实例当做了一个整体去对待，一个失败，全部失败。
接下来看下ShardedJedis的实现，这个里面主要做了Hash的处理和各个Shard的Client的缓存。
public class ShardedJedis extends BinaryShardedJedis implements JedisCommands, Closeable { protected ShardedJedisPool dataSource = null; public ShardedJedis(List shards) { super(shards); } public ShardedJedis(List shards, Hashing algo) { super(shards, algo); } public ShardedJedis(List shards, Pattern keyTagPattern) { super(shards, keyTagPattern); } public ShardedJedis(List shards, Hashing algo, Pattern keyTagPattern) { super(shards, algo, keyTagPattern); }
这里的dataSource是对连接池的引用，用于在Close的时候资源返还。和JedisPool的思想差不多。
由于ShardedJedis是BinaryShardedJedis的子类，所以构造函数会一直向上调用，在Shard中：