三：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++);
     
}
}