Redis API 入门

发表于 | 分类于 | | 阅读次数:

基本

  • windows 连接redis: redis-cli.exe -h 127.0.0.1 -p 6379
  • 查看所有的key: keys *
  • 删除所有key value : flushall
  • 查看当前数据库键的数量： dbsize
  • 切换数据库 ： select [index]
  • 获取键值的数据类型：type key

字符串(string)

  • 插入键： set key value
  • 获取值： get key
  • 多重插入键：mset key value
  • 多重获取值： mget key
  • 判断键是否存在：exists key
  • 删除键：del key (删除不支持通配符，不过支持多键参数：redis-cli DEL ‘redis-cli KEYS “user:*”‘)
  • 递增数字: incr key
  • 增加指定整数： incrby key increment
  • 减少指定整数： decrby key increment
  • 增加指定浮点数： incrbyfloat key increment
  • 追加value: append key value
  • 获取字符串长度： strlen key

散列(hash)

  • 插入键值： hset key field value
  • 获取值： hget key field
  • 获取全部键值： hgetall key
  • 多重插入键：hmset key field1 value1 field2 value2*
  • 多重获取值： hmget key field1 field1
  • 判断键是否存在：hexists key field
  • 插入键值（原子，键值存在则不插入） ： hsetnx key field
  • 增加指定整数： hincrby key field increment
  • 删除键值： hdel key field
  • 只获取字段名：hkeys key
  • 只获取字段值：hvals key
  • 获取字段数量： hlen key

列表(list)

  • 向列表左边添加元素(创建元素)： lpush key value
  • 向列表右边添加元素(创建元素)： rpush key value
  • 从左边弹出一个元素：lpop key
  • 从右边弹出一个元素：rpop key
  • 获取列表中元素数量：llen key
  • 获取列表中片段： lrange key 0 2
  • 删除元素： lrem key count value
  • 当count>0，从左边删除count个value值
  • 当count<0，从右边删除|count|个value值
  • 当count=0，整个列表中删除value值
  • 根据index获取元素：lindex key index
  • 指定index位置的的元素：lset key index value
  • 修剪列表： ltrim key start end
  • 插入元素：linsert key before|after pivot value
  • 将元素从一个列表转向另一个列表：rpoplpush source destination

集合(set)

  • 添加元素：sadd key value[…]
  • 删除元素：srem key value[…]
  • 获取全部集合元素： smembers key
  • 判断元素是否存在： sismember key value
  • 获取集合元素个数：scard key
  • 随机弹出元素： spop
  • 随机获取：srandmember key count
  • 当count>0，从集合获取count个不重复值，count>集合元素数目，获取全部
  • 当count<0，从集合获取|count|个值，元素有可能重复
  • 差：sdiff setA setB[…]
  • 交集 : sinner setA setB[…]
  • 并集 : sunion setA setB[…]
  • 差：sdiffstore destination setA setB[…]
  • 交集：sinner destination setA setB[…]
  • 并集：sunion destination setA setB[…]

有序集合（sorted set）

有序集合和列表相似，不过二者使用场景还是有很多不同的。
1.列表是通过链表实现，获取靠近两端数据极快，比较适合“新鲜事”、“日志”这样比较少访问中间元素的应用。
2.有序集合是使用散列表和跳跃表来实现，即时读取中间位置元素，速度也很快（时间复杂度O(log(N))）。
3.列表不能简单地调整元素位置，有序集合可以（更改分数）。
4.有序集合比列表更耗费内存。

  • 添加元素：zadd key score member […]
  • 获得元素分数：zscore key member
  • 获取集合中片段（分数由小到大排序）： zrange key start stop[withscores]
  • 获取集合中片段（分数由大到小排序）： zrevrange key start stop[withscores]
  • 根据分数范围获取列表中片段（分数由小到大排序）：zrangebyscore key min max [withscores ] [limit offset count]
  • 根据分数范围获取集合中片段（分数由大到小排序）：zrevrangebyscore key max min [withscores ] [limit offset count]
  • +inf -inf 代表正负无穷 1 (5 代表数学上的[1 5)
  • 改变元素分数：zincrby key increment member
  • 获取集合中元素数量: zcard key
  • 获取指定分数范围内元素数目： zcount key min max
  • 删除元素： zrem key member[…]
  • 按照排名rank删除元素： zremrangebyrank key start stop
  • 按照分数删除元素： zremrangebyrank key min max
  • 获取元素排名(正序，分数最小的排名0)： zrank key member
  • 获取元素排名（倒序，分数最大的排名0）：zrevrank key member
  • 计算有序集合的交集（并集同理）：zinterstore destination numkeys key[…] [aggregate :sum|min|max]
    其中numkeys是交集集合元素数目，aggregate选项是交集集合score的具体来源方式，例如aggregate=sum，此时交集集合当前元素的score就是所有被交集的元素score的和。

附上jedis相关api测试代码:

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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
/**
 * test redis api
 */
public class testRedisApi {
    public static void main(String[] args) {
            Jedis jedis = new Jedis("localhost");
            //testString(jedis);
            //testHash(jedis);
            //testList(jedis);
            //testSet(jedis);
            testZset(jedis);
    }
    /**
     * 测试String类型
     * @param jedis
     */
    private static void testString (Jedis jedis) {
        if (!jedis.exists("color:0")) {
            print("插入 string data...",true);
            // 新增key value
            jedis.set("color:0","red");
        }
        print("测试String类型...");
        String key = "color:0";
        // 判断key是否存在
        print("判断key是否存在" + jedis.exists(key));
        // 根据key获取value
        print("初始值 = " + jedis.get(key));
        // 根据key追加value
        jedis.append(key,"|blue");
        print("追加blue后的值: "+ jedis.get(key));
        // 获取string长度
        print("获取string长度: "+ jedis.strlen(key));
        // 删除
        jedis.del(key);
        print("删除key后的值: "+ jedis.get(key));
        // 递增数字键
        print("test递增数字键: "+ jedis.incr("id"));
        print("test递增数字键: "+ jedis.incr("id"));
        jedis.set("color:0","red");
    }
    /**
     * 测试Hash类型
     * @param jedis
     */
    private static void testHash (Jedis jedis) {
        if (jedis.hlen("car0") == 0) {
            print("插入 hash data...",true);
            // 新增hash数据
            Map<String,String> hashMap = new HashMap<>();
            hashMap.put("brand","BMW");
            hashMap.put("color","black");
            hashMap.put("price","888888");
            jedis.hmset("car0",hashMap);
        }
        print("测试Hash类型...");
        String key = "car0";
        // 根据key获取field value
        print("获取field值：" + jedis.hget(key,"brand"));
        // 获取全部field value (Map)
        print("获取全部field值：" + jedis.hgetAll(key));
        // 判断filed是否存在
        print("判断filed是否存在：" + jedis.hexists(key,"brand"));
        // 获取全部field
        print("获取全部field：" + jedis.hkeys(key));
        // 获取全部value
        print("获取全部value: " + jedis.hvals(key));
        // 删除指定field
        print("删除指定field: " + jedis.hdel(key,"color","price","brand"));
        // 获取field数量
        print("获取field数量:" +jedis.hlen(key));
    }
    /**
     * 测试List类型
     * @param jedis
     */
    private static void testList (Jedis jedis) {
        if (jedis.llen("girls") == 0) {
            print("插入 list data...",true);
            // 新增list数据
            jedis.lpush("girls","yuyu");
            jedis.rpush("girls","jingjing");
            jedis.rpush("girls","qiqi");
        }
        print("测试List类型...");
        String key = "girls";
        //获取list中片段(-1代表最后一个)
        print(jedis.lrange(key,0,-1).toString());
        // 从左边pop一个元素（右边rpop）
        print(jedis.lpop(key));
        // 获取list中元素数量
        print("list中元素数量" +jedis.llen(key));
        // 根据index获取元素
        print("根据index获取元素:" + jedis.lindex(key,0));
        // 根据index设置元素(index必须是在当前数组域中，否则报ERR index out of range)
        print("根据index设置元素:" + jedis.lset(key,0,"huhu"));
        // 删除元素
        // 当count>0，从左边删除count个value值
        // 当count<0，从右边删除|count|个value值
        // 当count=0，整个列表中删除value值
        print("删除元素:" + jedis.lrem(key,0,"huhu"));
        // 插入元素到指定位置
        print("插入元素到指定位置:"+ jedis.linsert(key, BinaryClient.LIST_POSITION.AFTER,"yuyu","hxhx"));
        // 将元素从一个列表转向另一个列表
        print("元素从一个列表转向另一个列表:" + jedis.rpoplpush(key,"test"));
        // 修剪list列表
        print("修剪list列表:" + jedis.ltrim("test",jedis.llen("test"),jedis.llen("test")));
    }
    /**
     * 测试Set类型
     * @param jedis
     */
    private static void testSet (Jedis jedis) {
        if (jedis.scard("languages") == 0) {
            print("插入 Set data...",true);
            // 新增set数据
            jedis.sadd("languages","java","java","javascript","python","golang");
        }
        print("测试Set类型...");
        String key = "languages";
        // 获取全部集合元素 (Set 无序)
        print("获取全部集合元素：" + jedis.smembers(key));
        // 判断元素是否存在
        print("判断元素是否存在：" + jedis.sismember(key,"java"));
        // 随机pop元素
        print("随机pop元素:" + jedis.spop(key));
        // 随机获取
        // 当count>0，从集合获取count个不重复值，count>集合元素数目，获取全部
        // 当count<0，从集合获取|count|个值，元素有可能重复
        print("随机获取元素:" + jedis.srandmember(key,1));
        // 移除集合指定成员
        print("移除集合指定成员:" + jedis.srem(key,"java","javascript"));
        jedis.sadd("set1","1","2","3");
        jedis.sadd("set2","1","4","5");
        // 差集
        print("差集：" + jedis.sdiff("set1","set2"));
        // 交集
        print("交集：" + jedis.sinter("set1","set2"));
        // 并集
        print("并集："+ jedis.sunion("set1","set2"));
    }
    /**
     * 测试Zset类型
     * @param jedis
     */
    private static void testZset (Jedis jedis) {
        if (jedis.zcard("phones") == 0) {
            print("插入 Zset data...",true);
            // 新增zset数据
            Map<String,Double> zMap = new HashMap<>();
            zMap.put("xiaomi",1.0);
            zMap.put("huawei",1.0);
            zMap.put("oneplus",2.0);
            zMap.put("apple",3.0);
            jedis.zadd("phones",zMap);
        }
        print("测试Zset类型...");
        String key = "phones";
        // 根据index获取集合片段(socre由小到大排序，zrevrange是相反的)
        print("根据index获取集合片段："+ jedis.zrange(key,0,-1));
        // 获取元素score
        print("获取元素score:" + jedis.zscore(key,"apple"));
        // 根据score范围获取集合片段(四个参数分别为：MAX socre，MIN score, offset[偏移量] ,count[数目])
        print("根据score获取集合片段：" + jedis.zrevrangeByScore(key,4,0,1,1));
        // 获取指定score范围内元素数目
        print("获取指定score范围元素数目：" + jedis.zcount(key,0,2));
        // 改变元素score
        print("改变元素socre:" + jedis.zincrby(key,4,"huawei"));
        // 获取元素排名index（正序）
        print("获取元素排名：" + jedis.zrank(key,"huawei"));
    }
    /**
     * 打印消息（不切行）
     * @param str
     */
    private static void print (String str) {
        print(str,false);
    }
    /**
     * 打印消息（切行）
     * @param str
     */
    private static void print (String str,boolean isNextLine) {
        if (isNextLine) {
            System.out.println(str+"\n");
            return;
        }
        System.out.println(str);
    }
}