三：Redis连接池、JedisPool详解、Redisi分布式

单机模式：

 package com.ljq.utils;

 import redis.clients.jedis.Jedis;
 import redis.clients.jedis.JedisPool;
 import redis.clients.jedis.JedisPoolConfig;

 /**
  * Redis操作接口
  *
  * @author NiceCui
  * @version 1.0 2017-6-14 上午08:54:14
  */
 public class RedisAPI {
     private static JedisPool pool = null;

     /**
      * 构建redis连接池
      *
      * @param ip
      * @param port
      * @return JedisPool
      */
     public static JedisPool getPool() {
         if (pool == null) {
             JedisPoolConfig config = new JedisPoolConfig();
             //控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；
             //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
             config.setMaxActive(500);
             //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例。
             config.setMaxIdle(5);
             //表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
             config.setMaxWait(1000 * 100);
             //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
             config.setTestOnBorrow(true);
             pool = new JedisPool(config, "192.168.2.191", 8888);
         }
         return pool;
     }

     /**
      * 返还到连接池
      *
      * @param pool
      * @param redis
      */
     public static void returnResource(JedisPool pool, Jedis redis) {
         if (redis != null) {
             pool.returnResource(redis);
         }
     }

     /**
      * 获取数据
      *
      * @param key
      * @return
      */
     public static String get(String key){
         String value = null;

         JedisPool pool = null;
         Jedis jedis = null;
         try {
             pool = getPool();
             jedis = pool.getResource();
             value = jedis.get(key);
         } catch (Exception e) {
             //释放redis对象
             pool.returnBrokenResource(jedis);
             e.printStackTrace();
         } finally {
             //返还到连接池
             returnResource(pool, jedis);
         }

         return value;
     }
 }

分布式模式

ShardedJe、dis是基于一致性哈希算法实现的分布式Redis集群客户端

 package com.jd.redis.client;

 import java.util.ArrayList;
 import java.util.List;

 import redis.clients.jedis.JedisPoolConfig;
 import redis.clients.jedis.JedisShardInfo;
 import redis.clients.jedis.ShardedJedis;
 import redis.clients.jedis.ShardedJedisPool;
 import redis.clients.util.Hashing;
 import redis.clients.util.Sharded;

 publicclass RedisShardPoolTest {

 static ShardedJedisPoolpool;

 static{

 JedisPoolConfig config =new JedisPoolConfig();//Jedis池配置

 config.setMaxActive(500);//最大活动的对象个数

 config.setMaxIdle(1000 * 60);//对象最大空闲时间

 config.setMaxWait(1000 * 10);//获取对象时最大等待时间

 config.setTestOnBorrow(true);

 String hostA = "10.10.224.44";

 int portA = 6379;

 String hostB = "10.10.224.48";

 int portB = 6379;

 List<JedisShardInfo> jdsInfoList =new ArrayList<JedisShardInfo>(2);

 JedisShardInfo infoA = new JedisShardInfo(hostA, portA);

 infoA.setPassword("redis.360buy");

 JedisShardInfo infoB = new JedisShardInfo(hostB, portB);

 infoB.setPassword("redis.360buy");

 jdsInfoList.add(infoA);

 jdsInfoList.add(infoB);

 pool =new ShardedJedisPool(config, jdsInfoList, Hashing.MURMUR_HASH,
 Sharded.DEFAULT_KEY_TAG_PATTERN);
     //传入连接池配置、分布式redis服务器主机信息、分片规则（存储到哪台redis服务器）
 }

 /**

  * @param args

  */

 publicstaticvoid main(String[] args) {

 for(int i=0; i<100; i++){
            String key =generateKey();
            //key += "{aaa}";
            ShardedJedis jds =null;
            try {
                jds =pool.getResource();
                System.out.println(key+":"+jds.getShard(key).getClient().getHost());
                System.out.println(jds.set(key,"1111111111111111111111111111111"));
            }catch (Exception e) {
                e.printStackTrace();
            }
            finally{
                pool.returnResourceObject(jds);
            }

 }

 }

 privatestaticintindex = 1;

 publicstatic String generateKey(){

 return String.valueOf(Thread.currentThread().getId())+"_"+(index++);

 }
 }