redis快速入门及使用

Redis完整学习指南：从基础命令到Spring集成实战

本文全面介绍了Redis的基础知识、常用命令以及Spring Data Redis的集成使用方式，适合Java开发者快速上手Redis技术。

文章目录

Redis完整学习指南：从基础命令到Spring集成实战
- [🚀 Redis简介](#🚀 Redis简介)
- [📋 Redis基础命令](#📋 Redis基础命令)
- - 基础命令示例
- [🎯 Redis数据类型详解](#🎯 Redis数据类型详解)
- - [1. 字符串（String）类型](#1. 字符串（String）类型)
  - [2. 哈希（Hash）类型](#2. 哈希（Hash）类型)
  - [3. 列表（List）类型](#3. 列表（List）类型)
  - [4. 集合（Set）类型](#4. 集合（Set）类型)
  - [5. 有序集合（Zset）类型](#5. 有序集合（Zset）类型)
- [🔧 Spring Data Redis集成](#🔧 Spring Data Redis集成)
- - [为什么选择Spring Data Redis？](#为什么选择Spring Data Redis？)
  - 集成步骤
  - - [1. 添加Maven依赖](#1. 添加Maven依赖)
    - [2. 配置Redis数据源](#2. 配置Redis数据源)
    - [3. 创建Redis配置类](#3. 创建Redis配置类)
    - [4. 使用RedisTemplate操作Redis](#4. 使用RedisTemplate操作Redis)
  - [Spring Data Redis常用操作](#Spring Data Redis常用操作)
- [🎯 实战应用场景](#🎯 实战应用场景)
- - [1. 缓存系统](#1. 缓存系统)
  - [2. 分布式锁](#2. 分布式锁)
  - [3. 排行榜系统](#3. 排行榜系统)
- [📝 总结](#📝 总结)

🚀 Redis简介

Redis是一个基于内存的key-value结构数据库，是互联网技术领域使用最广泛的存储中间件。

核心特点：

⚡ 高性能：基于内存存储，读写速度极快
🔥 高并发：适合处理大量并发请求
💾 持久化：支持数据持久化到磁盘
🎯 丰富数据类型：支持字符串、哈希、列表、集合、有序集合等
🔧 功能丰富：支持事务、发布订阅、Lua脚本等

📋 Redis基础命令

Redis的通用命令是不分数据类型的，都可以使用的命令：

通用命令	说明	示例
`KEYS pattern`	查找所有符合给定模式的key	`KEYS *`
`EXISTS key`	检查给定key是否存在	`EXISTS name`
`TYPE key`	返回key所储存的值的类型	`TYPE mykey`
`DEL key`	删除指定的key	`DEL name name2`

基础命令示例

redis 复制代码

# 返回Redis中所有的key
KEYS *

# 返回Redis中所有以set开头的key
KEYS set*

# 检查name这个key是否存在
EXISTS name

# 删除name, name2
DEL name name2

🎯 Redis数据类型详解

1. 字符串（String）类型

字符串是Redis最基本的数据类型，可以存储文本、数字等。

常用命令	说明	应用场景
`SET key value`	设置指定key的值	缓存数据
`GET key`	获取指定key的值	读取缓存
`SETEX key seconds value`	设置key的值并指定过期时间	验证码、临时token
`SETNX key value`	只有在key不存在时设置key的值	分布式锁

示例代码：

redis 复制代码

# 设置name的值为work
SET name work

# 获取name的值
GET name

# 设置code的值为1234，且过期时间为30秒
SETEX code 30 1234

# 设置code的值为work，当code不存在时
SETNX code work

2. 哈希（Hash）类型

Hash是一个String类型的field和value的映射表，通常用于存储对象。

常用命令	说明	应用场景
`HSET key field value`	将哈希表key中的字段field设为value	存储用户信息
`HGET key field`	获取存储在哈希表中指定字段的值	获取用户属性
`HDEL key field`	删除存储在哈希表中的指定字段	删除用户属性
`HKEYS key`	获取哈希表中所有字段	获取所有字段名
`HVALS key`	获取哈希表中所有值	获取所有字段值

示例代码：

redis 复制代码

# 设置name中的字段liubei为刘备
HSET name liubei 刘备

# 获取name中的字段liubei的值
HGET name liubei

# 删除name中的字段liubei
HDEL name liubei

# 获取name中所有的字段
HKEYS name

# 获取name中所有的值
HVALS name

3. 列表（List）类型

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

常用命令	说明	应用场景
`LPUSH key value1 [value2]`	将一个或多个值插入到列表头部	消息队列
`LRANGE key start stop`	获取列表指定范围内的元素	获取消息列表
`RPOP key`	移除并获取列表最后一个元素	消费消息
`LLEN key`	获取列表长度	统计消息数量

示例代码：

redis 复制代码

# 将a，b，c插入到mylist列表头部
LPUSH mylist a b c

# 获取mylist全部元素
LRANGE mylist 0 -1

# 移除并获取mylist最后一个元素
RPOP mylist

# 获取mylist列表长度
LLEN mylist

4. 集合（Set）类型

Set是string类型的无序集合，集合成员是唯一的。

常用命令	说明	应用场景
`SADD key member1 [member2]`	向集合添加一个或多个成员	用户标签
`SMEMBERS key`	返回集合中的所有成员	获取所有标签
`SCARD key`	获取集合的成员数	统计标签数量
`SINTER key1 [key2]`	返回给定所有集合的交集	共同好友
`SUNION key1 [key2]`	返回所有给定集合的并集	合并标签
`SREM key member1 [member2]`	删除集合中一个或多个成员	移除标签

示例代码：

redis 复制代码

# 向name添加liubei、guanyu、zhangfei
SADD name liubei guanyu zhangfei

# 返回name中的所有成员
SMEMBERS name

# 获取name中的成员数
SCARD name

# 返回name与n集合的交集
SINTER name n

# 返回name与n集合的并集
SUNION name n

# 删除name中liubei，guanyu
SREM name liubei guanyu

5. 有序集合（Zset）类型

有序集合是string类型元素的集合，每个元素都会关联一个double类型的分数。

常用命令	说明	应用场景
`ZADD key score1 member1 [score2 member2]`	向有序集合添加一个或多个成员	排行榜
`ZRANGE key start stop [WITHSCORES]`	通过索引区间返回有序集合中指定区间内的成员	获取排行榜
`ZINCRBY key increment member`	有序集合中对指定成员的分数加上增量	增加分数
`ZREM key member [member ...]`	移除有序集合中的一个或多个成员	移除成员

示例代码：

redis 复制代码

# 向score有序集合中添加zhangsan lisi wangwu，对应分数为30,40,50
ZADD score 30 zhangsan 40 lisi 50 wangwu

# 返回score中的所有成员
ZRANGE score 0 -1

# 在score集合中修改zhangsan的分数，使其上涨10分
ZINCRBY score 10 zhangsan

# 在score集合中移除zhangsan
ZREM score zhangsan

🔧 Spring Data Redis集成

为什么选择Spring Data Redis？

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

Jedis：老牌客户端，功能完整
Lettuce：基于Netty，性能更好
Spring Data Redis：Spring生态，集成度高

由于Spring Data Redis是Spring的一部分，对Redis底层开发包进行高度封装，所以在Spring项目中使用Spring Data Redis可以大大简化操作。

集成步骤

1. 添加Maven依赖

xml 复制代码

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2. 配置Redis数据源

yaml 复制代码

spring:
  redis:
    host: localhost    # Redis服务器地址
    port: 6379        # Redis端口号
    password: 密码     # Redis密码（如果有）
    database: 0       # 使用的数据库编号
    timeout: 5000ms   # 连接超时时间
    lettuce:
      pool:
        max-active: 8   # 最大连接数
        max-idle: 8     # 最大空闲连接数
        min-idle: 0     # 最小空闲连接数

3. 创建Redis配置类

java 复制代码

@Configuration
@Slf4j
public class RedisConfiguration {
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        log.info("开始创建Redis模板对象");
        
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        
        // 设置Redis连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        
        // 设置key的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        
        // 设置value的序列化器
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        
        // 初始化RedisTemplate
        redisTemplate.afterPropertiesSet();
        
        return redisTemplate;
    }
}

4. 使用RedisTemplate操作Redis

java 复制代码

@SpringBootTest
public class SpringDataRedisTest {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Test
    public void testRedisTemplate() {
        System.out.println(redisTemplate);
        
        // 获取各种操作对象
        ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
        HashOperations<String, Object, Object> hashOperations = redisTemplate.opsForHash();
        ListOperations<String, Object> listOperations = redisTemplate.opsForList();
        SetOperations<String, Object> setOperations = redisTemplate.opsForSet();
        ZSetOperations<String, Object> zSetOperations = redisTemplate.opsForZSet();
    }
}

Spring Data Redis常用操作

字符串操作

Spring Data Redis实现	Redis命令	说明
`redisTemplate.opsForValue().set("city", "北京")`	`SET city 北京`	设置指定key的值
`redisTemplate.opsForValue().get("city")`	`GET city`	获取指定key的值
`redisTemplate.opsForValue().set("code", "1234", 30, TimeUnit.SECONDS)`	`SETEX code 30 1234`	设置key的值并指定过期时间
`redisTemplate.opsForValue().setIfAbsent("lock", "1")`	`SETNX lock 1`	只有在key不存在时设置key的值

完整示例：

java 复制代码

@Test
public void testString() {
    // 基本操作
    redisTemplate.opsForValue().set("city", "北京");
    String city = (String) redisTemplate.opsForValue().get("city");
    System.out.println(city);
    
    // 设置过期时间
    redisTemplate.opsForValue().set("code", "1234", 30, TimeUnit.SECONDS);
    
    // 分布式锁
    redisTemplate.opsForValue().setIfAbsent("lock", "1");
}

哈希操作

Spring Data Redis实现	Redis命令	说明
`hashOperations.put("100", "name", "tom")`	`HSET 100 name tom`	将哈希表key中的字段field设为value
`hashOperations.get("100", "name")`	`HGET 100 name`	获取存储在哈希表中指定字段的值
`hashOperations.keys("100")`	`HKEYS 100`	获取哈希表中所有字段
`hashOperations.values("100")`	`HVALS 100`	获取哈希表中所有值
`hashOperations.delete("100", "age")`	`HDEL 100 age`	删除哈希表key中的一个或多个指定字段

完整示例：

java 复制代码

@Test
public void testHash() {
    HashOperations<String, Object, Object> hashOperations = redisTemplate.opsForHash();
    
    // 存储用户信息
    hashOperations.put("100", "name", "tom");
    hashOperations.put("100", "age", "20");
    
    // 获取用户姓名
    String name = (String) hashOperations.get("100", "name");
    System.out.println(name);
    
    // 获取所有字段
    Set<Object> keys = hashOperations.keys("100");
    System.out.println(keys);
    
    // 获取所有值
    List<Object> values = hashOperations.values("100");
    System.out.println(values);
    
    // 删除字段
    hashOperations.delete("100", "age");
}

列表操作

Spring Data Redis实现	Redis命令	说明
`listOperations.leftPush("mylist", "d")`	`LPUSH mylist d`	将一个值插入到列表头部
`listOperations.leftPushAll("mylist", "a", "b", "c")`	`LPUSH mylist a b c`	将多个值插入到列表头部
`listOperations.range("mylist", 0, -1)`	`LRANGE mylist 0 -1`	获取列表指定范围内的元素
`listOperations.rightPop("mylist")`	`RPOP mylist`	移除并获取列表最后一个元素
`listOperations.size("mylist")`	`LLEN mylist`	获取列表长度

完整示例：

java 复制代码

@Test
public void testList() {
    ListOperations<String, Object> listOperations = redisTemplate.opsForList();
    
    // 添加元素到列表
    listOperations.leftPushAll("mylist", "a", "b", "c");
    listOperations.leftPush("mylist", "d");
    
    // 获取所有元素
    List<Object> mylist = listOperations.range("mylist", 0, -1);
    System.out.println(mylist);
    
    // 移除最后一个元素
    listOperations.rightPop("mylist");
    
    // 获取列表长度
    Long size = listOperations.size("mylist");
    System.out.println(size);
}

集合操作

Spring Data Redis实现	Redis命令	说明
`setOperations.add("set1", "a", "b", "c", "d")`	`SADD set1 a b c d`	向集合添加一个或多个成员
`setOperations.members("set1")`	`SMEMBERS set1`	返回集合中的所有成员
`setOperations.size("set1")`	`SCARD set1`	获取集合的成员数
`setOperations.intersect("set1", "set2")`	`SINTER set1 set2`	返回给定所有集合的交集
`setOperations.union("set1", "set2")`	`SUNION set1 set2`	返回所有给定集合的并集
`setOperations.remove("set1", "a", "b")`	`SREM set1 a b`	移除集合中一个或多个成员

完整示例：

java 复制代码

@Test
public void testSet() {
    SetOperations<String, Object> setOperations = redisTemplate.opsForSet();
    
    // 添加集合元素
    setOperations.add("set1", "a", "b", "c", "d");
    setOperations.add("set2", "a", "b", "x", "y");
    
    // 获取所有成员
    Set<Object> members = setOperations.members("set1");
    System.out.println(members);
    
    // 获取成员数量
    Long size = setOperations.size("set1");
    System.out.println(size);
    
    // 获取交集
    Set<Object> intersect = setOperations.intersect("set1", "set2");
    System.out.println(intersect);
    
    // 获取并集
    Set<Object> union = setOperations.union("set1", "set2");
    System.out.println(union);
    
    // 移除成员
    setOperations.remove("set1", "a", "b");
}

有序集合操作

Spring Data Redis实现	Redis命令	说明
`zSetOperations.add("zset1", "a", 10)`	`ZADD zset1 10 a`	向有序集合添加一个成员，并指定分数
`zSetOperations.range("zset1", 0, -1)`	`ZRANGE zset1 0 -1`	通过索引区间返回有序集合中指定区间内的成员
`zSetOperations.incrementScore("zset1", "c", 10)`	`ZINCRBY zset1 10 c`	有序集合中对指定成员的分数加上增量
`zSetOperations.remove("zset1", "a", "b")`	`ZREM zset1 a b`	移除有序集合中的一个或多个成员

完整示例：

java 复制代码

@Test
public void testZset() {
    ZSetOperations<String, Object> zSetOperations = redisTemplate.opsForZSet();
    
    // 添加有序集合元素
    zSetOperations.add("zset1", "a", 10);
    zSetOperations.add("zset1", "b", 12);
    zSetOperations.add("zset1", "c", 9);
    
    // 获取所有成员
    Set<Object> zset1 = zSetOperations.range("zset1", 0, -1);
    System.out.println(zset1);
    
    // 增加分数
    zSetOperations.incrementScore("zset1", "c", 10);
    
    // 移除成员
    zSetOperations.remove("zset1", "a", "b");
}

通用操作

Spring Data Redis实现	Redis命令	说明
`redisTemplate.keys("*")`	`KEYS *`	查找所有符合给定模式的key
`redisTemplate.hasKey("name")`	`EXISTS name`	检查给定key是否存在
`redisTemplate.type(key)`	`TYPE key`	返回key所储存的值的类型
`redisTemplate.delete("mylist")`	`DEL mylist`	删除指定的key

完整示例：

java 复制代码

@Test
public void testCommon() {
    // 获取所有key
    Set<String> keys = redisTemplate.keys("*");
    System.out.println(keys);
    
    // 检查key是否存在
    Boolean name = redisTemplate.hasKey("name");
    Boolean set1 = redisTemplate.hasKey("set1");
    
    // 获取key的类型
    for (String key : keys) {
        DataType type = redisTemplate.type(key);
        System.out.println(key + " -> " + type.name());
    }
    
    // 删除key
    redisTemplate.delete("mylist");
}

🎯 实战应用场景

1. 缓存系统

java 复制代码

@Service
public class UserService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    public User getUserById(Long id) {
        // 先从缓存获取
        String key = "user:" + id;
        User user = (User) redisTemplate.opsForValue().get(key);
        
        if (user == null) {
            // 缓存未命中，从数据库查询
            user = userMapper.selectById(id);
            if (user != null) {
                // 存入缓存，设置过期时间
                redisTemplate.opsForValue().set(key, user, 30, TimeUnit.MINUTES);
            }
        }
        
        return user;
    }
}

2. 分布式锁

java 复制代码

@Service
public class OrderService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    public boolean createOrder(Long userId, Long productId) {
        String lockKey = "order:lock:" + userId;
        
        // 尝试获取分布式锁
        Boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 10, TimeUnit.SECONDS);
        
        if (locked) {
            try {
                // 执行业务逻辑
                return processOrder(userId, productId);
            } finally {
                // 释放锁
                redisTemplate.delete(lockKey);
            }
        }
        
        return false;
    }
}

3. 排行榜系统

java 复制代码

@Service
public class RankingService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    public void addScore(String userId, double score) {
        redisTemplate.opsForZSet().add("ranking", userId, score);
    }
    
    public List<String> getTopUsers(int count) {
        Set<Object> topUsers = redisTemplate.opsForZSet().reverseRange("ranking", 0, count - 1);
        return topUsers.stream().map(Object::toString).collect(Collectors.toList());
    }
    
    public Long getUserRank(String userId) {
        return redisTemplate.opsForZSet().reverseRank("ranking", userId);
    }
}

📝 总结

通过本文的学习，我们掌握了：

Redis基础概念：了解Redis的特点和应用场景
Redis命令操作：掌握各种数据类型的常用命令
Spring Data Redis集成：学会在Spring项目中集成Redis
实战应用：理解Redis在缓存、分布式锁、排行榜等场景的应用

Redis作为高性能的内存数据库，在现代Web应用中扮演着重要角色。掌握Redis的使用，对于提升系统性能和用户体验具有重要意义。

💡 提示： 在实际项目中，建议根据业务需求选择合适的Redis数据类型，并注意合理设置过期时间，避免内存泄漏。