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

时间 2020-05-28

标签 redis 基本类型使用 java 栏目 Redis 繁體版

原文原文链接

1 Redis简介

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

redis的优势：

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

2 Redis数据结构简介

STRING(字符串)；
LIST(列表)；
SET（集合）
HASH（散列）
ZSET(有序集合)

Java使用Redis

一、引入Maven依赖

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

二、测试

1 @Test
2 public void test01(){
3     Jedis jedis = new Jedis("localhost");
4  
5     jedis.set("hello","world");
6  
7     System.out.println(jedis.get("hello"));
8 }

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

2.1.1 STRING(字符串)；

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

字符串
整数
浮点数

Redis自增命令和自减命令redis

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

 1 @Test
 2 public void test02(){
 3     Jedis jedis = new Jedis("localhost");
 4 
 5 
 6     jedis.set("num","10");
 7     // 11
 8     System.out.println(jedis.incr("num"));
 9     // 31
10     System.out.println(jedis.incrBy("num",20));
11     // 11
12     System.out.println(jedis.decrBy("num",20));
13 }

　　java使用Redis处理子串：数据库

 1 @Test
 2 public void test03() {
 3     Jedis jedis = new Jedis("localhost");
 4     // redis存储字符串
 5     jedis.set("str","hello");
 6     System.out.println(jedis.get("str"));
 7     // 字符串追加
 8     jedis.append("str","world");
 9     System.out.println(jedis.get("str"));
10     // 取子串
11     System.out.println(jedis.getrange("str",5,9));
12     // 指定位置插入字符串(会把指定位置以后的字符串覆盖)
13     jedis.setrange("str",5,",jiz");
14     System.out.println(jedis.get("str"));
15 }

　　运行结果：缓存

2.1.2 列表

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

Redis对列表的基本操做网络

 1 @Test
 2 public void test04() {
 3     Jedis jedis = new Jedis("localhost");
 4     // 1 2
 5     jedis.rpush("list", "1", "2");
 6     // 1
 7     System.out.println(jedis.rpop("list")); //2
 8     // 3 1
 9     jedis.lpush("list","3");
10     // 1
11     System.out.println(jedis.lpop("list")); //3
12     // 3 2 1
13     jedis.lpush("list", "2", "3");
14     // 得到位置为1的元素
15     System.out.println(jedis.lindex("list",1)); // 3
16 }

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

　　　　　　　　　　　　　　　　Redis阻塞式列表操做app

 1 @Test
 2 public void test05() {
 3     Jedis jedis = new Jedis("localhost");
 4     // item1 item2 item3 item4
 5     jedis.rpush("list1", "item1", "item2", "item3", "item4");
 6     // 弹出最左端的元素 item2 item3 item4
 7     System.out.println(jedis.blpop(0, "list1"));
 8     // 弹出最右端的元素 item2 item3
 9     System.out.println(jedis.brpop(0, "list1"));
10     // 弹出最右端的元素，将其推入到新队列的最左端，并向用户返回该元素 list1=> item2  list2=>item3
11     System.out.println(jedis.rpoplpush("list1", "list2")); // item3
12     // 弹出最右端的元素，将其推入到新队列的最左端，并向用户返回该元素 若是list1无元素，等待timeout list1=> item2  list2=>item2,item3
13     System.out.println(jedis.brpoplpush("list1", "list2",10));
14 }

2.1.3 集合

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

Redis对集合的操做测试

 1 @Test
 2 public void test06() {
 3     Jedis jedis = new Jedis("localhost");
 4     // 生成set 存入元素
 5     jedis.sadd("set", "a", "b", "c", "c");
 6     System.out.println(jedis.smembers("set"));
 7     // 移除 b 元素
 8     jedis.srem("set", "b");
 9     System.out.println(jedis.smembers("set"));
10     // 检查 a 元素是否在集合中
11     System.out.println(jedis.sismember("set", "a"));
12     // 查询set中元素个数
13     System.out.println(jedis.scard("set"));
14     // 随机返回一个或者多个元素，若count为正数，返回的随机元素不会重复；若count为负数，返回的随机元素可能会重复；
15     System.out.println(jedis.srandmember("set", 1));
16     // 随机的移除元素
17     System.out.println(jedis.spop("set"));
18     // 移除set指定的元素到set2，移除成功返回1，不然返回0
19     if (jedis.smove("set", "set2", "b") > 0) {
20         System.out.println("success");
21         System.out.println(jedis.smembers("set2"));
22     }else {
23         System.out.println("error");
24         System.out.println(jedis.smembers("set"));
25     }

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

2.1.4 散列

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

 1 @Test
 2 public void test07() {
 3     Jedis jedis = new Jedis("localhost");
 4     Map<String, String> map = new HashMap<>();
 5     map.put("k1", "value1");
 6     map.put("k2", "value2");
 7     map.put("k3", "value3");
 8     // 存储hash值
 9     jedis.hmset("hash-set", map);
10     // 获取指定的key的值
11     System.out.println(jedis.hmget("hash-set", "k1", "k2"));
12     System.out.println(jedis.hmget("hash-set", "k1"));
13     // 删除指定的key
14     jedis.hdel("hash-set", "k1");
15     System.out.println(jedis.hmget("hash-set", "k1"));
16     // 统计个数
17     System.out.println(jedis.hlen("hash-set"));
18 }

 1 @Test
 2 public void test08() {
 3     Jedis jedis = new Jedis("localhost");
 4     Map<String, String> map = new HashMap<>();
 5     map.put("num1", "10");
 6     map.put("num2", "20");
 7     map.put("num3", "30");
 8     // 存储hash值
 9     jedis.hmset("num-set", map);
10     // 检查指定的key是否存储在散列中
11     System.out.println(jedis.hexists("num-set", "num1"));
12     //System.out.println(jedis.hexists("num-set", "num4"));
13     // 获取散列表中包含的全部键
14     System.out.println(jedis.hkeys("num-set"));
15     // 获取散列表中包含的全部值
16     System.out.println(jedis.hvals("num-set"));
17     // 获取全部键值对
18     System.out.println(jedis.hgetAll("num-set"));
19     // 将key存储的值加整数increment
20     jedis.hincrBy("num-set", "num1", 20);
21     System.out.println(jedis.hgetAll("num-set"));
22     // 将key存储的值加浮点数
23     jedis.hincrByFloat("num-set", "num2", 20.8);
24     System.out.println(jedis.hgetAll("num-set"));
25 }

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));
}

 1 @Test
 2 public void test10() {
 3     Jedis jedis = new Jedis("localhost");
 4     // 生成有序集合
 5     jedis.zadd("zset2-key", new HashMap<String, Double>() {{
 6         put("a", 1d);
 7         put("b", 3d);
 8         put("c", 2d);
 9     }});
10     // 返回有序集合中指定member的排名
11     System.out.println(jedis.zrevrank("zset2-key", "a"));
12     // 返回有序集合给定排名范围内的成员 分值降序
13     System.out.println(jedis.zrevrange("zset2-key", 0, jedis.zcard("zset-key")));
14     // 返回有序集合中分值介于min和max之间的全部成员 并按照分值排序
15     System.out.println(jedis.zrangeByScore("zset2-key", 2, 3));
16     // 移除排名介于start和max之间全部成员 删除排名1-2之间的成员
17     jedis.zremrangeByRank("zset2-key", 1, 2);
18     // 查询移除后的结果
19     System.out.println(jedis.zrevrange("zset2-key", 0, jedis.zcard("zset-key")));
20     jedis.zadd("zset2-key", new HashMap<String, Double>() {{
21         put("a", 1d);
22         put("b", 3d);
23         put("c", 2d);
24     }});
25     // 移除分值介于min和max之间全部成员
26     jedis.zremrangeByScore("zset2-key", 1, 2);
27     System.out.println(jedis.zrevrange("zset2-key", 0, jedis.zcard("zset-key")));
28 }

　　交集和并集

Redis的交集运算：

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

Redis的并集运算：

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

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