jedis操做redis（一）

redis是一个经常使用的内存Nosql数据库，为何要用nosql，为何要用redis不用memcache这些不少博客以及讲得很清楚了。
下面介绍redis的5大基本数据类型的经常使用操做：
STRING(也能够是字符串、浮点数、整数) 对整个字符串或者字符串的其中的一部分执行操做，对整数或者浮点数进行自增或者自减
LIST(有序) 链表
SET(无序) 集合
HASH(无序) 散列表 相似于java中的HashMap
ZSET（有序集合） 字符串成员 和 浮点数分值的有序映射
下面是使用java版本的redis的客户端jedis对redis进行操做的相关的api的测试：
maven依赖以下：

<dependencies>
        <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

public class JedisApiTest {
    private Jedis jedis;
    @Rule
    public ExpectedException expectedEx = ExpectedException.none();

    @Before
    public void before() {
        jedis = new Jedis("127.0.0.1", 6379);
    }

    @Test
    public void test() {
        // redis 中 String数据类型的经常使用的操做相关测试
        // 首先先清空全部的键值对
        // jedis.flushAll();
        // 清除全部测试要用到的 key
        jedis.del("hello", "name", "age", "ages");
        // 设置 key - value
        Assert.assertEquals("OK", jedis.set("hello", "world"));
        // 获取 key - value
        Assert.assertEquals("world", jedis.get("hello"));
        // append value
        jedis.append("hello", "!");
        Assert.assertEquals("world!", jedis.get("hello"));
        // 删除value
        Assert.assertEquals(Long.valueOf(1l), jedis.del("hello"));
        // 删除不存在的能够
        Assert.assertEquals(Long.valueOf(0l), jedis.del("hello"));
        // 获取不存在的 key
        Assert.assertEquals(null, jedis.get("hello"));
        // 同时设置多个值
        Assert.assertEquals("OK", jedis.mset("name", "liuling", "age", "23", "qq", "476777XXX"));
        // incr增长一个值 返回结果是增长后的值
        Assert.assertEquals(Long.valueOf(24l), jedis.incr("age"));
        // 增长一个不存在的值 会set这个值而且值为一
        Assert.assertEquals(Long.valueOf(1l), jedis.incr("ages"));
        // 增长一个不是数值的 值
        expectedEx.expect(JedisDataException.class);// Exception.class其实也是能够的
        expectedEx.expectMessage("ERR value");// 错误信息中的一部分就能够了
        jedis.incr("name");
    }

    @Test
    public void test2() {
        // 关于 List 数据类型的操做
        // 先清除测试要用到 键值
        jedis.del("list");
        // 多个值推入返回的是推入的值的 数目 4
        Assert.assertEquals(Long.valueOf(4L), jedis.rpush("list", "item1", "item2", "item1", "item3"));
        // 展现list所有的值
        List<String> list = jedis.lrange("list", 0, -1);
        Assert.assertEquals(4, list.size());
        // 测试取超出范围的值 左右超出范围不管 如何写只要左边比右边小都是整个list列表
        Assert.assertEquals(4, jedis.lrange("list", -200, 1000).size());
        // 右边没有超过范围
        Assert.assertEquals(3, jedis.lrange("list", -200, 2).size());
        // 左边超过范围
        Assert.assertEquals(2, jedis.lrange("list", 2, 1000).size());
        // 左右没有超过范围只是 左边比右边大
        Assert.assertEquals(0, jedis.lrange("list", 2, 1).size());
        // 其余的都不用测试了 只要左边比右边大 返回的list都是空的 []
        // pop返回的都是pop的值
        Assert.assertEquals("item1", jedis.lpop("list"));
        for (int i = 0; i < 3; i++) {
            jedis.lpop("list");
        }
        // pop 一个空的list查看返回什么 返回null
        Assert.assertEquals(null, jedis.lpop("list"));
    }

    @Test
    public void test3() {
        // 清除 测试的 key
        jedis.del("set");
        // 返回值是进入成功的的值的数目 重复的值进入不成功
        Assert.assertEquals(Long.valueOf(2), jedis.sadd("set", "set1", "set2", "set1"));
        // 获取set里面全部的值
        Set<String> set = jedis.smembers("set");
        Assert.assertEquals(2, set.size());
        // 判断值是否在set中
        Assert.assertTrue(jedis.sismember("set", "set1"));
        Assert.assertFalse(jedis.sismember("set", "set3"));
        // 返回删除成功的 key的数量的值
        Assert.assertEquals(Long.valueOf(2l), jedis.srem("set", "set1", "set2"));
        // 返回删除成功的 key的值 由于 都不存在全部返回值是0l
        Assert.assertEquals(Long.valueOf(0l), jedis.srem("set", "set1", "set2"));
    }

    @Test
    public void test4() {
        // 哈希 测试
        // 首先先删除测试的key
        jedis.del("map");
        Assert.assertEquals(Long.valueOf(1l), jedis.hset("map", "k1", "v1"));// 设置一个值
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("k1", "v2");
        map.put("k2", "v2");
        Assert.assertEquals("OK", jedis.hmset("map", map));
        Assert.assertEquals("v2", jedis.hget("map", "k1"));// 会被覆盖
        Assert.assertEquals(null, jedis.hget("map", "k3"));// 获取不存在的key
        Assert.assertEquals("[v2, null]", jedis.hmget("map", "k1", "k3").toString());// 这个只想说明获取
                                                                                        // 获取hash中不存在的值会返回null
        Assert.assertEquals(2, jedis.hgetAll("map").size());
        // -----------------------------------------
        Assert.assertEquals(Long.valueOf(0l), jedis.hset("map", "k1", "v3"));
        Assert.assertEquals("v3", jedis.hget("map", "k1"));// 会被覆盖
        // 这两个表示 hset一个存在的值 会返回0可是值确实会被覆盖
        // -----------------------------------------
        Assert.assertEquals(Long.valueOf(1l), jedis.hdel("map", "k1"));
        // hdel也能够批量删除 返回删除成功的key的数量
        Assert.assertEquals(Long.valueOf(0l), jedis.hdel("map", "k1"));
    }

    @Test
    public void test5() {
        // 最后一种数据类型zSet有序集合
        // 首先清楚要测试的key
        jedis.del("zset");
        Assert.assertEquals(Long.valueOf(1l), jedis.zadd("zset", 1.1, "k1"));
        Assert.assertEquals(Long.valueOf(0l), jedis.zadd("zset", 4.4, "k1"));// 设置同样的值是0
        Assert.assertEquals(Long.valueOf(1l), jedis.zadd("zset", 3.3, "k3"));//
        // output:[k3,k1] 值被覆盖了
        System.out.println(jedis.zrangeByScore("zset", 0, 5));
        // [[[107,51],3.3],[[107, 49],4.4]]f
        System.out.println(jedis.zrangeByScoreWithScores("zset", 0, 10));
        Set<Tuple> setWithTuple = jedis.zrangeByScoreWithScores("zset", 0, 10);
        for (Tuple t : setWithTuple) {
            System.out.println(t.getElement() + "--" + t.getScore());
        }
        // output:
        // k3--3.3
        // k1--4.4
    }
        }