Java客户端Jedis

1.jedis基本使用方法

Jedis的使用方法非常简单，只要下面三行代码就可以实现get功能：

• 生成一个 Jedis 对象，这个对象负责和指定 Redis 实例进行通信
  Jedis jedis = new Jedis("127.0.0.1", 6379);
• jedis 执行 set 操作
  jedis.set("hello", "world");
• 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：客户端读写超时。

在实际项目中比较推荐使用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");
258
//  输出结果： [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);

2.Jedis连接池的使用方法

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

Jedis连接池使用方式

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

Jedis直连方式和连接池方式对比

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 {
264
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几个比较常用的属性，表给出了
Generic-ObjectPoolConfig其他属性及其含义解释。

GenericObjectPoolConfig的重要属性

3.jedis 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对象的调用。

除了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. 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涉及了字节数组，需要自己选择适合的序列化方法。