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