征服 Redis + Jedis

Jedis on Github

A blazingly small and sane redis java client

https://github.com/xetorthio/jedis

征服 Redis + Jedis

From: http://snowolf.iteye.com/blog/1633196

用Memcached，对于缓存对象大小有要求，单个对象不得大于1MB，且不支持复杂的数据类型，譬如SET

等。基于这些限制，有必要考虑Redis！

 

相关链接：

征服 Redis

征服 Redis + Jedis

征服 Redis + Jedis + Spring （一）—— 配置&常规操作（GET SET DEL）

征服 Redis + Jedis + Spring （二）—— 哈希表操作（HMGET HMSET）

征服 Redis + Jedis + Spring （三）—— 列表操作

 

言归正传，目前Redis大概有3中基于Java语言的Client：

• Jredis
• Jedis
• Redis4J

这里只说Jedis，因为它是官方提供的唯一Redis Client For Java Provider！

 

一、简单使用Jedis

需要Jedis就从Maven获取吧！

Maven Pom.xml

 

Xml代码  

<dependency>      <groupId>redis.clients</groupId>      <artifactId>jedis</artifactId>      <version>2.1.0</version>      <type>jar</type>      <scope>compile</scope>  </dependency>  

 

 

如果只是简单使用Jedis，以下这么几行代码足够：

 

Java代码  

Jedis jedis = new Jedis("10.11.20.140");  String keys = "name";    // 删数据  jedis.del(keys);  // 存数据  jedis.set(keys, "snowolf");  // 取数据  String value = jedis.get(keys);    System.out.println(value);  

 

二、池化使用Jedis

Jedis使用commons-pool完成池化实现。

先做个配置文件：

Properties代码  

#最大分配的对象数  redis.pool.maxActive=1024  #最大能够保持idel状态的对象数  redis.pool.maxIdle=200  #当池内没有返回对象时，最大等待时间  redis.pool.maxWait=1000  #当调用borrow Object方法时，是否进行有效性检查  redis.pool.testOnBorrow=true  #当调用return Object方法时，是否进行有效性检查  redis.pool.testOnReturn=true  #IP  redis.ip=10.11.20.140  #Port  redis.port=6379  

 

 在静态代码段中完成初始化：

 

Java代码  

private static JedisPool pool;  static {      ResourceBundle bundle = ResourceBundle.getBundle("redis");      if (bundle == null) {          throw new IllegalArgumentException(                  "[redis.properties] is not found!");      }      JedisPoolConfig config = new JedisPoolConfig();      config.setMaxActive(Integer.valueOf(bundle              .getString("redis.pool.maxActive")));      config.setMaxIdle(Integer.valueOf(bundle              .getString("redis.pool.maxIdle")));      config.setMaxWait(Long.valueOf(bundle.getString("redis.pool.maxWait")));      config.setTestOnBorrow(Boolean.valueOf(bundle              .getString("redis.pool.testOnBorrow")));      config.setTestOnReturn(Boolean.valueOf(bundle              .getString("redis.pool.testOnReturn")));      pool = new JedisPool(config, bundle.getString("redis.ip"),              Integer.valueOf(bundle.getString("redis.port")));  }  

 然后，修改前面那段jedis操作Redis

Java代码  

// 从池中获取一个Jedis对象  Jedis jedis = pool.getResource();  String keys = "name";    // 删数据  jedis.del(keys);  // 存数据  jedis.set(keys, "snowolf");  // 取数据  String value = jedis.get(keys);    System.out.println(value);    // 释放对象池  pool.returnResource(jedis);  

 改为从对象池中，获取Jedis实例：

 

Java代码  

// 从池中获取一个Jedis对象  Jedis jedis = pool.getResource();  

 切记，最后使用后，释放Jedis对象：

 

Java代码  

// 释放对象池  pool.returnResource(jedis);  

三、一致性哈希

 

Memcached完全基于分布式集群，而Redis是Master-Slave，如果想把Reids，做成集群模式，无外乎多做几套Master-Slave，每套Master-Slave完成各自的容灾处理，通过Client工具，完成一致性哈希。

PS:Memcached是在Server端完成Sharding，Redis只能依靠各个Client做Sharding。可能会在Redis 3.0系列支持Server端Sharding。

 

保留前面的JedisPoolConfig，新增两个Redis的IP（redis1.ip，redis2.ip），完成两个JedisShardInfo实例，并将其丢进List中：

 

Java代码  

JedisShardInfo jedisShardInfo1 = new JedisShardInfo(                  bundle.getString("redis1.ip"), Integer.valueOf(bundle                       .getString("redis.port")));  JedisShardInfo jedisShardInfo2 = new JedisShardInfo(                  bundle.getString("redis2.ip"), Integer.valueOf(bundle                       .getString("redis.port")));    List<JedisShardInfo> list = new LinkedList<JedisShardInfo>();  list.add(jedisShardInfo1);  list.add(jedisShardInfo2);  

 初始化ShardedJedisPool代替JedisPool：

 

Java代码  

ShardedJedisPool pool = new ShardedJedisPool(config, list);  

 改由ShardedJedis，获取Jedis对象：

 

Java代码  

// 从池中获取一个Jedis对象  ShardedJedis jedis = pool.getResource();  String keys = "name";  String value = "snowolf";  // 删数据  jedis.del(keys);  // 存数据  jedis.set(keys, value);  // 取数据  String v = jedis.get(keys);    System.out.println(v);    // 释放对象池  pool.returnResource(jedis);  

 

 

四、Spring封装参考

 Ok，完成上述代码足够完成简单任务，如果有必要，可以用Spring封装初始化：

 

Xml代码  

<context:property-placeholder location="classpath:redis.properties" />  <bean      id="jedisPoolConfig"      class="redis.clients.jedis.JedisPoolConfig"  >      <property          name="maxActive"          value="${redis.pool.maxActive}" />      <property          name="maxIdle"          value="${redis.pool.maxIdle}" />      <property          name="maxWait"          value="${redis.pool.maxWait}" />      <property          name="testOnBorrow"          value="${redis.pool.testOnBorrow}" />  </bean>  <bean      id="shardedJedisPool"      class="redis.clients.jedis.ShardedJedisPool"  >      <constructor-arg          index="0"          ref="jedisPoolConfig" />      <constructor-arg index="1">          <list>              <bean class="redis.clients.jedis.JedisShardInfo">                  <constructor-arg                      index="0"                      value="${redis1.ip}" />                  <constructor-arg                      index="1"                      value="${redis.port}"                      type="int" />              </bean>              <bean class="redis.clients.jedis.JedisShardInfo">                  <constructor-arg                      index="0"                      value="${redis2.ip}" />                  <constructor-arg                      index="1"                      value="${redis.port}"                      type="int" />              </bean>          </list>      </constructor-arg>  </bean>  

代码可以更简洁一些：

 

Java代码  

private ApplicationContext app;  private ShardedJedisPool pool;    @Before  public void before() throws Exception {      app = new ClassPathXmlApplicationContext("applicationContext.xml");      pool = (ShardedJedisPool) app.getBean("shardedJedisPool");  }    @Test  public void test() {        // 从池中获取一个Jedis对象      ShardedJedis jedis = pool.getResource();      String keys = "name";      String value = "snowolf";      // 删数据      jedis.del(keys);      // 存数据      jedis.set(keys, value);      // 取数据      String v = jedis.get(keys);        System.out.println(v);        // 释放对象池      pool.returnResource(jedis);        assertEquals(value, v);  }  

当然，Spring提供了对于Redis的专门支持：spring-data-redis，以后有机会再深入研究。

详见附件！

 

相关链接：

征服 Redis

征服 Redis + Jedis

征服 Redis + Jedis + Spring （一）—— 配置&常规操作（GET SET DEL）

征服 Redis + Jedis + Spring （二）—— 哈希表操作（HMGET HMSET）

征服 Redis + Jedis + Spring （三）—— 列表操作

• jedis.zip (24.4 KB)
• 下载次数: 883

//======================================================================

Jedis连接池的使用

From: http://www.cnblogs.com/linjiqin/archive/2013/06/14/3135248.html

所需jar：jedis-2.1.0.jar和commons-pool-1.5.4.jar

Jedis操作步骤如下：

1->获取Jedis实例需要从JedisPool中获取；

2->用完Jedis实例需要返还给JedisPool；

3->如果Jedis在使用过程中出错，则也需要还给JedisPool；

代码如下：

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 {

    privatestatic JedisPool pool =null;

    

    /**

     * 构建redis连接池

     * 

     * @param ip

     * @param port

     * @return JedisPool

     */

    publicstatic 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

     */

    publicstaticvoid returnResource(JedisPool pool, Jedis redis) {

        if (redis !=null) {

            pool.returnResource(redis);

        }

    }

    

    /**

     * 获取数据

     * 

     * @param key

     * @return

     */

    publicstatic 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;

    }

}

代码说明：

a、获取jedis实例时，实际上可能有两类错误。

一类是pool.getReource()，得不到可用的jedis实例；

另一类是jedis.set/get时出错也会抛出异常；

为了实现区分，所以根据instance是否为null来实现，如果为空就证明instance根本就没初始化，也就不用return给pool；如果instance不为null，则证明是需要返还给pool的；

b、在instance出错时，必须调用returnBrokenResource返还给pool，否则下次通过getResource得到的instance的缓冲区可能还存在数据，出现问题！

-------------------------------------------------

JedisPool的配置参数很大程度上依赖于实际应用需求、软硬件能力。以前没用过commons-pool，所以这次花了一整天专门看这些参数的含义。。。JedisPool的配置参数大部分是由JedisPoolConfig的对应项来赋值的。

maxActive：控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted。

maxIdle：控制一个pool最多有多少个状态为idle(空闲)的jedis实例；

whenExhaustedAction：表示当pool中的jedis实例都被allocated完时，pool要采取的操作；默认有三种。

WHEN_EXHAUSTED_FAIL --> 表示无jedis实例时，直接抛出NoSuchElementException；

WHEN_EXHAUSTED_BLOCK --> 则表示阻塞住，或者达到maxWait时抛出JedisConnectionException；

WHEN_EXHAUSTED_GROW --> 则表示新建一个jedis实例，也就说设置的maxActive无用；

maxWait：表示当borrow一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；

testOnBorrow：在borrow一个jedis实例时，是否提前进行alidate操作；如果为true，则得到的jedis实例均是可用的；

testOnReturn：在return给pool时，是否提前进行validate操作；

testWhileIdle：如果为true，表示有一个idle object evitor线程对idle object进行扫描，如果validate失败，此object会被从pool中drop掉；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义；

timeBetweenEvictionRunsMillis：表示idle object evitor两次扫描之间要sleep的毫秒数；

numTestsPerEvictionRun：表示idle object evitor每次扫描的最多的对象数；

minEvictableIdleTimeMillis：表示一个对象至少停留在idle状态的最短时间，然后才能被idle object evitor扫描并驱逐；这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义；

softMinEvictableIdleTimeMillis：在minEvictableIdleTimeMillis基础上，加入了至少minIdle个对象已经在pool里面了。如果为-1，evicted不会根据idle time驱逐任何对象。如果minEvictableIdleTimeMillis>0，则此项设置无意义，且只有在timeBetweenEvictionRunsMillis大于0时才有意义；

lifo：borrowObject返回对象时，是采用DEFAULT_LIFO（last in first out，即类似cache的最频繁使用队列），如果为False，则表示FIFO队列；

其中JedisPoolConfig对一些参数的默认设置如下：

testWhileIdle=true

minEvictableIdleTimeMills=60000

timeBetweenEvictionRunsMillis=30000

numTestsPerEvictionRun=-1

//======================================================================

Java中使用Jedis操作Redis

From: http://www.cnblogs.com/liuling/p/2014-4-19-04.html

使用Java操作Redis需要jedis-2.1.0.jar，下载地址：http://files.cnblogs.com/liuling/jedis-2.1.0.jar.zip

如果需要使用Redis连接池的话，还需commons-pool-1.5.4.jar，下载地址:http://files.cnblogs.com/liuling/commons-pool-1.5.4.jar.zip

  1 package com.test;

  2 

  3 import java.util.HashMap;

  4 import java.util.Iterator;

  5 import java.util.List;

  6 import java.util.Map;

  7 

  8 import org.junit.Before;

  9 import org.junit.Test;

 10 

 11 import redis.clients.jedis.Jedis;

 12 

 13 publicclass TestRedis {

 14     private Jedis jedis; 

 15     

 16     @Before

 17     publicvoid setup() {

 18         //连接redis服务器，192.168.0.100:6379

 19         jedis = new Jedis("192.168.0.100", 6379);

 20         //权限认证

 21         jedis.auth("admin");  

 22     }

 23     

 24     /**

 25      * redis存储字符串

 26      */

 27     @Test

 28     publicvoid testString() {

 29         //-----添加数据----------  

 30         jedis.set("name","xinxin");//向key-->name中放入了value-->xinxin  

 31         System.out.println(jedis.get("name"));//执行结果：xinxin  

 32         

 33         jedis.append("name", " is my lover");//拼接

 34         System.out.println(jedis.get("name")); 

 35         

 36         jedis.del("name"); //删除某个键

 37         System.out.println(jedis.get("name"));

 38         //设置多个键值对

 39         jedis.mset("name","liuling","age","23","qq","476777389");

 40         jedis.incr("age");//进行加1操作

 41         System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" + jedis.get("qq"));

 42         

 43     }

 44     

 45     /**

 46      * redis操作Map

 47      */

 48     @Test

 49     publicvoid testMap() {

 50         //-----添加数据----------  

 51         Map<String, String> map =new HashMap<String, String>();

 52         map.put("name", "xinxin");

 53         map.put("age", "22");

 54         map.put("qq", "123456");

 55         jedis.hmset("user",map);

 56         //取出user中的name，执行结果:[minxr]-->注意结果是一个泛型的List  

 57         //第一个参数是存入redis中map对象的key，后面跟的是放入map中的对象的key，后面的key可以跟多个，是可变参数  

 58         List<String> rsmap = jedis.hmget("user", "name", "age", "qq");

 59         System.out.println(rsmap);  

 60   

 61         //删除map中的某个键值  

 62         jedis.hdel("user","age");

 63         System.out.println(jedis.hmget("user", "age"));//因为删除了，所以返回的是null  

 64         System.out.println(jedis.hlen("user"));//返回key为user的键中存放的值的个数2 

 65         System.out.println(jedis.exists("user"));//是否存在key为user的记录 返回true  

 66         System.out.println(jedis.hkeys("user"));//返回map对象中的所有key  

 67         System.out.println(jedis.hvals("user"));//返回map对象中的所有value 

 68   

 69         Iterator<String> iter=jedis.hkeys("user").iterator();  

 70         while (iter.hasNext()){  

 71             String key = iter.next();  

 72             System.out.println(key+":"+jedis.hmget("user",key));  

 73         }  

 74     }

 75     

 76     /** 

 77      * jedis操作List 

 78      */  

 79     @Test  

 80     publicvoid testList(){  

 81         //开始前，先移除所有的内容  

 82         jedis.del("java framework");  

 83         System.out.println(jedis.lrange("java framework",0,-1));  

 84         //先向key java framework中存放三条数据  

 85         jedis.lpush("java framework","spring");  

 86         jedis.lpush("java framework","struts");  

 87         jedis.lpush("java framework","hibernate");  

 88         //再取出所有数据jedis.lrange是按范围取出，  

 89         // 第一个是key，第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有  

 90         System.out.println(jedis.lrange("java framework",0,-1));  

 91         

 92         jedis.del("java framework");

 93         jedis.rpush("java framework","spring");  

 94         jedis.rpush("java framework","struts");  

 95         jedis.rpush("java framework","hibernate"); 

 96         System.out.println(jedis.lrange("java framework",0,-1));

 97     }  

 98     

 99     /** 

100      * jedis操作Set 

101      */  

102     @Test  

103     publicvoid testSet(){  

104         //添加  

105         jedis.sadd("user","liuling");  

106         jedis.sadd("user","xinxin");  

107         jedis.sadd("user","ling");  

108         jedis.sadd("user","zhangxinxin");

109         jedis.sadd("user","who");  

110         //移除noname  

111         jedis.srem("user","who");  

112         System.out.println(jedis.smembers("user"));//获取所有加入的value  

113         System.out.println(jedis.sismember("user", "who"));//判断 who 是否是user集合的元素  

114         System.out.println(jedis.srandmember("user"));  

115         System.out.println(jedis.scard("user"));//返回集合的元素个数  

116     }  

117   

118     @Test  

119     publicvoid test()throws InterruptedException {  

120         //jedis 排序  

121         //注意，此处的rpush和lpush是List的操作。是一个双向链表（但从表现来看的）  

122         jedis.del("a");//先清除数据，再加入数据进行测试  

123         jedis.rpush("a", "1");  

124         jedis.lpush("a","6");  

125         jedis.lpush("a","3");  

126         jedis.lpush("a","9");  

127         System.out.println(jedis.lrange("a",0,-1));// [9, 3, 6, 1]  

128         System.out.println(jedis.sort("a"));//[1, 3, 6, 9]  //输入排序后结果  

129         System.out.println(jedis.lrange("a",0,-1));  

130     }  

131     

132     @Test

133     publicvoid testRedisPool() {

134         RedisUtil.getJedis().set("newname", "中文测试");

135         System.out.println(RedisUtil.getJedis().get("newname"));

136     }

137 }

 

Redis连接池：

 1 package com.test;

 2 

 3 import redis.clients.jedis.Jedis;

 4 import redis.clients.jedis.JedisPool;

 5 import redis.clients.jedis.JedisPoolConfig;

 6 

 7 publicfinalclass RedisUtil {

 8     

 9     //Redis服务器IP

10     privatestatic String ADDR = "192.168.0.100";

11     

12     //Redis的端口号

13     privatestaticint PORT = 6379;

14     

15     //访问密码

16     privatestatic String AUTH = "admin";

17     

18     //可用连接实例的最大数目，默认值为8；

19     //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。

20     privatestaticint MAX_ACTIVE = 1024;

21     

22     //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。

23     privatestaticint MAX_IDLE = 200;

24     

25     //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；

26     privatestaticint MAX_WAIT = 10000;

27     

28     privatestaticint TIMEOUT = 10000;

29     

30     //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；

31     privatestaticboolean TEST_ON_BORROW =true;

32     

33     privatestatic JedisPool jedisPool =null;

34     

35     /**

36      * 初始化Redis连接池

37      */

38     static {

39         try {

40             JedisPoolConfig config =new JedisPoolConfig();

41             config.setMaxActive(MAX_ACTIVE);

42             config.setMaxIdle(MAX_IDLE);

43             config.setMaxWait(MAX_WAIT);

44             config.setTestOnBorrow(TEST_ON_BORROW);

45             jedisPool =new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);

46         } catch (Exception e) {

47             e.printStackTrace();

48         }

49     }

50     

51     /**

52      * 获取Jedis实例

53      *@return

54      */

55     publicsynchronizedstatic Jedis getJedis() {

56         try {

57             if (jedisPool !=null) {

58                 Jedis resource = jedisPool.getResource();

59                 return resource;

60             } else {

61                 return null;

62             }

63         } catch (Exception e) {

64             e.printStackTrace();

65             returnnull;

66         }

67     }

68     

69     /**

70      * 释放jedis资源

71      *@param jedis

72      */

73     publicstaticvoid returnResource(final Jedis jedis) {

74         if (jedis !=null) {

75             jedisPool.returnResource(jedis);

76         }

77     }

78 }