Redis入门与核心概念

前置知识

在开始本教程之前，建议您具备以下基础知识：

• Java 基础语法
• Spring Boot 基础
• 基本的数据库概念
• Docker 基础知识（可选）

什么是 Redis？

Redis (Remote Dictionary Server) 是一个开源的、基于内存的数据结构存储系统，可以用作数据库、缓存和消息中间件。Redis 支持多种数据类型，如字符串、哈希表、列表、集合、有序集合等。

Redis 的主要特点

• 高性能：基于内存操作，读写性能极高
• 丰富的数据类型：支持多种数据结构
• 原子操作：所有操作都是原子性的
• 持久化：支持数据持久化到磁盘
• 主从复制：支持主从复制和高可用
• 集群：支持分布式集群部署

Redis 核心数据类型

1. String（字符串）

String 是 Redis 最基本的数据类型，可以存储文本、整数或二进制数据。

// 设置字符串
stringRedisTemplate.opsForValue().set("key", "value");

// 获取字符串
String value = stringRedisTemplate.opsForValue().get("key");

// 设置过期时间
stringRedisTemplate.opsForValue().set("key-with-ttl", "value", 60, TimeUnit.SECONDS);

// 原子递增
Long newValue = stringRedisTemplate.opsForValue().increment("counter");

2. List（列表）

List 是简单的字符串列表，按照插入顺序排序，可以添加元素到头部或尾部。

// 从左侧添加元素
stringRedisTemplate.opsForList().leftPush("list", "value1");
stringRedisTemplate.opsForList().leftPush("list", "value2");

// 从右侧添加元素
stringRedisTemplate.opsForList().rightPush("list", "value3");

// 获取列表范围
List<String> values = stringRedisTemplate.opsForList().range("list", 0, -1);

// 从左侧弹出元素
String value = stringRedisTemplate.opsForList().leftPop("list");

3. Set（集合）

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

// 添加元素到集合
stringRedisTemplate.opsForSet().add("set", "value1", "value2", "value3");

// 获取集合所有成员
Set<String> members = stringRedisTemplate.opsForSet().members("set");

// 判断元素是否在集合中
Boolean isMember = stringRedisTemplate.opsForSet().isMember("set", "value1");

// 获取两个集合的交集
Set<String> intersection = stringRedisTemplate.opsForSet().intersect("set1", "set2");

4. Sorted Set（有序集合）

Sorted Set 是有序的字符串集合，每个元素关联一个分数，用于排序。

// 添加元素到有序集合
stringRedisTemplate.opsForZSet().add("zset", "value1", 1.0);
stringRedisTemplate.opsForZSet().add("zset", "value2", 2.0);
stringRedisTemplate.opsForZSet().add("zset", "value3", 3.0);

// 获取有序集合范围（按分数升序）
Set<String> range = stringRedisTemplate.opsForZSet().range("zset", 0, -1);

// 获取元素分数
Double score = stringRedisTemplate.opsForZSet().score("zset", "value1");

// 获取元素排名（从0开始）
Long rank = stringRedisTemplate.opsForZSet().rank("zset", "value1");

5. Hash（哈希）

Hash 是字符串字段和字符串值之间的映射，适合存储对象。

// 设置哈希字段
stringRedisTemplate.opsForHash().put("user:1", "name", "John");
stringRedisTemplate.opsForHash().put("user:1", "email", "john@example.com");

// 获取哈希字段
String name = (String) stringRedisTemplate.opsForHash().get("user:1", "name");

// 获取所有字段和值
Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:1");

// 判断字段是否存在
Boolean hasKey = stringRedisTemplate.opsForHash().hasKey("user:1", "name");

环境搭建

1. 使用 Docker 安装 Redis

# 拉取 Redis 镜像
docker pull redis:latest

# 启动 Redis 容器
docker run --name redis -p 6379:6379 -d redis

2. Spring Boot 集成 Redis

在 pom.xml 中添加 Redis 依赖：

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

在 application.properties 或 application.yml 中配置 Redis：

spring:
  redis:
    host: localhost
    port: 6379
    # 如果有密码，取消下面的注释
    # password: your-password
    # 连接超时时间（毫秒）
    timeout: 2000
    # 连接池配置
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: -1ms

3. Redis 配置类

Redis配置类完整代码

@Configuration
public class RedisConfig {
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        
        // 使用 Jackson2JsonRedisSerializer 序列化和反序列化 redis 的 value 值
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, 
                                    ObjectMapper.DefaultTyping.NON_FINAL, 
                                    JsonTypeInfo.As.PROPERTY);
        serializer.setObjectMapper(mapper);
        
        // 使用 StringRedisSerializer 序列化和反序列化 redis 的 key 值
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setValueSerializer(serializer);
        
        // Hash 的 key 和 value 序列化
        template.setHashKeySerializer(stringRedisSerializer);
        template.setHashValueSerializer(serializer);
        
        template.afterPropertiesSet();
        return template;
    }
    
    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(factory);
        return stringRedisTemplate;
    }
}

## 快速开始

### 1. 创建 Redis 工具类

```java
@Component
@Slf4j
public class RedisUtil {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 设置缓存
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            log.error("设置缓存异常", e);
            return false;
        }
    }
    
    /**
     * 设置缓存并设置过期时间
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            log.error("设置缓存异常", e);
            return false;
        }
    }
    
    /**
     * 获取缓存
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }
    
    /**
     * 删除缓存
     */
    public boolean delete(String key) {
        return Boolean.TRUE.equals(redisTemplate.delete(key));
    }
    
    /**
     * 判断key是否存在
     */
    public boolean hasKey(String key) {
        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
    }
}

2. 使用示例

@RestController
@RequestMapping("/redis")
@Slf4j
public class RedisController {
    
    @Autowired
    private RedisUtil redisUtil;
    
    @GetMapping("/set")
    public String set(@RequestParam String key, @RequestParam String value) {
        boolean result = redisUtil.set(key, value);
        return result ? "设置成功" : "设置失败";
    }
    
    @GetMapping("/get")
    public Object get(@RequestParam String key) {
        return redisUtil.get(key);
    }
    
    @GetMapping("/delete")
    public String delete(@RequestParam String key) {
        boolean result = redisUtil.delete(key);
        return result ? "删除成功" : "删除失败";
    }
}

最佳实践

1. 键命名规范

建议

1. 使用冒号分隔不同部分，如 user:1:profile
2. 避免使用过长的键名
3. 保持命名一致性

2. 过期时间设置

// 设置绝对过期时间
redisTemplate.opsForValue().set("key", "value", 60, TimeUnit.SECONDS);

// 设置相对过期时间
redisTemplate.expire("key", 60, TimeUnit.SECONDS);

// 获取剩余过期时间
Long ttl = redisTemplate.getExpire("key");

3. 性能优化

注意事项

1. 避免存储大对象
2. 使用批量操作减少网络开销
3. 合理设置连接池参数
4. 使用 Pipeline 批量处理命令

// 使用 Pipeline 批量处理
List<Object> results = redisTemplate.executePipelined(new RedisCallback<Object>() {
    @Override
    public Object doInRedis(RedisConnection connection) throws DataAccessException {
        StringRedisConnection stringRedisConn = (StringRedisConnection) connection;
        
        for (int i = 0; i < 1000; i++) {
            stringRedisConn.set("key" + i, "value" + i);
        }
        
        return null;
    }
});

总结

本文详细介绍了 Redis 的基础知识和核心数据类型：

1. ✅ Redis 简介：Redis 的概念和主要特点
2. ✅ 核心数据类型：String、List、Set、Sorted Set、Hash
3. ✅ 环境搭建：Docker 安装和 Spring Boot 集成
4. ✅ 快速开始：Redis 工具类和使用示例
5. ✅ 最佳实践：键命名规范、过期时间设置和性能优化

下一步学习

• 学习 Redis 的高级特性（事务、发布订阅、Lua 脚本）
• 了解 Redis 的持久化机制（RDB 和 AOF）
• 探索 Redis 的集群和高可用方案

希望这篇文章能帮助您快速入门 Redis！如果您有任何问题，欢迎在评论区讨论。