Sakura的博客
0%

Redis快速入门

发表于

Redis快速入门

Redis介绍

Redis是一个键值数据库，内存数据库，属于AP模型（CAP理论模型）

有四种模式可以部署

  • 单机模式
  • 主从模式
  • 哨兵模式
  • 集群模式

Redis内部使用自己设计的一种文本协议进行客户端与服务端之间的通信-RESP（基于TCP协议实现，采用请求/响应模型）

在集群模式下，Redis会对存储数据进行切片（利用哈希槽进行分片，Redis cluster划分了16384个槽，一个槽对应一个节点，存数据时会先算哈希值，具体来说就是在存取key时，Redis会使用CRC16算法得出一个结果，再对16384取余计算出槽位置)

Redis的优势

  • 基于内存
  • 单线程模型
  • 多路复用IO模型，就是多个线程的IO注册到同一个管道上，这个管道会统一和内核进行交互，当管道中的某一个请求需要的数据准备好之后，进程就把对应的数据拷贝到用户空间中。（分为三种：select、poll、epoll）
  • 高效的数据结构（基本数据结构和高级数据结构）
    • 字符串 String
    • 列表 List
    • 集合 Set
    • 有序集合 Zset
    • 哈希 Hash
    • 流 Stream
    • 位图 Bitmap
    • Geospatial
    • HyperLogLog
  • 多线程的引入（Redis6.0），只是接收网络通信使用了多线程，数据的读写操作还是使用的单线程

Redis安装（Ubuntu）

更新apt

1
2
sudo apt update
sudo apt upgrade

安装Redis

1
sudo apt install redis-server

查看Redis版本

1
redis-cli --version

查看运行状态

1
systemctl status redis

配置远程连接

1
2
3
4
5
sudo nano /etc/redis/redis.conf 
# #取消注释requirepass 启动密码认证，并设置访问密码
requirepass your-pass-word
# 以守护进程运行Redis 
daemonize yes

ps:需要注意的是，Redis属于键值对数据库，然后键类型是支持所有二进制序列，但是一般都是使用字符串，空字符串也是一个有效的key值，值的类型就是五种基本数据类型加上高级数据类型

命令行操作

Redis默认为16个库

切换库

1
select db

删除库所有数据

1
flushdb

查看所有key

1
keys *

返回存在的key的数量

1
exists key [key...]

Redis可以给key设置过期时间expire &ttl

1
2
expire key 30
ttl key

返回key存储的value数据类型

1
type key

删除key

1
del key

字符串 String

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 设置
set key value
# 获取
get key
# 对数字类型加1
incr key
# 对数字类型减1
decr key
# 追加
append key value
# 获取value总长度
strlen key
# 截取value
getrange key start end
# 替换value
setrange key offset value
# 获取多个和设置多个
mset key1 value1 key2 value2
mget key1 key2

哈希 Hash，这里可以这么理解，就相当于创建一个哈希表，键key相当于表的名字，field和value表示哈希表的槽位和数据值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 新建
hset key field value
# 获取
hget key field
# 设置多个和获取多个
hmset key field1 value1 field2 value2
hmget key field1 field2
# 获取全部
hgetall key
# 删除 hdel
hdel key field
# 获取所有field域
hkeys key
# 获取所有值
hvals key
# 判断filed是否存在
hexists key field

列表 List

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 添加 lpush 和rpush
lpush key value[value..]
rpush key value[value]
# 获取lrange, 负数表示倒数
lrange key start stop
# 获取指定index元素
lindex key index
# 获取列表长度 llen
llen key
# 按值移除元素 lrem
lrem key count value
# 修改某个值 lset
lset key index value
# 插入元素到指定值之前或之后 linsert
linsert key BEFORE|AFTER pivot value

集合Set

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 添加 sadd
sadd key member
# 获取元素 smembers
smembers key
# 判断元素是否存在 sismember
sismember key member
# 获取集合元素个数 scard
scard key
# 删除集合key中的一个或多个元素 srem
srem key member
# 随机删除元素spop
spop key [count]
# 随机取元素 srandmember
srandmember key [count]

有序集合 Zset

1
2
3
4
5
6
7
8
9
10
# 添加zadd
zadd key score member [score member ..]
# 查询 zrange,WITHSCORES表示是否同时返回score和member
zrange key start stop [WITHSCORES]
# 区间查询 zrevrange,返回值按照score从大到小排序
zrevrange key start stop [WITHSCORES]
# 删除元素 zrem
zrem key member [member]
# 获取元素个数zcard
zcard key

Java操作Redis

工具：IDEA

安装依赖，使用jedis操作

1
2
3
4
5
<dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
</dependency>

初始化对象

1
2
3
4
5
@Before
    public void init() {
        this.jedis = new Jedis("192.168.10.129", 6379);
        jedis.auth("12345678");
    }

然后就可以使用jedis对Redis进行操作了

字符串String

1
2
3
4
5
6
7
8
9
10
@Test
    public void setKey() {
        jedis.set("test", "test");
        System.out.println(jedis.get("test"));
    }
    
@Test
    public void deleteKey() {
        jedis.del("test");
    }

列表List

1
2
3
4
5
6
7
8
9
10
11
@Test
    public void testList() {
        // 添加数据
        List<String> temp = Arrays.asList("1", "2", "3");
        Gson gson = new Gson();
        String s = gson.toJson(temp);
        jedis.rpush("testList", s);
        jedis.lpush("testList", "sakura");
        List<String> test = jedis.lrange("testList", 0, -1);
        System.out.println(test);
    }

集合Set

1
2
3
4
5
@Test
public void testSet() {
    jedis.sadd("testSet", "1", "2", "2");
    System.out.println(jedis.smembers("testSet"));
}

有序集合Zset

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Test
    public void testZSet() {
        HashMap<String, Double> scoreMap = new HashMap<String, Double>();
        scoreMap.put("xiaoming", 70.0);
        scoreMap.put("xiaowang", 100.0);
        scoreMap.put("xiaohong", 88.0);
        scoreMap.put("xiaoli", 60.0);
        scoreMap.put("zhangsan", 58.0);
        jedis.zadd("math", scoreMap);
        // 查看scoreMap的形式
        System.out.println("查看scoreMap的形式：" + scoreMap);
        // 0 第0个元素，-1最后一个元素
        System.out.println("返回math全部元素：" + jedis.zrange("math", 0, -1));
        System.out.println("查看key有多少个元素：" + jedis.zcard("math"));
        // 移除 xiaoli 这个元素
        System.out.println("移除xiaoli 这个元素");
        jedis.zrem("math", "xiaoli");
        // -inf 负无穷  inf 正无穷，即从小到大排序
        System.out.println("按照递增顺序，返回math全部的元素（含成绩）：" + jedis.zrangeByScoreWithScores("math", "-inf", "inf"));
        System.out.println("统计math集合，成绩在[80,100]之间的元素个数：" + jedis.zcount("math", 80, 100));
    }

哈希Hash

1
2
3
4
5
@Test
    public void testHash() {
        jedis.hset("testHash", "testField", "testValue");
        System.out.println(jedis.hget("testHash", "testField"));
    }

完整的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
package com.sakura.test;

import com.google.gson.Gson;
import com.nimbusds.jose.shaded.json.JSONUtil;
import org.junit.Before;
import org.junit.Test;
import redis.clients.jedis.Jedis;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;

public class TestRedis {

    public static Jedis jedis;

    @Before
    public void init() {
        this.jedis = new Jedis("192.168.10.129", 6379);
        jedis.auth("12345678");
    }

    @Test
    public void setKey() {
        jedis.set("test", "test");
        System.out.println(jedis.get("test"));
    }

    @Test
    public void deleteKey() {
        jedis.del("test");
    }

    @Test
    public void testList() {
        // 添加数据
        List<String> temp = Arrays.asList("1", "2", "3");
        Gson gson = new Gson();
        String s = gson.toJson(temp);
        jedis.rpush("testList", s);
        jedis.lpush("testList", "sakura");
        List<String> test = jedis.lrange("testList", 0, -1);
        System.out.println(test);
    }

    @Test
    public void testSet() {
        jedis.sadd("testSet", "1", "2", "2");
        System.out.println(jedis.smembers("testSet"));
    }

    @Test
    public void testZSet() {
        HashMap<String, Double> scoreMap = new HashMap<String, Double>();
        scoreMap.put("xiaoming", 70.0);
        scoreMap.put("xiaowang", 100.0);
        scoreMap.put("xiaohong", 88.0);
        scoreMap.put("xiaoli", 60.0);
        scoreMap.put("zhangsan", 58.0);
        jedis.zadd("math", scoreMap);
        // 查看scoreMap的形式
        System.out.println("查看scoreMap的形式：" + scoreMap);
        // 0 第0个元素，-1最后一个元素
        System.out.println("返回math全部元素：" + jedis.zrange("math", 0, -1));
        System.out.println("查看key有多少个元素：" + jedis.zcard("math"));
        // 移除 xiaoli 这个元素
        System.out.println("移除xiaoli 这个元素");
        jedis.zrem("math", "xiaoli");
        // -inf 负无穷  inf 正无穷，即从小到大排序
        System.out.println("按照递增顺序，返回math全部的元素（含成绩）：" + jedis.zrangeByScoreWithScores("math", "-inf", "inf"));
        System.out.println("统计math集合，成绩在[80,100]之间的元素个数：" + jedis.zcount("math", 80, 100));
    }

    @Test
    public void testHash() {
        jedis.hset("testHash", "testField", "testValue");
        System.out.println(jedis.hget("testHash", "testField"));
    }


}