Redis入门学习

一、摘要

二、五种数据类型的基本命令操作

三、Redis连接池

四、普通同步方式

五、事务方式(Transactions)

六、管道(Pipelining)

七、管道中调用事务

八、分布式直连同步调用

九、分布式直连异步管道调用

十、分布式连接池同步调用

十一、分布式连接池异步调用

十二、需要注意的地方

一、摘要：

　　Redis是一个著名的key-value存储系统，而作为其官方推荐的java版客户端jedis也非常强大和稳定，支持事务、管道及有jedis自身实现的分布式。

二、五种数据类型的基本命令操作：

package sy.test;

import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.junit.Before;
import org.junit.Test;

import redis.clients.jedis.Jedis;
import sy.util.RedisUtil;

public class TestJedis {
private Jedis jedis;

@Before
public void setUp() throws Exception {
//连接redis服务器，192.168.0.100:6379
jedis = new Jedis("192.168.0.16", 6379);
//登陆权限认证
jedis.auth("123456");
}

/**
* redis存储字符串
*/
@Test
public void testString() {
jedis.set("name", "itme");
System.out.println(jedis.get("name"));

jedis.append("name", " is my lover");   //拼接
System.out.println(jedis.get("name"));

//删除某个键
jedis.del("name");
System.out.println(jedis.get("name"));

//添加多个键值对
jedis.mset("name","mset","age","25","qq","123456");
System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" + jedis.get("qq"));

//自增1操作
jedis.incr("age");
System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" + jedis.get("qq"));

//关闭jedis连接
jedis.disconnect();

}

/**
* 操作map
*/
@Test
public void testMap(){

//添加数据
Map<String, String> map = new HashMap<String,String>();
map.put("name", "xinxin");
map.put("age", "22");
map.put("qq", "123456");

jedis.hmset("user", map);

List<String> list = jedis.hmget("user", "name","age","qq");
System.out.println(list);

//删除数据
jedis.hdel("user", "name");
System.out.println(jedis.hmget("user", "age")); //因为删除了，所以返回的是null
System.out.println(jedis.hlen("user")); //返回key为user的键中存放的值的个数2
System.out.println(jedis.exists("user"));//是否存在key为user的记录 返回true
System.out.println(jedis.hkeys("user"));//返回map对象中的所有key
System.out.println(jedis.hvals("user"));//返回map对象中的所有value

Iterator<String> iter=jedis.hkeys("user").iterator();
while (iter.hasNext()){
String key = iter.next();
System.out.println(key+":"+jedis.hmget("user",key));
}

//关闭jedis连接
jedis.disconnect();
}

/**
* 操作List
* 底层是双向链表
*/
@Test
public void testList(){
//开始前，先移除所有的内容
jedis.del("java framework");
System.out.println(jedis.lrange("java framework",0,-1));
//先向key java framework中存放三条数据
jedis.lpush("java framework","spring");
jedis.lpush("java framework","struts");
jedis.lpush("java framework","hibernate");

//再取出所有数据jedis.lrange是按范围取出，
// 第一个是key，第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有
System.out.println(jedis.lrange("java framework",0,-1));

jedis.del("java framework");
jedis.rpush("java framework","spring");
jedis.rpush("java framework","struts");
jedis.rpush("java framework","hibernate");
System.out.println(jedis.lrange("java framework",0,-1));

//关闭jedis连接
jedis.disconnect();
}

/**
* jedis操作set
*/
@Test
public void testSet(){
//添加
jedis.sadd("user1","liuling");
jedis.sadd("user1","xinxin");
jedis.sadd("user1","ling");
jedis.sadd("user1","zhangxinxin");
jedis.sadd("user1","who");
//移除noname
jedis.srem("user1","who");
System.out.println(jedis.smembers("user1"));//获取所有加入的value
System.out.println(jedis.sismember("user1", "who"));//判断 who 是否是user集合的元素
System.out.println(jedis.srandmember("user1"));
System.out.println(jedis.scard("user1"));//返回集合的元素个数

//关闭jedis连接
jedis.disconnect();
}

@Test
public void testSortList(){
//jedis 排序
//注意，此处的rpush和lpush是List的操作。是一个双向链表（但从表现来看的）
jedis.del("a");//先清除数据，再加入数据进行测试
jedis.rpush("a", "1");
jedis.lpush("a","6");
jedis.lpush("a","3");
jedis.lpush("a","9");

System.out.println(jedis.lrange("a",0,-1));// [9, 3, 6, 1]
//输入排序后结果  不影响原来的顺序。
System.out.println(jedis.sort("a")); //[1, 3, 6, 9]
System.out.println(jedis.lrange("a",0,-1));

//关闭jedis
jedis.disconnect();
}

@Test
public void testRedisPool(){
RedisUtil.getJedis().set("newname", "中文测试");
System.out.println(RedisUtil.getJedis().get("newname"));
}

}

三、Redis连接池

package sy.util;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public final class RedisUtil {

//Redis服务器IP
private static String ADDR = "192.168.0.16";

//Redis的端口号
private static int PORT = 6379;

//访问密码
private static String AUTH = "123456";

//可用连接实例的最大数目，默认值为8；
//如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
private static int MAX_ACTIVE = 1024;

//控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
private static int MAX_IDLE = 200;

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

private static int TIMEOUT = 10000;

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

private static JedisPool jedisPool = null;

/**
* 初始化Redis连接池
*/
static {
try {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxIdle(MAX_ACTIVE);
config.setMaxIdle(MAX_IDLE);
config.setMaxWaitMillis(MAX_WAIT);
config.setTestOnBorrow(TEST_ON_BORROW);
jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
} catch (Exception e) {
e.printStackTrace();
}
}

/**
* 获取Jedis实例
* @return
*/
public synchronized static Jedis getJedis() {
try {
if (jedisPool != null) {
Jedis resource = jedisPool.getResource();
return resource;
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
}

/**
* 释放jedis资源
* @param jedis
*/
public static void returnResource(final Jedis jedis) {
if (jedis != null) {
jedisPool.returnResource(jedis);
}
}
}

四、普通同步方式

　　最简单和基础的调用方式：

/**
* jedis redis普通同步方式
*/
@Test
public void testNormal(){
Jedis jedis = RedisUtil.getJedis();
long start = System.currentTimeMillis();
for(int i=0;i<10000;i++){
jedis.set("n" + i, "n" + i);
}
long end = System.currentTimeMillis();
System.out.println("Simple set" + ((end-start)/1000.0) + " seconds");
}

五、事务方式(Transactions)

　　redis的事务很简单，他主要目的是保障，一个client发起的事务中的命令可以连续的执行，而中间不会插入其他client的命令。一般情况下 redis 在接受到一个 client 发来的命令后会立即处理并返回处理结果，但是当一个 client在一个连接中发 multi命令，这个连接会进入一个事务上下文，该连接后续的命令并不是立即执行，而是先放到一个队列中。当从此连接受到 exec 命令后，redis会顺序的执行队列中的所有命令。并将所有命令的运行结果打包到一起返回给 client.然后此连接就结束事务上下文。

@Test
public void testTransaction1(){
Jedis jedis = RedisUtil.getJedis();
long start = System.currentTimeMillis();

jedis.flushDB();
jedis.lpush("mylist", "hello");

//开启事务
Transaction tx = jedis.multi();
tx.set("testtran1", "testtran1");

tx.lset("mylist", 10, "world");
tx.set("testtran1-1", "testtran1-1");
//提交事务
List<Object> results = tx.exec();

long end = System.currentTimeMillis();
System.out.println(jedis.get("testtran1"));
System.out.println(jedis.lrange("mylist", 0, -1));
System.out.println(jedis.get("testtran1-1"));
System.out.println("Test Transaction1 " + ((end-start)/1000.0) + " seconds");
jedis.disconnect();
}

@Test
public void testTransaction2(){
Jedis jedis = RedisUtil.getJedis();
long start = System.currentTimeMillis();

jedis.flushDB();

jedis.set("testtran2", "testtran2");
jedis.set("testtran2-1", "testtran2-1");

//开启事务
Transaction tx = jedis.multi();
tx.set("testtran2", "testtran2_new");
tx.set("testtran2-1", "testtran2-1_new");

//回滚事务
tx.discard();

long end = System.currentTimeMillis();
System.out.println(jedis.get("testtran2"));
System.out.println(jedis.get("testtran2-1"));
System.out.println("Test Transaction2 " + ((end-start)/1000.0) + " seconds");
jedis.disconnect();
}

　　示例1说明，只要提交事务了，不管事务中的命令执行成功与否都会执行，即使有命令执行错误，也不会在java中抛出异常。其中tx.lset("mylist", 10, "world");的处理结果是错误的，但是其后边的命令继续执行。

　　我们调用jedis.watch(…)方法来监控key，如果调用后key值发生变化，则整个事务会执行失败。另外，事务中某个操作失败，并不会回滚其他操作。这一点需要注意。还有，我们可以使用discard()方法来取消事务。

六、管道(Pipelining)

　　有时，我们需要采用异步方式，一次发送多个指令，不同步等待其返回结果。批量发送请求，减少网络通信时间，最后将多条命令的执行结果打包返回给客户端。

/**
* 管道pipeline
*/
@Test
public void testPipeline(){
Jedis jedis = RedisUtil.getJedis();
jedis.flushDB();

//使用管道的方式
Pipeline pipeline = jedis.pipelined();
long start1 = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
pipeline.set("pipeline" + i, "pipeline" + i);
}
long end1 = System.currentTimeMillis();
System.out.println("使用Pipeline的方式 " + ((end1-start1)/1000.0) + " seconds");

//普通方式
long start2 = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
pipeline.set("normal" + i, "normal" + i);
}
long end2 = System.currentTimeMillis();
System.out.println("普通方式 " + ((end2-start2)/1000.0) + " seconds");
}

七、管道中调用事务

@Test
public void test4combPipelineTrans() {
jedis = new Jedis("192.168.0.16", 6379);long start = System.currentTimeMillis();
Pipeline pipeline = jedis.pipelined();
pipeline.multi();
for (int i = 0; i < 100000; i++) {
pipeline.set("" + i, "" + i);
}
pipeline.exec();
List<Object> results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
System.out.println("Pipelined transaction: " + ((end - start)/1000.0) + " seconds");
jedis.disconnect();
}

　　但是经测试（见本文后续部分），发现其效率和单独使用事务差不多，甚至还略微差点。

八、分布式直连同步调用

@Test
public void test5shardNormal() {
List<JedisShardInfo> shards = Arrays.asList(
new JedisShardInfo("localhost",6379),
new JedisShardInfo("localhost",6380));

ShardedJedis sharding = new ShardedJedis(shards);

long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
String result = sharding.set("sn" + i, "n" + i);
}
long end = System.currentTimeMillis();
System.out.println("Simple@Sharing SET: " + ((end - start)/1000.0) + " seconds");

sharding.disconnect();
}

　　这个是分布式直接连接，并且是同步调用，每步执行都返回执行结果。类似地，还有异步管道调用。

九、分布式直连异步管道调用

@Test
public void test6shardpipelined() {
List<JedisShardInfo> shards = Arrays.asList(
new JedisShardInfo("localhost",6379),
new JedisShardInfo("localhost",6380));

ShardedJedis sharding = new ShardedJedis(shards);

ShardedJedisPipeline pipeline = sharding.pipelined();
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
pipeline.set("sp" + i, "p" + i);
}
List<Object> results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
System.out.println("Pipelined@Sharing SET: " + ((end - start)/1000.0) + " seconds");

sharding.disconnect();
}

十、分布式连接池同步调用

　　如果，你的分布式调用代码是运行在线程中，那么上面两个直连调用方式就不合适了，因为直连方式是非线程安全的，这个时候，你就必须选择连接池调用。

@Test
public void test7shardSimplePool() {
List<JedisShardInfo> shards = Arrays.asList(
new JedisShardInfo("localhost",6379),
new JedisShardInfo("localhost",6380));

ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);

ShardedJedis one = pool.getResource();

long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
String result = one.set("spn" + i, "n" + i);
}
long end = System.currentTimeMillis();
pool.returnResource(one);
System.out.println("Simple@Pool SET: " + ((end - start)/1000.0) + " seconds");

pool.destroy();
}

十一、分布式连接池异步调用

@Test
public void test8shardPipelinedPool() {
List<JedisShardInfo> shards = Arrays.asList(
new JedisShardInfo("localhost",6379),
new JedisShardInfo("localhost",6380));

ShardedJedisPool pool = new ShardedJedisPool(new JedisPoolConfig(), shards);

ShardedJedis one = pool.getResource();

ShardedJedisPipeline pipeline = one.pipelined();

long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
pipeline.set("sppn" + i, "n" + i);
}
List<Object> results = pipeline.syncAndReturnAll();
long end = System.currentTimeMillis();
pool.returnResource(one);
System.out.println("Pipelined@Pool SET: " + ((end - start)/1000.0) + " seconds");
pool.destroy();
}

十二、需要注意的地方

　　1.事务和管道都是异步模式。在事务和管道中不能同步查询结果。比如下面两个调用，都是不允许的：

Transaction tx = jedis.multi();
for (int i = 0; i < 100000; i++) {
tx.set("t" + i, "t" + i);
}
System.out.println(tx.get("t1000").get());  //不允许

List<Object> results = tx.exec();

…
…

Pipeline pipeline = jedis.pipelined();
long start = System.currentTimeMillis();
for (int i = 0; i < 100000; i++) {
pipeline.set("p" + i, "p" + i);
}
System.out.println(pipeline.get("p1000").get()); //不允许

List<Object> results = pipeline.syncAndReturnAll();

　　2. 事务和管道都是异步的，个人感觉，在管道中再进行事务调用，没有必要，不如直接进行事务模式。

　　3. 分布式中，连接池的性能比直连的性能略好(见后续测试部分)。

　　4.分布式调用中不支持事务。因为事务是在服务器端实现，而在分布式中，每批次的调用对象都可能访问不同的机器，所以没法进行事务。

　参考文章：

　　　　　1.http://my.oschina.net/sphl520/blog/312514#OSC_h3_3

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

　　　　　 3.Redis实战《红丸出品》

　　　　　 4.http://www.2cto.com/kf/201504/395403.html