Redis-Redis基本类型及使用Java操作

1 Redis简介

    Redis（REmote Dictionary Server）是一个使用ANSI C编写的、开源的、支持网络的、基于内存的、可持久化的键值对存储系统。目前最流行的键值对存储系统。 经常被用作数据库、缓存以及消息队列等。

redis的优点：

• 基于内存的数据库，效率比磁盘型的快；
• Redis的工作模式为单线程，不需要线程间的同步操作。Redis采用单线程主要因为其瓶颈在内存和宽带上，而不是在CPU上；
• Redis中的key-value的value可是是字符串、链表、集合、散列表等；
• redis支持数据持久化，可以采用RDB、AOF、RDB&AOF三种方案；
• Redis支持主从结构，可以利用从实例进行数据备份；

2 Redis数据结构简介

1. STRING(字符串)；
2. LIST(列表)；
3. SET（集合）
4. HASH（散列）
5. ZSET(有序集合)

Java使用Redis

1、引入Maven依赖

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

2、测试

@Test
public void test01(){
    Jedis jedis = new Jedis("localhost");
 
    jedis.set("hello","world");
 
    System.out.println(jedis.get("hello"));
}

 

　　下面介绍五种基本类型的使用；

2.1.1 STRING(字符串)；

    Redis的字符串就是一个由字节组成的序列，字符串可以存储3种类型的值；

• 字符串
• 整数
• 浮点数   

Redis自增命令和自减命令

　　java使用Redis实现自增、自减命令：

@Test
public void test02(){
    Jedis jedis = new Jedis("localhost");


    jedis.set("num","10");
    // 11
    System.out.println(jedis.incr("num"));
    // 31
    System.out.println(jedis.incrBy("num",20));
    // 11
    System.out.println(jedis.decrBy("num",20));
}

　　java使用Redis处理子串：

@Test
public void test03() {
    Jedis jedis = new Jedis("localhost");
    // redis存储字符串
    jedis.set("str","hello");
    System.out.println(jedis.get("str"));
    // 字符串追加
    jedis.append("str","world");
    System.out.println(jedis.get("str"));
    // 取子串
    System.out.println(jedis.getrange("str",5,9));
    // 指定位置插入字符串(会把指定位置之后的字符串覆盖)
    jedis.setrange("str",5,",jiz");
    System.out.println(jedis.get("str"));
}

　　运行结果：

2.1.2 列表

 

    Redis允许用户从序列的两端推入或者弹出元素，获取列表元素以及执行各种常见的列表操作；可用来存储任务信息、最近浏览过的文章或常用联系人信息。

 

Redis对列表的基本操作

 

@Test
public void test04() {
    Jedis jedis = new Jedis("localhost");
    // 1 2
    jedis.rpush("list", "1", "2");
    // 1
    System.out.println(jedis.rpop("list")); //2
    // 3 1
    jedis.lpush("list","3");
    // 1
    System.out.println(jedis.lpop("list")); //3
    // 3 2 1
    jedis.lpush("list", "2", "3");
    // 获得位置为1的元素
    System.out.println(jedis.lindex("list",1)); // 3
}

 

 

　　 阻塞弹出命令和弹出并推入命令，最常见的用例就是消息队列（nessaging）和任务队列(task queue);

 

　　　　　　　　　　　　　　　　Redis阻塞式列表操作

 

@Test
public void test05() {
    Jedis jedis = new Jedis("localhost");
    // item1 item2 item3 item4
    jedis.rpush("list1", "item1", "item2", "item3", "item4");
    // 弹出最左端的元素 item2 item3 item4
    System.out.println(jedis.blpop(0, "list1"));
    // 弹出最右端的元素 item2 item3
    System.out.println(jedis.brpop(0, "list1"));
    // 弹出最右端的元素，将其推入到新队列的最左端，并向用户返回该元素 list1=> item2  list2=>item3
    System.out.println(jedis.rpoplpush("list1", "list2")); // item3
    // 弹出最右端的元素，将其推入到新队列的最左端，并向用户返回该元素 如果list1无元素，等待timeout list1=> item2  list2=>item2,item3
    System.out.println(jedis.brpoplpush("list1", "list2",10));
}

 

 

 

 

2.1.3 集合

    

    Redis的集合以无序的方式来存储多个各不相同的元素，用户可以快速对集合执行添加元素、移除元素操作以及检查一个元素是否在集合中；

 

Redis对集合的操作

@Test
public void test06() {
    Jedis jedis = new Jedis("localhost");
    // 生成set 存入元素
    jedis.sadd("set", "a", "b", "c", "c");
    System.out.println(jedis.smembers("set"));
    // 移除 b 元素
    jedis.srem("set", "b");
    System.out.println(jedis.smembers("set"));
    // 检查 a 元素是否在集合中
    System.out.println(jedis.sismember("set", "a"));
    // 查询set中元素个数
    System.out.println(jedis.scard("set"));
    // 随机返回一个或者多个元素，若count为正数，返回的随机元素不会重复；若count为负数，返回的随机元素可能会重复；
    System.out.println(jedis.srandmember("set", 1));
    // 随机的移除元素
    System.out.println(jedis.spop("set"));
    // 移除set指定的元素到set2，移除成功返回1，否则返回0
    if (jedis.smove("set", "set2", "b") > 0) {
        System.out.println("success");
        System.out.println(jedis.smembers("set2"));
    }else {
        System.out.println("error");
        System.out.println(jedis.smembers("set"));
    }

 

 

 

 

    命令可用于并集运算、交集运算和差集运算。

 

 

2.1.4 散列

    Redis的散列可以让用户将多个键值对存储到一个Redis建里面，将一些相关的数据存储在一起。

 

 

 

@Test
public void test07() {
    Jedis jedis = new Jedis("localhost");
    Map<String, String> map = new HashMap<>();
    map.put("k1", "value1");
    map.put("k2", "value2");
    map.put("k3", "value3");
    // 存储hash值
    jedis.hmset("hash-set", map);
    // 获取指定的key的值
    System.out.println(jedis.hmget("hash-set", "k1", "k2"));
    System.out.println(jedis.hmget("hash-set", "k1"));
    // 删除指定的key
    jedis.hdel("hash-set", "k1");
    System.out.println(jedis.hmget("hash-set", "k1"));
    // 统计个数
    System.out.println(jedis.hlen("hash-set"));
}

 

 

@Test
public void test08() {
    Jedis jedis = new Jedis("localhost");
    Map<String, String> map = new HashMap<>();
    map.put("num1", "10");
    map.put("num2", "20");
    map.put("num3", "30");
    // 存储hash值
    jedis.hmset("num-set", map);
    // 检查指定的key是否存储在散列中
    System.out.println(jedis.hexists("num-set", "num1"));
    //System.out.println(jedis.hexists("num-set", "num4"));
    // 获取散列表中包含的所有键
    System.out.println(jedis.hkeys("num-set"));
    // 获取散列表中包含的所有值
    System.out.println(jedis.hvals("num-set"));
    // 获取所有键值对
    System.out.println(jedis.hgetAll("num-set"));
    // 将key存储的值加整数increment
    jedis.hincrBy("num-set", "num1", 20);
    System.out.println(jedis.hgetAll("num-set"));
    // 将key存储的值加浮点数
    jedis.hincrByFloat("num-set", "num2", 20.8);
    System.out.println(jedis.hgetAll("num-set"));
}

 

2.1.4 有序集合

    

　　存储成员与分值之间的映射，并且提供了分值处理命令，根据分值大小有序的获取（fetch）或扫描（scan）成员和分值的命令。

 

 

 

@Test
public void test09() {
    Jedis jedis = new Jedis("localhost");


    // 生成有序集合
    jedis.zadd("zset-key", new HashMap<String, Double>() {{
        put("a", 1d);
        put("b", 2d);
        put("c", 3d);
    }});
    // 返回有序集合包含的成员数量
    System.out.println(jedis.zcard("zset-key"));
    // 有序集合内指定的值+increment
    jedis.zincrby("zset-key", 5d, "a");
    // 返回成员member的值
    System.out.println(jedis.zscore("zset-key", "a"));
    // 返回分值介于min和max之间的成员数量
    System.out.println(jedis.zcount("zset-key", 4, 7));
    // 返回有序集合中排名介于start和stop之间的成员，
    System.out.println(jedis.zrange("zset-key", 0, 3));
    System.out.println(jedis.zrange("zset-key", 2, 3));
    // 如果给定了可选的WITHSCORES选项，那么成员的分值也返回
    System.out.println(jedis.zrangeByScoreWithScores("zset-key", 2, 3));
}

 

 

 

 

 

@Test
public void test10() {
    Jedis jedis = new Jedis("localhost");
    // 生成有序集合
    jedis.zadd("zset2-key", new HashMap<String, Double>() {{
        put("a", 1d);
        put("b", 3d);
        put("c", 2d);
    }});
    // 返回有序集合中指定member的排名
    System.out.println(jedis.zrevrank("zset2-key", "a"));
    // 返回有序集合给定排名范围内的成员 分值降序
    System.out.println(jedis.zrevrange("zset2-key", 0, jedis.zcard("zset-key")));
    // 返回有序集合中分值介于min和max之间的所有成员 并按照分值排序
    System.out.println(jedis.zrangeByScore("zset2-key", 2, 3));
    // 移除排名介于start和max之间所有成员 删除排名1-2之间的成员
    jedis.zremrangeByRank("zset2-key", 1, 2);
    // 查询移除后的结果
    System.out.println(jedis.zrevrange("zset2-key", 0, jedis.zcard("zset-key")));
    jedis.zadd("zset2-key", new HashMap<String, Double>() {{
        put("a", 1d);
        put("b", 3d);
        put("c", 2d);
    }});
    // 移除分值介于min和max之间所有成员
    jedis.zremrangeByScore("zset2-key", 1, 2);
    System.out.println(jedis.zrevrange("zset2-key", 0, jedis.zcard("zset-key")));
}

 

　　交集和并集

Redis的交集运算：

    将相同key的成员的分值相加，若某个成员是集合中独有的，在合并后不存在；

 

Redis的并集运算：

    将相同key的成员的分值相加，若某个成员是集合中独有的，在合并后放置在新的集合中；

@Test
public void test11() {
    Jedis jedis = new Jedis("localhost");
    jedis.zadd("zset3-key", new HashMap<String, Double>() {{
        put("a", 1d);
        put("b", 4d);
        put("c", 2d);
    }});
    jedis.zadd("zset4-key", new HashMap<String, Double>() {{
        put("a", 7d);
        put("e", 3d);
        put("f", 1d);
    }});
    // 对有序集合执行交集运算
    jedis.zinterstore("zset5-key", "zset3-key", "zset4-key");
    System.out.println(jedis.zrevrangeWithScores("zset5-key", 0, jedis.zcard("zset5-key")));
    // 对有序集合执行并集运算
    jedis.zunionstore("zset6-key", "zset3-key", "zset4-key");
    System.out.println(jedis.zrevrangeWithScores("zset6-key", 0, jedis.zcard("zset6-key")));
}