← 返回首页

第2章: Redis数据类型

掌握Redis五大基本数据类型

Redis数据类型概览

Redis支持五种基本数据类型和三种特殊数据类型。

五大基本类型

String（字符串）：最基本的类型，可以存储字符串、数字、二进制数据
List（列表）：有序的字符串列表，支持头尾操作
Set（集合）：无序的字符串集合，元素唯一
Hash（哈希）：键值对集合，适合存储对象
ZSet（有序集合）：带分数的有序集合，可排序

三种特殊类型

Bitmap（位图）：基于字符串的位操作
HyperLogLog：基数统计
Geospatial（地理位置）：地理位置信息

String（字符串）

String是Redis最基本的数据类型，一个key对应一个value。

基本操作

# 设置值
SET name "Redis"
OK

# 获取值
GET name
"Redis"

# 设置多个值
MSET key1 "value1" key2 "value2" key3 "value3"
OK

# 获取多个值
MGET key1 key2 key3
1) "value1"
2) "value2"
3) "value3"

# 追加字符串
APPEND name " Database"
(integer) 15

GET name
"Redis Database"

# 获取字符串长度
STRLEN name
(integer) 15

数值操作

# 设置数字
SET counter 100
OK

# 自增1
INCR counter
(integer) 101

# 自减1
DECR counter
(integer) 100

# 增加指定值
INCRBY counter 10
(integer) 110

# 减少指定值
DECRBY counter 5
(integer) 105

# 浮点数增加
INCRBYFLOAT price 0.5
"10.5"

过期时间

# 设置值并指定过期时间（秒）
SETEX session 3600 "user_token"
OK

# 设置值并指定过期时间（毫秒）
PSETEX cache 60000 "cached_data"
OK

# 查看剩余时间（秒）
TTL session
(integer) 3599

# 查看剩余时间（毫秒）
PTTL cache
(integer) 59999

Java操作String

@Service
public class StringService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 设置字符串
    public void setString(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    // 设置字符串并指定过期时间
    public void setStringWithExpire(String key, String value, long timeout) {
        redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    }

    // 获取字符串
    public String getString(String key) {
        return (String) redisTemplate.opsForValue().get(key);
    }

    // 自增
    public Long increment(String key) {
        return redisTemplate.opsForValue().increment(key);
    }

    // 增加指定值
    public Long incrementBy(String key, long delta) {
        return redisTemplate.opsForValue().increment(key, delta);
    }

    // 自减
    public Long decrement(String key) {
        return redisTemplate.opsForValue().decrement(key);
    }
}

List（列表）

List是简单的字符串列表，按照插入顺序排序。

基本操作

# 从左侧插入
LPUSH mylist "world"
(integer) 1
LPUSH mylist "hello"
(integer) 2

# 从右侧插入
RPUSH mylist "!"
(integer) 3

# 查看列表
LRANGE mylist 0 -1
1) "hello"
2) "world"
3) "!"

# 获取列表长度
LLEN mylist
(integer) 3

# 从左侧弹出
LPOP mylist
"hello"

# 从右侧弹出
RPOP mylist
"!"

# 根据索引获取元素
LINDEX mylist 0
"world"

# 设置指定索引的值
LSET mylist 0 "Redis"
OK

高级操作

# 移除指定元素
LREM mylist 1 "value"  # 移除1个值为"value"的元素
(integer) 1

# 保留指定范围
LTRIM mylist 0 2  # 只保留索引0-2的元素
OK

# 阻塞式弹出（用于消息队列）
BLPOP mylist 30  # 阻塞30秒等待元素
1) "mylist"
2) "element"

Java操作List

@Service
public class ListService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 从左侧插入
    public void leftPush(String key, Object value) {
        redisTemplate.opsForList().leftPush(key, value);
    }

    // 从右侧插入
    public void rightPush(String key, Object value) {
        redisTemplate.opsForList().rightPush(key, value);
    }

    // 从左侧弹出
    public Object leftPop(String key) {
        return redisTemplate.opsForList().leftPop(key);
    }

    // 获取列表范围
    public List<Object> range(String key, long start, long end) {
        return redisTemplate.opsForList().range(key, start, end);
    }

    // 获取列表长度
    public Long size(String key) {
        return redisTemplate.opsForList().size(key);
    }

    // 根据索引获取元素
    public Object index(String key, long index) {
        return redisTemplate.opsForList().index(key, index);
    }
}

Set（集合）

Set是无序的字符串集合，元素唯一，不允许重复。

基本操作

# 添加元素
SADD myset "apple"
(integer) 1
SADD myset "banana" "orange"
(integer) 2

# 查看所有元素
SMEMBERS myset
1) "apple"
2) "banana"
3) "orange"

# 判断元素是否存在
SISMEMBER myset "apple"
(integer) 1

# 获取集合元素数量
SCARD myset
(integer) 3

# 移除元素
SREM myset "banana"
(integer) 1

# 随机弹出元素
SPOP myset
"orange"

集合运算

# 创建两个集合
SADD set1 "a" "b" "c"
SADD set2 "b" "c" "d"

# 交集
SINTER set1 set2
1) "b"
2) "c"

# 并集
SUNION set1 set2
1) "a"
2) "b"
3) "c"
4) "d"

# 差集
SDIFF set1 set2
1) "a"

# 将交集存储到新集合
SINTERSTORE result set1 set2
(integer) 2

Java操作Set

@Service
public class SetService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 添加元素
    public Long add(String key, Object... values) {
        return redisTemplate.opsForSet().add(key, values);
    }

    // 获取所有元素
    public Set<Object> members(String key) {
        return redisTemplate.opsForSet().members(key);
    }

    // 判断元素是否存在
    public Boolean isMember(String key, Object value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }

    // 获取集合大小
    public Long size(String key) {
        return redisTemplate.opsForSet().size(key);
    }

    // 移除元素
    public Long remove(String key, Object... values) {
        return redisTemplate.opsForSet().remove(key, values);
    }

    // 求交集
    public Set<Object> intersect(String key, String otherKey) {
        return redisTemplate.opsForSet().intersect(key, otherKey);
    }
}

Hash（哈希）

Hash是键值对集合，适合存储对象。

基本操作

# 设置单个字段
HSET user:1 name "张三"
(integer) 1
HSET user:1 age 25
(integer) 1

# 设置多个字段
HMSET user:2 name "李四" age 30 city "北京"
OK

# 获取单个字段
HGET user:1 name
"张三"

# 获取多个字段
HMGET user:1 name age
1) "张三"
2) "25"

# 获取所有字段和值
HGETALL user:1
1) "name"
2) "张三"
3) "age"
4) "25"

# 获取所有字段名
HKEYS user:1
1) "name"
2) "age"

# 获取所有值
HVALS user:1
1) "张三"
2) "25"

# 删除字段
HDEL user:1 age
(integer) 1

# 判断字段是否存在
HEXISTS user:1 name
(integer) 1

# 字段数量
HLEN user:1
(integer) 1

数值操作

# 字段值增加
HINCRBY user:1 age 1
(integer) 26

# 浮点数增加
HINCRBYFLOAT user:1 score 0.5
"95.5"

Java操作Hash

@Service
public class HashService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 设置字段
    public void put(String key, String hashKey, Object value) {
        redisTemplate.opsForHash().put(key, hashKey, value);
    }

    // 设置多个字段
    public void putAll(String key, Map<String, Object> map) {
        redisTemplate.opsForHash().putAll(key, map);
    }

    // 获取字段值
    public Object get(String key, String hashKey) {
        return redisTemplate.opsForHash().get(key, hashKey);
    }

    // 获取所有字段和值
    public Map<Object, Object> entries(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    // 删除字段
    public Long delete(String key, Object... hashKeys) {
        return redisTemplate.opsForHash().delete(key, hashKeys);
    }

    // 判断字段是否存在
    public Boolean hasKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }

    // 字段值增加
    public Long increment(String key, String hashKey, long delta) {
        return redisTemplate.opsForHash().increment(key, hashKey, delta);
    }
}

ZSet（有序集合）

ZSet是有序集合，每个元素关联一个分数（score），按分数排序。

基本操作

# 添加元素
ZADD rank 100 "张三"
(integer) 1
ZADD rank 95 "李四" 98 "王五"
(integer) 2

# 查看所有元素（按分数升序）
ZRANGE rank 0 -1 WITHSCORES
1) "李四"
2) "95"
3) "王五"
4) "98"
5) "张三"
6) "100"

# 查看所有元素（按分数降序）
ZREVRANGE rank 0 -1 WITHSCORES
1) "张三"
2) "100"
3) "王五"
4) "98"
5) "李四"
6) "95"

# 获取元素分数
ZSCORE rank "张三"
"100"

# 获取元素排名（升序，从0开始）
ZRANK rank "张三"
(integer) 2

# 获取元素排名（降序）
ZREVRANK rank "张三"
(integer) 0

# 获取集合元素数量
ZCARD rank
(integer) 3

# 移除元素
ZREM rank "李四"
(integer) 1

范围查询

# 按分数范围查询
ZRANGEBYSCORE rank 90 100
1) "王五"
2) "张三"

# 按分数范围查询（降序）
ZREVRANGEBYSCORE rank 100 90
1) "张三"
2) "王五"

# 统计分数范围内的元素数量
ZCOUNT rank 90 100
(integer) 2

# 增加元素分数
ZINCRBY rank 5 "王五"
"103"

Java操作ZSet

@Service
public class ZSetService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 添加元素
    public Boolean add(String key, Object value, double score) {
        return redisTemplate.opsForZSet().add(key, value, score);
    }

    // 获取指定范围元素（升序）
    public Set<Object> range(String key, long start, long end) {
        return redisTemplate.opsForZSet().range(key, start, end);
    }

    // 获取指定范围元素（降序）
    public Set<Object> reverseRange(String key, long start, long end) {
        return redisTemplate.opsForZSet().reverseRange(key, start, end);
    }

    // 获取元素分数
    public Double score(String key, Object value) {
        return redisTemplate.opsForZSet().score(key, value);
    }

    // 获取元素排名
    public Long rank(String key, Object value) {
        return redisTemplate.opsForZSet().rank(key, value);
    }

    // 移除元素
    public Long remove(String key, Object... values) {
        return redisTemplate.opsForZSet().remove(key, values);
    }

    // 增加分数
    public Double incrementScore(String key, Object value, double delta) {
        return redisTemplate.opsForZSet().incrementScore(key, value, delta);
    }
}

本章小结

String：最基本的类型，适合缓存、计数器
List：有序列表，适合消息队列、时间线
Set：无序集合，适合标签、好友关系
Hash：键值对集合，适合存储对象
ZSet：有序集合，适合排行榜、延迟队列
Spring Boot提供了便捷的操作接口