第4章客户端-Java客户端Jedis

1.获取Jedis
maven配置加入项目中

<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>2.8.2</version>
</dependency>

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

import redis.clients.jedis.Jedis;public class JedisTest {public static void main(String[] args) {Jedis jedis=null;try {//1. 生成一个Jedis对象，这个对象负责和指定Redis实例进行通信jedis = new Jedis("59.110.35.177", 6379);jedis.auth("password");// 1.string// 输出结果：OKjedis.set("hello", "world");// 输出结果：worldjedis.get("hello");// 输出结果：1jedis.incr("counter");// 2.hashjedis.hset("myhash", "f1", "v1");jedis.hset("myhash", "f2", "v2");// 输出结果：{f1=v1, f2=v2}jedis.hgetAll("myhash");// 3.listjedis.rpush("mylist", "1");jedis.rpush("mylist", "2");jedis.rpush("mylist", "3");// 输出结果：[1, 2, 3]jedis.lrange("mylist", 0, -1);// 4.setjedis.sadd("myset", "a");jedis.sadd("myset", "b");jedis.sadd("myset", "a");// 输出结果：[b, a]jedis.smembers("myset");// 5.zsetjedis.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);}catch (Exception e){e.printStackTrace();}finally {if (jedis != null) {jedis.close();}}}
}

参数除了可以是字符串，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, finalSchema<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);

总体代码为：

import redis.clients.jedis.Jedis;
import java.util.Date;
public class redisSerializerTest {public static void main(String[] args) {ProtostuffSerializer protostuffSerializer = new ProtostuffSerializer();Jedis jedis=null;try {//1. 生成一个Jedis对象，这个对象负责和指定Redis实例进行通信jedis = new Jedis("59.110.35.177", 6379);jedis.auth("1.tiantian");String key = "club:1";// 定义实体对象Club club = new Club(1, "AC", "米兰", new Date(), 1);// 序列化byte[] clubBtyes = protostuffSerializer.serialize(club);jedis.set(key.getBytes(), clubBtyes);// 反序列化[id=1, clubName=AC, clubInfo=米兰, createDate=Tue Sep 15 09:53:18 CST 2015, rank=1]byte[] resultBtyes = jedis.get(key.getBytes());Club resultClub = protostuffSerializer.deserialize(resultBtyes);}catch (Exception e){e.printStackTrace();}finally {if (jedis != null) {jedis.close();}}}
}

3.Jedis连接池使用
以上是Jedis的直连方式，所谓直连是指Jedis每次都会新建TCP连接，使用后再断开连接，对于频繁访问Redis的场景显然不是高效的使用方式，如下图所示
在这里插入图片描述
因此生产环境中一般使用连接池的方式对Jedis连接进行管理，如下图所示，所有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其他属性及其含义解释。
在这里插入图片描述
总体代码为：

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;public class jedisPoolTest {public static void main(String[] args) {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);// 初始化Jedis连接池JedisPool jedisPool = new JedisPool(poolConfig, "59.110.35.177", 6379,200,"1.tiantian");Jedis jedis = null;try {// 1. 从连接池获取jedis对象jedis = jedisPool.getResource();// 2. 执行操作String result = jedis.get("hello");System.out.println(result);} catch (Exception e) {e.printStackTrace();} finally {if (jedis != null) {// 如果使用JedisPool，close操作不是关闭连接，代表归还连接池jedis.close();}}}
}

4.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

总体代码为：

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import java.util.List;
import java.util.Set;
public class JedisPipelineTest {public static void main(String[] args) {Jedis jedis=null;try {jedis = new Jedis("59.110.35.177", 6379);jedis.auth("1.tiantian");Set<String> keys = jedis.keys("*");// 1)生成pipeline对象Pipeline pipeline = jedis.pipelined();// 2)pipeline执行命令，注意此时命令并未真正执行for (String key : keys) {pipeline.del(key);}// 3)执行命令pipeline.sync();pipeline.set("hello", "world");pipeline.incr("counter");List<Object> resultList = pipeline.syncAndReturnAll();for (Object object : resultList) {System.out.println(object);}} catch (Exception e){e.printStackTrace();}finally {if (jedis != null) {
// 如果使用JedisPool，close操作不是关闭连接，代表归还连接池jedis.close();}        }}
}

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涉及了字节数组，需要自己选择适合的序列化方法。
总体代码为：

import redis.clients.jedis.Jedis;
public class JedisLuaTest {public static void main(String[] args) {Jedis jedis=null;try {//1. 生成一个Jedis对象，这个对象负责和指定Redis实例进行通信jedis = new Jedis("59.110.35.177", 6379);jedis.auth("1.tiantian");String key = "hello";String script = "return redis.call('get',KEYS[1])";Object result = jedis.eval(script, 1, key);// 打印结果为worldSystem.out.println(result);String scriptSha = jedis.scriptLoad(script);System.out.println(scriptSha);Object result1 = jedis.evalsha(scriptSha, 1, key);// 打印结果为worldSystem.out.println(result1);}catch (Exception e){e.printStackTrace();}finally {if (jedis != null) {jedis.close();}}}
}