Redis基础语法教程与Spring Data Redis使用说明

1 Redis简介

Redis是一个用ANSI C编写的基于内存的key-value结构数据库。

特点：

• 基于内存存储，读写性能高
• 适合存储热点数据（热点商品、资讯、新闻）
• 企业应用广泛

---

2 安装与启动

官网：https://redis.io
中文网：https://www.redis.net.cn/

Mac启动Redis服务端：

redis-server

连接到Redis实例：

redis-cli

停止Redis实例：

redis-cli shutdown

可视化操作工具：Another Redis Desktop Manager

---

3 Redis数据类型

Redis存储的是key-value结构的数据，其中key是字符串类型，value有5种常用的数据类型：

1. 字符串（String）：普通字符串，Redis中最简单的数据类型。
2. 哈希（Hash）：又称散列，每个元素分为若干字段field_i与其对应的值value_i，类似于Java中的HashMap。
3. 列表（List）：按照插入顺序排序，可以有重复元素，类似于Java中的LinkedList。
4. 集合（Set）：无序集合，无重复元素，类似于Java中的HashSet。
5. 有序集合（Sorted Set / Zset）：集合中每个元素关联一个分数（score），根据分数升序排序，没有重复元素

---

4 常用的Redis命令

与SQL语句类似，Redis命令不区分大小写。以下介绍部分实用的操作命令：

4.1 字符串（String）操作命令

简单的键值操作

1. SET key value：设置指定key的值
2. GET key：获取指定key的值
3. SETEX key seconds value：设置指定key的值，并将key的过期（Expire）时间设为seconds秒
4. SETNX key value：只有在key不存在时设置key的值

4.2 哈希（Hash）操作命令

Redis的Hash是一个String类型的field和value的映射表，特别适合用于存储对象

1. HSET key field value：将哈希表key中的字段field的值设为value
2. HGET key field：获取存储在哈希表中指定字段的值
3. HDEL key field：删除存储在哈希表中的指定字段
4. HKEYS key：获取哈希表中所有字段
5. HVALS key：获取哈希表中所有值

4.3 列表（List）操作命令

Redis列表是简单的字符串列表，按照插入顺序排序（队列）

1. LPUSH key value [value ...]：将一个或多个值插入到列表头部（左；尾插则为RPUSH）
2. LRANGE key start stop：获取列表指定范围内的元素（索引从头到尾递增）
   • 含两端
   • 头部的开始元素索引为0；可使用-1等倒序索引，参考python
3. RPOP key：移除并获取列表最后一个元素（右；头删则为LPOP）
4. LLEN key：获取列表长度

4.4 集合（Set）操作命令

Redis的Set是String类型的无序集合。集合成员是唯一的，集合中不能出现重复的数据

1. SADD key member [member ...]：向集合添加一个或多个成员
2. SMEMBERS key：返回集合中的所有成员
3. SCARD key：获取集合的成员数（Card，基数）
4. SINTER key1 [key2 ...]：返回给定所有集合的交集（Interaction）
5. SUNION key1 [key2 ...]：返回所有给定集合的并集（Union）
6. SREM key member [member ...]：删除（Remove）集合中一个或多个成员

4.5 有序集合（Zset）操作命令

Redis有序集合（Zset）是String类型元素的集合，且不允许有重复成员。每个元素都会关联一个double类型的分数

1. ZADD key score1 member1 [score2 member2 ..]：向有序集合添加一个或多个成员
2. ZRANGE key start stop [WITHSCORES]：通过索引区间返回有序集合中指定区间内的成员
   • WITHSCORES：将成员的分数一并返回
3. ZINCRBY key increment member：有序集合中对指定成员的分数加上增量increment
4. ZREM key member [member ...]：移除有序集合中的一个或多个成员

4.6 通用命令

以下通用命令各数据类型均可使用

1. KEYS pattern：查找所有符合给定模式pattern的key
2. EXISTS key：检查给定key是否存在
3. TYPE key：返回key所储存的值的类型
4. DEL key：若key存在，则删除key

---

5 Spring Data Redis

Redis的Java客户端有很多，常用的有如下几种：

• Jedis
• Lettuce
• Spring Data Redis：Spring的一部分，对Redis底层开发包进行了高度封装。在Spring项目中常使用Spring Data Redis来简化操作。

5.1 开启步骤

使用Spring Data Redis的操作步骤：

1. 导入Spring Data Redis的maven坐标
2. 配置Redis数据源
3. 编写配置类，创建RedisTemplate对象
4. 通过Redis Template对象操作Redis

@Configuration
@Slf4j
public class RedisConfiguration {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        log.info("开始创建Redis模版对象...");
        RedisTemplate redisTemplate = new RedisTemplate();
        // 设置Redis连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 设置Redis key序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

@Autowired
private RedisTemplate redisTemplate;

@Test
public void testRedisTemplate() {
    System.out.println(redisTemplate);
    // 获取各类Redis数据的操作对象
    ValueOperations valueOperations = redisTemplate.opsForValue();
    HashOperations hashOperations = redisTemplate.opsForHash();
    ListOperations listOperations = redisTemplate.opsForList();
    SetOperations setOperations = redisTemplate.opsForSet();
    ZSetOperations zSetOperations = redisTemplate.opsForZSet();
}

5.2 使用方法

@SpringBootTest
public class SpringDataRedisTest {
    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 操作字符串类数据
     */
    @Test
    public void testString() {
        // SET GET
        redisTemplate.opsForValue().set("name", "yohane");
        String name = (String) redisTemplate.opsForValue().get("name");
        System.out.println(name);
        // SETEX
        redisTemplate.opsForValue().set("code", "3306", 1234, TimeUnit.SECONDS);
        // SETNX
        redisTemplate.opsForValue().setIfAbsent("lock", "1");
        redisTemplate.opsForValue().setIfAbsent("lock", "2");   // failed
    }

    /**
     * 操作哈希类数据
     */
    @Test
    public void testHash() {
        HashOperations hashOperations = redisTemplate.opsForHash();
        // HSET HGET
        hashOperations.put("user:1", "name", "teresa");
        hashOperations.put("user:1", "age", "17");
        String name = (String) hashOperations.get("user:1", "name");
        System.out.println(name);
        // HKEYS
        Set keys = hashOperations.keys("user:1");
        System.out.println(keys);
        // HVALS
        List values = hashOperations.values("user:1");
        System.out.println(values);
        // HDEL
        hashOperations.delete("user:1", "age");
    }

    /**
     * 操作列表类数据
     */
    @Test
    public void testList() {
        ListOperations listOperations = redisTemplate.opsForList();
        // LPUSH
        listOperations.leftPush("mynumqueue", "1");
        listOperations.leftPushAll("mynumqueue", "2", "3", "4");
        // LRANGE
        List<String> mylist = listOperations.range("mynumqueue", 0, 3);
        System.out.println(mylist);
        // RPOP
        Object pop = listOperations.rightPop("mynumqueue");
        System.out.println(pop);
        // LLEN
        Long size = listOperations.size("mynumqueue");
        System.out.println(size);
    }

    /**
     * 操作集合类数据
     */
    @Test
    public void testSet() {
        SetOperations setOperations = redisTemplate.opsForSet();
        // SADD
        setOperations.add("myset1", "1", "2", "3", "4", "5");
        setOperations.add("myset2", "4", "5", "6", "7", "8");
        // SMEMBERS
        Set<String> myset1 = setOperations.members("myset1");
        System.out.println(myset1);
        // SCARD
        Long size = setOperations.size("myset1");
        System.out.println(size);
        // SINTER
        Set<String> intersect = setOperations.intersect("myset1", "myset2");
        System.out.println(intersect);
        // SUNION
        Set<String> union = setOperations.union("myset1", "myset2");
        System.out.println(union);
        // SREM
        setOperations.remove("myset1", "1", "2");
    }

    /**
     * 操作有序集合类数据
     */
    @Test
    public void testZSet() {
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
        // ZADD
        zSetOperations.add("myzset", "1", 10.1);
        zSetOperations.add("myzset", "2", 10.5);
        zSetOperations.add("myzset", "3", 10.3);
        zSetOperations.add("myzset", "4", 10.2);
        // ZRANGE
        Set<String> myzset = zSetOperations.range("myzset", 0, 3);
        System.out.println(myzset);
        var myzsetWithScore = zSetOperations.rangeWithScores("myzset", 0, 3);
        System.out.println(myzsetWithScore);
        // ZINCRBY
        zSetOperations.incrementScore("myzset", "1", 1);
        // ZREM
        zSetOperations.remove("myzset", "1");
    }

    /**
     * 通用命令操作
     */
    @Test
    public void testCommon() {
        // KEYS
        Set<String> keys = redisTemplate.keys("*");
        System.out.println(keys);
        // EXISTS
        System.out.println(redisTemplate.hasKey("myset1"));
        System.out.println(redisTemplate.hasKey("holyjitt"));
        // TYPE
        for (Object key : keys) {
            DataType type = redisTemplate.type(key);
            System.out.println(type.name());
        }
        // DEL
        redisTemplate.delete("myset1");
    }
}