jedis连接池详解(Redis)

原子性（atomicity）：

一个事务是一个不可分割的最小工作单位，事务中包括的诸操作要么都做，要么都不做。

Redis所有单个命令的执行都是原子性的，这与它的单线程机制有关；

Redis命令的原子性使得我们不用考虑并发问题，可以方便的利用原子性自增操作INCR实现简单计数器功能;

单机模式：

package com.ljq.utils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**   
 * Redis操作接口
 *
 * @author 林计钦
 * @version 1.0 2013-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.returnResourceObject(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;
    }
}

分布式模式 

ShardedJedis是基于一致性哈希算法实现的分布式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++);
    
}
}