Redis入门完整教程：Java客户端Jedis

Java有很多优秀的Redis客户端（详见：http://redis.io/clients#java），这
里介绍使用较为广泛的客户端Jedis，本节将按照以下几个方面对Jedis进行
介绍：
·获取Jedis
·Jedis的基本使用
·Jedis连接池使用
·Jedis中Pipeline使用
·Jedis的Lua脚本使用

4.2.1　获取Jedis
Jedis属于Java的第三方开发包，在Java中获取第三方开发包通常有两种
方式：
·直接下载目标版本的Jedis-${version}.jar包加入到项目中。
·使用集成构建工具，例如maven、gradle等将Jedis目标版本的配置加入
到项目中。
通常在实际项目中使用第二种方式，但如果只是想测试一下Jedis，第
一种方法也是可以的。在写本书时，Jedis最新发布的稳定版本2.8.2，以
Maven为例子，在项目中加入下面的依赖即可：
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.8.2</version>
</dependency>
对于第三方开发包，版本的选择也是至关重要的，因为Redis更新速度
比较快，如果客户端跟不上服务端的速度，有些特性和bug不能及时更新，
不利于日常开发。通常来讲选取第三方开发包有如下两个策略：
·选择比较稳定的版本，也就是尽可能选择稳定的里程碑版本，这些版
本已经经过多次alpha，beta的修复，基本算是稳定了。
·选择更新活跃的第三方开发包，例如Redis3.0有了Redis Cluster新特
性，但是如果使用的客户端一直不支持，并且维护的人也比较少，这种就谨
慎选择。
本节介绍的Jedis基本满足上述两个特点，下面将对Jedis的基本使用方
法进行介绍。

4.2.2　Jedis的基本使用方法
Jedis的使用方法非常简单，只要下面三行代码就可以实现get功能：
# 1.  生成一个 Jedis 对象，这个对象负责和指定 Redis 实例进行通信
Jedis jedis = new Jedis("127.0.0.1", 6379);
# 2. jedis 执行 set 操作
jedis.set("hello", "world");
# 3. jedis 执行 get 操作 , value="world"
String value = jedis.get("hello");
可以看到初始化Jedis需要两个参数：Redis实例的IP和端口，除了这两
个参数外，还有一个包含了四个参数的构造函数是比较常用的：
Jedis(final String host, final int port, final int connectionTimeout, final int
soTimeout)
参数说明：
·host：Redis实例的所在机器的IP。
·port：Redis实例的端口。
·connectionTimeout：客户端连接超时。
·soTimeout：客户端读写超时。
如果想看一下执行结果：
String setResult = jedis.set("hello", "world");
String getResult = jedis.get("hello");
System.out.println(setResult);
System.out.println(getResult);

输出结果为：
OK
world
可以看到jedis.set的返回结果是OK，和redis-cli的执行效果是一样的，
只不过结果类型变为了Java的数据类型。上面的这种写法只是为了演示使
用，在实际项目中比较推荐使用try catch finally的形式来进行代码的书写：
一方面可以在Jedis出现异常的时候（本身是网络操作），将异常进行捕获
或者抛出；另一个方面无论执行成功或者失败，将Jedis连接关闭掉，在开
发中关闭不用的连接资源是一种好的习惯，代码类似如下：
Jedis jedis = null;
try {
jedis = new Jedis("127.0.0.1", 6379);
jedis.get("hello");
} catch (Exception e) {
logger.error(e.getMessage(),e);
} finally {
if (jedis != null) {
jedis.close();
}
}
下面用一个例子说明Jedis对于Redis五种数据结构的操作，为了节省篇
幅，所有返回结果放在注释中。
// 1.string
//  输出结果： OK
jedis.set("hello", "world");
//  输出结果： world
jedis.get("hello");
//  输出结果： 1
jedis.incr("counter");
// 2.hash
jedis.hset("myhash", "f1", "v1");
jedis.hset("myhash", "f2", "v2");
//  输出结果： {f1=v1, f2=v2}
jedis.hgetAll("myhash");
// 3.list
jedis.rpush("mylist", "1");
jedis.rpush("mylist", "2");
jedis.rpush("mylist", "3");
//  输出结果： [1, 2, 3]
jedis.lrange("mylist", 0, -1);
// 4.set
jedis.sadd("myset", "a");
jedis.sadd("myset", "b");
jedis.sadd("myset", "a");
//  输出结果： [b, a]
jedis.smembers("myset");
// 5.zset
jedis.zadd("myzset", 99, "tom");
jedis.zadd("myzset", 66, "peter");
jedis.zadd("myzset", 33, "james");
//  输出结果： [[["james"],33.0], [["peter"],66.0], [["tom"],99.0]]
jedis.zrangeWithScores("myzset", 0, -1);
参数除了可以是字符串，Jedis还提供了字节数组的参数，例如：
public String set(final String key, String value)
public String set(final byte[] key, final byte[] value)
public byte[] get(final byte[] key)
public String get(final String key)
有了这些API的支持，就可以将Java对象序列化为二进制，当应用需要
获取Java对象时，使用get（final byte[]key）函数将字节数组取出，然后反序
列化为Java对象即可。和很多NoSQL数据库（例如Memcache、Ehcache）的
客户端不同，Jedis本身没有提供序列化的工具，也就是说开发者需要自己
引入序列化的工具。序列化的工具有很多，例如XML、Json、谷歌的
Protobuf、Facebook的Thrift等等，对于序列化工具的选择开发者可以根据自
身需求决定，下面以protostuff（Protobuf的Java客户端）为例子进行说明。
1）protostuff的Maven依赖：
<protostuff.version>1.0.11</protostuff.version>
<dependency>
<groupId>com.dyuproject.protostuff</groupId>
<artifactId>protostuff-runtime</artifactId>
<version>${protostuff.version}</version>
</dependency>
<dependency>
<groupId>com.dyuproject.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
<version>${protostuff.version}</version>
</dependency>

2）定义实体类：
//  俱乐部
public class Club implements Serializable {
private int id; // id
private String name; //  名称
private String info; //  描述
private Date createDate; //  创建日期
private int rank; //  排名
//  相应的 getter setter 不占用篇幅
}
3）序列化工具类ProtostuffSerializer提供了序列化和反序列化方法：
 

package com.sohu.tv.serializer;
import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtostuffIOUtil;
import com.dyuproject.protostuff.Schema;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
import java.util.concurrent.ConcurrentHashMap;
// 序列化工具
public class ProtostuffSerializer {
private Schema<Club> schema = RuntimeSchema.createFrom(Club.class);
public byte[] serialize(final Club club) {
final LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_
BUFFER_SIZE);
try {
return serializeInternal(club, schema, buffer);
} catch (final Exception e) {
throw new IllegalStateException(e.getMessage(), e);
} finally {
buffer.clear();
}
}
public Club deserialize(final byte[] bytes) {
try {
Club club = deserializeInternal(bytes, schema.newMessage(), schema);
if (club != null ) {
return club;
}
} catch (final Exception e) {
throw new IllegalStateException(e.getMessage(), e);
}
return null;
}
private <T> byte[] serializeInternal(final T source, final Schema<T>
schema, final LinkedBuffer buffer) {
return ProtostuffIOUtil.toByteArray(source, schema, buffer);
}
private <T> T deserializeInternal(final byte[] bytes, final T result, final
Schema<T> schema) {
ProtostuffIOUtil.mergeFrom(bytes, result, schema);
return result;
}
}

4）测试。
生成序列化工具类：
ProtostuffSerializer protostuffSerializer = new ProtostuffSerializer();
生成Jedis对象：
Jedis jedis = new Jedis("127.0.0.1", 6379);
序列化：
String key = "club:1";
//  定义实体对象
Club club = new Club(1, "AC", " 米兰 ", new Date(), 1);
//  序列化
byte[] clubBtyes = protostuffSerializer.serialize(club);
jedis.set(key.getBytes(), clubBtyes);
反序列化：
byte[] resultBtyes = jedis.get(key.getBytes());
//  反序列化 [id=1, clubName=AC, clubInfo= 米兰 , createDate=Tue Sep 15 09:53:18 CST
// 2015, rank=1]
Club resultClub = protostuffSerializer.deserialize(resultBtyes);

4.2.3　Jedis连接池的使用方法
4.2.2节介绍的是Jedis的直连方式，所谓直连是指Jedis每次都会新建TCP
连接，使用后再断开连接，对于频繁访问Redis的场景显然不是高效的使用
方式，如图4-3所示。

 

因此生产环境中一般使用连接池的方式对Jedis连接进行管理，如图4-4
所示，所有Jedis对象预先放在池子中（JedisPool），每次要连接Redis，只
需要在池子中借，用完了在归还给池子。

 

客户端连接Redis使用的是TCP协议，直连的方式每次需要建立TCP连
接，而连接池的方式是可以预先初始化好Jedis连接，所以每次只需要从
Jedis连接池借用即可，而借用和归还操作是在本地进行的，只有少量的并
发同步开销，远远小于新建TCP连接的开销。另外直连的方式无法限制Jedis
对象的个数，在极端情况下可能会造成连接泄露，而连接池的形式可以有效
的保护和控制资源的使用。但是直连的方式也并不是一无是处，表4-1给出
两种方式各自的优劣势。

 

Jedis提供了JedisPool这个类作为对Jedis的连接池，同时使用了Apache的
通用对象池工具common-pool作为资源的管理工具，下面是使用JedisPool操
作Redis的代码示例：
1）Jedis连接池（通常JedisPool是单例的）：
// common-pool 连接池配置，这里使用默认配置，后面小节会介绍具体配置说明
GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
//  初始化 Jedis 连接池
JedisPool jedisPool = new JedisPool(poolConfig, "127.0.0.1", 6379);
2）获取Jedis对象不再是直接生成一个Jedis对象进行直连，而是从连接
池直接获取，代码如下：
Jedis jedis = null;
try {
// 1.  从连接池获取 jedis 对象
jedis = jedisPool.getResource();
// 2.  执行操作
jedis.get("hello");
} catch (Exception e) {
logger.error(e.getMessage(),e);
} finally {
if (jedis != null) {
//  如果使用 JedisPool ， close 操作不是关闭连接，代表归还连接池
jedis.close();
}
}
这里可以看到在finally中依然是jedis.close（）操作，为什么会把连接关
闭呢，这不和连接池的原则违背了吗？但实际上Jedis的close（）实现方式
如下：
public void close() {
//  使用 Jedis 连接池
if (dataSource != null) {
if (client.isBroken()) {
this.dataSource.returnBrokenResource(this);
} else {
this.dataSource.returnResource(this);
}
//  直连
} else {
client.close();
}
} 

参数说明：
·dataSource！=null代表使用的是连接池，所以jedis.close（）代表归还
连接给连接池，而且Jedis会判断当前连接是否已经断开。
·dataSource=null代表直连，jedis.close（）代表关闭连接。
前面GenericObjectPoolConfig使用的是默认配置，实际它提供有很多参
数，例如池子中最大连接数、最大空闲连接数、最小空闲连接数、连接活性
检测，等等，例如下面代码：
GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
//  设置最大连接数为默认值的 5 倍
poolConfig.setMaxTotal(GenericObjectPoolConfig.DEFAULT_MAX_TOTAL * 5);
//  设置最大空闲连接数为默认值的 3 倍
poolConfig.setMaxIdle(GenericObjectPoolConfig.DEFAULT_MAX_IDLE * 3);
//  设置最小空闲连接数为默认值的 2 倍
poolConfig.setMinIdle(GenericObjectPoolConfig.DEFAULT_MIN_IDLE * 2);
//  设置开启 jmx 功能
poolConfig.setJmxEnabled(true);
//  设置连接池没有连接后客户端的最大等待时间 ( 单位为毫秒 )
poolConfig.setMaxWaitMillis(3000);
上面几个是GenericObjectPoolConfig几个比较常用的属性，表4-2给出了
Generic-ObjectPoolConfig其他属性及其含义解释。

表4-2　GenericObjectPoolConfig的重要属性

 

4.2.4　Redis中Pipeline的使用方法
3.3节介绍了Pipeline的基本原理，Jedis支持Pipeline特性，我们知道
Redis提供了mget、mset方法，但是并没有提供mdel方法，如果想实现这个功
能，可以借助Pipeline来模拟批量删除，虽然不会像mget和mset那样是一个原
子命令，但是在绝大数场景下可以使用。下面代码是mdel删除的实现过程。
注意
这里为了节省篇幅，没有写try catch finally，没有关闭jedis。
public void mdel(List<String> keys) {
Jedis jedis = new Jedis("127.0.0.1");
// 1) 生成 pipeline 对象
Pipeline pipeline = jedis.pipelined();
// 2)pipeline 执行命令，注意此时命令并未真正执行
for (String key : keys) {
pipeline.del(key);
}
// 3) 执行命令
pipeline.sync();
}
说明如下：
·利用jedis对象生成一个pipeline对象，直接可以调用
jedis.pipelined（）。
·将del命令封装到pipeline中，可以调用pipeline.del（String key），这个
方法和jedis.del（String key）的写法是完全一致的，只不过此时不会真正的
执行命令。
·使用pipeline.sync（）完成此次pipeline对象的调用。
267
除了pipeline.sync（），还可以使用pipeline.syncAndReturnAll（）将
pipeline的命令进行返回，例如下面代码将set和incr做了一次pipeline操作，
并顺序打印了两个命令的结果：
Jedis jedis = new Jedis("127.0.0.1");
Pipeline pipeline = jedis.pipelined();
pipeline.set("hello", "world");
pipeline.incr("counter");
List<Object> resultList = pipeline.syncAndReturnAll();
for (Object object : resultList) {
System.out.println(object);
}
输出结果为：
OK
1

4.2.5　Jedis的Lua脚本
Jedis中执行Lua脚本和redis-cli十分类似，Jedis提供了三个重要的函数实
现Lua脚本的执行：
Object eval(String script, int keyCount, String... params)
Object evalsha(String sha1, int keyCount, String... params)
String scriptLoad(String script)
eval函数有三个参数，分别是：
·script：Lua脚本内容。
·keyCount：键的个数。
·params：相关参数KEYS和ARGV。
以一个最简单的Lua脚本为例子进行说明：
return redis.call('get',KEYS[1])
在redis-cli中执行上面的Lua脚本，方法如下：
127.0.0.1:6379> eval "return redis.call('get',KEYS[1])" 1 hello
"world"
在Jedis中执行，方法如下：
String key = "hello";
String script = "return redis.call('get',KEYS[1])";
Object result = jedis.eval(script, 1, key);
//  打印结果为 world
System.out.println(result)

scriptLoad和evalsha函数要一起使用，首先使用scriptLoad将脚本加载到
Redis中，代码如下：
String scriptSha = jedis.scriptLoad(script);
evalsha函数用来执行脚本的SHA1校验和，它需要三个参数：
·scriptSha：脚本的SHA1。
·keyCount：键的个数。
·params：相关参数KEYS和ARGV。
执行效果如下：
Stirng key = "hello";
Object result = jedis.evalsha(scriptSha, 1, key);
//  打印结果为 world
System.out.println(result);
总体来说，Jedis的使用还是比较简单的，重点注意以下几点即可：
1）Jedis操作放在try catch finally里更加合理。
2）区分直连和连接池两种实现方式优缺点。
3）jedis.close（）方法的两种实现方式。
4）Jedis依赖了common-pool，有关common-pool的参数需要根据不同的
使用场景，各不相同，需要具体问题具体分析。
5）如果key和value涉及了字节数组，需要自己选择适合的序列化方法。

4.3　Python客户端redis-py
因为本书主要使用Java语言作为编程语言，所以对Python的客户端redis-
py不会太详细介绍，主要介绍以下几个方面：
·获取redis-py。
·redis-py的基本使用方法。
·redis-py的Pipeline的使用。
·redis-py的Lua脚本使用。

4.3.1　获取redis-py
Redis官网提供了很多Python语言的客户端
（http://redis.io/clients#python），但最被广泛认可的客户端是redis-py。
redis-py需要Python2.7以上版本，有关Python的安装本书不会介绍，主要介绍
一下如何获取安装redis-py，方法有三种：
第一，使用pip进行安装：
pip install redis
第二，使用easy_install进行安装：
easy_install redis
第三，使用源码安装：以2.10.5版本为例子进行说明，只需要如下四
步：
wget https:// github.com/andymccurdy/redis-py/archive/2.10.5.zip
unzip redis-2.10.5.zip
cd redis-2.10.5
# 安装 redis-py
python setup.py install

4.3.2　redis-py的基本使用方法
redis-py的使用方法也比较简单，下面将逐步骤介绍。
1）导入依赖库：
import redis
2）生成客户端连接：需要Redis的实例IP和端口两个参数：
client = redis.StrictRedis(host='127.0.0.1', port=6379)
3）执行命令：redis-py的API保留了Redis API的原始风格，所以使用起
来不会有不习惯的感觉：
# True
client.set(key, "python-redis")
# world
client.get(key)
整个实例代码如下：
import redis
client = redis.StrictRedis(host='127.0.0.1', port=6379)
key = "hello"
setResult = client.set(key, "python-redis")
print setResult
value = client.get(key)
print "key:" + key + ", value:" + value
输出结果为：
True
key:hello, value:python-redis

下面代码给出redis-py操作Redis五种数据结构的示例，输出结果写在注
释中：

#1.string
# 输出结果： True
client.set("hello","world")
# 输出结果： world
client.get("hello")
# 输出结果： 1
client.incr("counter")
#2.hash
client.hset("myhash","f1","v1")
client.hset("myhash","f2","v2")
# 输出结果： {'f1': 'v1', 'f2': 'v2'}
client.hgetall("myhash")
#3.list
client.rpush("mylist","1")
client.rpush("mylist","2")
client.rpush("mylist","3")
# 输出结果： ['1', '2', '3']
client.lrange("mylist", 0, -1)
#4.set
client.sadd("myset","a")
client.sadd("myset","b")
client.sadd("myset","a")
# 输出结果： set(['a', 'b'])
client.smembers("myset")
#5.zset
client.zadd("myzset","99","tom")
client.zadd("myzset","66","peter")
client.zadd("myzset","33","james")
# 输出结果： [('james', 33.0), ('peter', 66.0), ('tom', 99.0)]
client.zrange("myzset", 0, -1, withscores=True)

4.3.3　redis-py中Pipeline的使用方法
redis-py支持Redis的Pipeline功能，下面用一个简单的示例进行说明。
1）引入依赖，生成客户端连接：
import redis
client = redis.StrictRedis(host='127.0.0.1', port=6379)
2）生成Pipeline：注意client.pipeline包含了一个参数，如果
transaction=False代表不使用事务：
pipeline = client.pipeline(transaction=False)
3）将命令封装到Pipeline中，此时命令并没有真正执行：
pipeline.set("hello","world")
pipeline.incr("counter")
4）执行Pipeline：
#[True, 3]
result = pipeline.execute()
和4.2.4小节一样，将用redis-py的Pipeline实现mdel功能：
import redis
def mdel( keys ):
client = redis.StrictRedis(host='127.0.0.1', port=6379)
pipeline = client.pipeline(transaction=False)
for key in keys:
print pipeline.delete(key)
return pipeline.execute();

4.3.4　redis-py中的Lua脚本使用方法
redis-py中执行Lua脚本和redis-cli十分类似，redis-py提供了三个重要的
函数实现Lua脚本的执行：
eval(String script, int keyCount, String... params)
script_load(String script)
evalsha(String sha1, int keyCount, String... params ：
eval函数有三个参数，分别是：
·script：Lua脚本内容。
·keyCount：键的个数。
·params：相关参数KEYS和ARGV。
以一个最简单的Lua脚本为例进行说明：
return redis.call('get',KEYS[1])
在redis-py中执行，方法如下：
import redis
client = redis.StrictRedis(host='127.0.0.1', port=6379)
script = "return redis.call('get',KEYS[1])"
# 输出结果为 world
print client.eval(script,1,"hello")
script_load和evalsha函数要一起使用，首先使用script_load将脚本加载到
Redis中，代码如下：

scriptSha = client.script_load(script)
evalsha函数用来执行脚本的哈希值，它需要三个参数：
·scriptSha：脚本的SHA1。
·keyCount：键的个数。
·params：相关参数KEYS和ARGV。
执行效果如下：
print jedis.evalsha(scriptSha, 1, "hello");
完整代码如下：
import redis
client = redis.StrictRedis(host='127.0.0.1', port=6379)
script = "return redis.call('get',KEYS[1])"
scriptSha = client.script_load(script)
print client.evalsha(scriptSha, 1, "hello");