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