征服 Redis + Jedis

痛定思痛。 2022-08-04 08:39 107阅读 0赞

# 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]

[**征服 Redis + Jedis**][Redis _ Jedis]

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

[**征服 Redis + Jedis + Spring （二）—— 哈希表操作（HMGET HMSET）**][Redis _ Jedis _ Spring _ _HMGET HMSET]

[**征服 Redis + Jedis + Spring （三）—— 列表操作**][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]

[**征服 Redis + Jedis**][Redis _ Jedis]

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

[**征服 Redis + Jedis + Spring （二）—— 哈希表操作（HMGET HMSET）**][Redis _ Jedis _ Spring _ _HMGET HMSET]

[**征服 Redis + Jedis + Spring （三）—— 列表操作**][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

\*/

publicclass 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][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][http_files.cnblogs.com_liuling_commons-pool-1.5.4.jar.zip]

1package com.test;

3import java.util.HashMap;

4import java.util.Iterator;

5import java.util.List;

6import java.util.Map;

8import org.junit.Before;

9import org.junit.Test;

11import redis.clients.jedis.Jedis;

13publicclass TestRedis \{

14     private Jedis jedis;

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     \}

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

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

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

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"));

43     \}

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

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

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     \}

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

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     \}

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连接池：

1package com.test;

3import redis.clients.jedis.Jedis;

4import redis.clients.jedis.JedisPool;

5import redis.clients.jedis.JedisPoolConfig;

7publicfinalclass RedisUtil \{

9     //Redis服务器IP

10     privatestatic String ADDR = "192.168.0.100";

12     //Redis的端口号

13     privatestaticint PORT = 6379;

15     //访问密码

16     privatestatic String AUTH = "admin";

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

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

20     privatestaticint MAX\_ACTIVE = 1024;

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

23     privatestaticint MAX\_IDLE = 200;

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

26     privatestaticint MAX\_WAIT = 10000;

28     privatestaticint TIMEOUT = 10000;

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

31     privatestaticboolean TEST\_ON\_BORROW =true;

33     privatestatic JedisPool jedisPool = null;

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     \}

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

62             \}

63         \} catch (Exception e) \{

64             e.printStackTrace();

65             returnnull;

66         \}

67     \}

69     /\*\*

70      \* 释放jedis资源

71      \*@param jedis

72      \*/

73     publicstaticvoid returnResource(final Jedis jedis) \{

74         if (jedis !=null) \{

75             jedisPool.returnResource(jedis);

76         \}

77     \}

78 \}

[Redis]: http://snowolf.iteye.com/blog/1630697
[Redis _ Jedis]: http://snowolf.iteye.com/blog/1633196
[Redis _ Jedis _ Spring _ _GET SET DEL]: http://snowolf.iteye.com/blog/1666908
[Redis _ Jedis _ Spring _ _HMGET HMSET]: http://snowolf.iteye.com/blog/1667104
[Redis _ Jedis _ Spring _]: http://snowolf.iteye.com/blog/1824868/
[jedis.zip]: http://dl.iteye.com/topics/download/afa8ef29-0b7b-34e9-bd22-25d80c07af6e
[http_files.cnblogs.com_liuling_jedis-2.1.0.jar.zip]: http://files.cnblogs.com/liuling/jedis-2.1.0.jar.zip
[http_files.cnblogs.com_liuling_commons-pool-1.5.4.jar.zip]: http://files.cnblogs.com/liuling/commons-pool-1.5.4.jar.zip