Redis五大数据类型

Key +

  • string
  • set
  • list
  • hash
  • zset

通用操作指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#查询当前库的所有键
keys * 
#判断某个键是否存在
exists <key> 
#查看键的类型
type <key>
#删除某个键
del <key>
#设置键值对的过期时间 单位:秒
expire <key> <seconds>
#查看还有多少秒过期 -1永不过期 -2已过期
ttl <key>
#查看当前数据库key的数量
dbsize
#清空当前库
Flushdb
#通杀全部库
Flushall

String

  • String是Redis最基本的类型,可以理解成与Memcached一模一样的类型,一个key 对应一个value
  • String类型是二进制安全的,意味着redis的string可以包含任何数据.比如jpg图片或者序列化的对象
  • String类型是redis最基本的数据类型,一个redis中,字符串value最多可以是512M

基本操作指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#查询对应键值
get <key>
#添加键值对
set <key> <value>
#将给定的值添加到原值的末尾
append <key> <value>
#获得值的长度
strlen <key>
#仅当key不存在的时候设置key的值
setnx <key> <value>
#将key中存储的数字增1 只能对数字值操作 如果为空 新增的值为1
incr <key>
#将key中存储的数字减1 只能对数字值操作 如果为空 新增的值为-1
decr <key>
#将key中的数字进行增减 自定义步长
incr/decr <key> <步长>

INCR KEY

对储存在指定key的数值执行原子的加1 操作

原子性: 不会被线程调度机制打断

在单线程中 能够在单条指令中完成的操作 都可以认为是 原子操作, 因为中断只能发生在指令中间

在多线程中 不能被其它线程打断的操作 就是原子操作

Redis单命令的原子性主要得益于redis的单线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#同时设置一个或者多个key-value
mset <key1> <value1> <key2> <value2> ...
#同时获取一个或者多个key-value
mget <key1> <value1> <key2> <value2> ...
#同时设置一个或者多个key-value 仅当所有给定的值都不存在
msetnx <key1> <value1> <key2> <value2> ...
#获得值的范围 类似java中的substring
getrange <key> <起始位置> <结束位置>
#从起始位置开始覆写key
setrange <key> <起始位置> <value>
#设置键值同时设置过期时间
setex <key> <过期时间> <value>
#以旧换新
getset <key> <value>

List

  • 单键多值
  • Redis列表是最简单的字符串列表 按照插入顺序排序 可以添加一个 元素导列表的头部(左边)或者尾部(右边)
  • 他的底层实际是一个双向链表 对两端的操作性能都很高 通过索引下标的操作中间的节点性能会比较差

image-20200908121748020

基本操作指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#从左边/右边插入值
lpush/rpush <key> <value1> <value2> <value3>...
#从左边/右边 吐出一个值 值在键在 值光键完
lpop/rpop <key>
#从 key1 右边吐出一个值 插到 key2 左边
rpoplpush <key1> <key2>
#按照索引下标获得元素(从左到右)
lrange <key> <start> <stop>
#按照索引下标获得元素(从右到左)
lindex <key> <start> <stop>
#获得列表长度
llen <key>
# 在value 后面插入 new value 插入值
linsert <key> after <value> <newvalue>
#从左边删除n个value n可以输入负数和0 负数表示从右到左 0表示全删除
lrem <key> <n> <value>

Set

  • Redis set对外提供的功能和list类似 是一个列表的功能

    特殊之处在于set可以自动排重 当你需要存储一个列表数据 又不希望出现重复数据的时候 set是一个很好的选择

    并且set提供了判断某个成员是否在set集合内的重要接口 这个 也是list所不能提供的

  • redis的set是string的无序集合 它底层其实是一个value为null的hash表,所以添加删除查找的复杂度都是O(1)

基本操作指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#将一个或者多个member元素加入到集合key中 当前已经存在的自动忽略
sadd <key> <value1> <value2>
#取出该集合的所有值
smembers <key>
#判断集合中<key>是否含有该<value> 有返回1 没有 返回0
sismember <key> <value>
#返回集合的元素个数
scard <key>
#删除集合中的某个元素
srem <key> <value1> <value2>
#随机吐出集合中的一个值
spop <key>
#随机从集合中取出n个值 不会在集合中删除
srandmember <key> <n>
#返回两个集合的交集元素
sinter <key1> <key2>
#返回两个集合的并集元素
sunion <key1> <key2>
#返回两个集合的差集元素
sdiff <key1> <key2>

Hash

  • Redis hash 是一个键值对集合
  • redis hash是一个string类型的field和value的映射表 hash特别适合用于存储对象
  • 类似java Map<String,String>

image-20200908123808970

基本操作指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#给<key>集合中的<field>键赋值<value> 
hset <key> <field> <value>
#从<key1>集合<field>中取出value
hget <key> <field> <value>
#批量设置hash的 值
hmset <key1> <field1> <value1> <field2> <value2>
#查看哈希表key中 field是否存在
hexists key <field>
#列出该hash集合的所有field
hkeys <key>
#列出该hash集合的所有value
hvals <key>
#为哈希表key中的域field的值加上增量increment
hincrby <key> <field> <increment>
#将哈希表key中的域field的值设置为value,当且仅当域field不存在
hsetnx <key> <field> <value>

ZSET(sorted set)

  • Redis有序集合zset和普通集合set非常相似 是一个没有重复元素的字符串集合 不同之处是有序集合的每个成员都关联了一个 评分(score),这个评分被用来按照从最低分到最高分的方式排序.集合的成员是唯一的 但是评分可以是重复的
  • 因为元素是有序的 所以可以很快根据评分或者次序来获取一个范围的元素 访问有序集合的中间元素也是非常快的 因此能使用有序集合作为一个没有重复成员的智能列表

基本操作指令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#将一个或者多个member元素机器score加入到有序集合key中
zadd <key> <score1> <value1> <score2> <value2> 
#返回有序集key中 下标在<start><stop>之间的元素 带withscores 可以让分数一起和值返回到结果集合
zrange <key> <start> <stop>[WITHSCORES]
#返回有序集合key中 score介于 min max之间的成员 等于也包括 有序集合成员按照score从小到大排序
zrangebyscore key min max [WITHSCORES][limit offset count]
#有序集合成员按照score从大到小排序
zrevrangebyscore key max min [WITHSCORES][limit offset count]
#为元素的score加上增量
zincrby <key> <increment> <value>
#删除该集合下指定值的元素
zrem <key> <value>
#统计该集合 分数区间内的元素个数
zcount <key> <min> <max>
#返回该值在集合中的排名 从0开始
zrank <key> <value>

RedisUtils 工具类

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
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226

/**
 * Redis工具类，使用之前请确保RedisTemplate成功注入
 *
 */
public class RedisUtils {
 
    private RedisUtils() {
    }
 
    @SuppressWarnings("unchecked")
    private static RedisTemplate<String, Object> redisTemplate = SpringUtils
        .getBean("redisTemplate", RedisTemplate.class);
 
    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public static boolean expire(final String key, final long timeout) {
 
        return expire(key, timeout, TimeUnit.SECONDS);
    }
 
    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @return true=设置成功；false=设置失败
     */
    public static boolean expire(final String key, final long timeout, final TimeUnit unit) {
 
        Boolean ret = redisTemplate.expire(key, timeout, unit);
        return ret != null && ret;
    }
 
    /**
     * 删除单个key
     *
     * @param key 键
     * @return true=删除成功；false=删除失败
     */
    public static boolean del(final String key) {
 
        Boolean ret = redisTemplate.delete(key);
        return ret != null && ret;
    }
 
    /**
     * 删除多个key
     *
     * @param keys 键集合
     * @return 成功删除的个数
     */
    public static long del(final Collection<String> keys) {
 
        Long ret = redisTemplate.delete(keys);
        return ret == null ? 0 : ret;
    }
 
    /**
     * 存入普通对象
     *
     * @param key Redis键
     * @param value 值
     */
    public static void set(final String key, final Object value) {
 
        redisTemplate.opsForValue().set(key, value, 1, TimeUnit.MINUTES);
    }
 
    // 存储普通对象操作
 
    /**
     * 存入普通对象
     *
     * @param key 键
     * @param value 值
     * @param timeout 有效期，单位秒
     */
    public static void set(final String key, final Object value, final long timeout) {
 
        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }
 
    /**
     * 获取普通对象
     *
     * @param key 键
     * @return 对象
     */
    public static Object get(final String key) {
 
        return redisTemplate.opsForValue().get(key);
    }
 
    // 存储Hash操作
 
    /**
     * 往Hash中存入数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @param value 值
     */
    public static void hPut(final String key, final String hKey, final Object value) {
 
        redisTemplate.opsForHash().put(key, hKey, value);
    }
 
    /**
     * 往Hash中存入多个数据
     *
     * @param key Redis键
     * @param values Hash键值对
     */
    public static void hPutAll(final String key, final Map<String, Object> values) {
 
        redisTemplate.opsForHash().putAll(key, values);
    }
 
    /**
     * 获取Hash中的数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public static Object hGet(final String key, final String hKey) {
 
        return redisTemplate.opsForHash().get(key, hKey);
    }
 
    /**
     * 获取多个Hash中的数据
     *
     * @param key Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public static List<Object> hMultiGet(final String key, final Collection<Object> hKeys) {
 
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }
 
    // 存储Set相关操作
 
    /**
     * 往Set中存入数据
     *
     * @param key Redis键
     * @param values 值
     * @return 存入的个数
     */
    public static long sSet(final String key, final Object... values) {
        Long count = redisTemplate.opsForSet().add(key, values);
        return count == null ? 0 : count;
    }
 
    /**
     * 删除Set中的数据
     *
     * @param key Redis键
     * @param values 值
     * @return 移除的个数
     */
    public static long sDel(final String key, final Object... values) {
        Long count = redisTemplate.opsForSet().remove(key, values);
        return count == null ? 0 : count;
    }
 
    // 存储List相关操作
 
    /**
     * 往List中存入数据
     *
     * @param key Redis键
     * @param value 数据
     * @return 存入的个数
     */
    public static long lPush(final String key, final Object value) {
        Long count = redisTemplate.opsForList().rightPush(key, value);
        return count == null ? 0 : count;
    }
 
    /**
     * 往List中存入多个数据
     *
     * @param key Redis键
     * @param values 多个数据
     * @return 存入的个数
     */
    public static long lPushAll(final String key, final Collection<Object> values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        return count == null ? 0 : count;
    }
 
    /**
     * 往List中存入多个数据
     *
     * @param key Redis键
     * @param values 多个数据
     * @return 存入的个数
     */
    public static long lPushAll(final String key, final Object... values) {
        Long count = redisTemplate.opsForList().rightPushAll(key, values);
        return count == null ? 0 : count;
    }
 
    /**
     * 从List中获取begin到end之间的元素
     *
     * @param key Redis键
     * @param start 开始位置
     * @param end 结束位置（start=0，end=-1表示获取全部元素）
     * @return List对象
     */
    public static List<Object> lGet(final String key, final int start, final int end) {
        return redisTemplate.opsForList().range(key, start, end);
    }
}

参考资料: 尚硅谷