🔄Update: 生成学习框架(LLM)

LEARNING_GUIDE.md

@@ -0,0 +1,145 @@
+# Redis 学习指南
+
+## 1. Redis基础概念
+
+### 什么是Redis？
+Redis是一个开源的内存数据结构存储系统，可以用作数据库、缓存和消息中间件。它支持多种数据结构，包括字符串、哈希、列表、集合、有序集合等。
+
+### Redis的主要特点
+- **高性能**：基于内存存储，读写速度极快
+- **丰富的数据结构**：支持多种数据类型和操作
+- **持久化**：支持RDB和AOF两种持久化方式
+- **原子性**：单个操作是原子性的
+- **多种模式**：支持主从复制、集群等模式
+
+## 2. 数据类型详解
+
+### 2.1 字符串(String)
+字符串是Redis最基础的数据类型，可以存储字符串、数字或二进制数据。
+
+#### 常用命令：
+- `SET key value` - 设置键值对
+- `GET key` - 获取键的值
+- `INCR key` - 对键的值进行自增
+- `DECR key` - 对键的值进行自减
+
+### 2.2 列表(List)
+列表是简单的字符串列表，按照插入顺序排序。可以向列表两端添加元素。
+
+#### 常用命令：
+- `LPUSH key value` - 在列表左侧插入元素
+- `RPUSH key value` - 在列表右侧插入元素
+- `LPOP key` - 从列表左侧弹出元素
+- `RPOP key` - 从列表右侧弹出元素
+- `LRANGE key start end` - 获取列表指定范围的元素
+
+### 2.3 集合(Set)
+集合是字符串类型的无序集合，集合中的元素是唯一的。
+
+#### 常用命令：
+- `SADD key member` - 向集合添加元素
+- `SREM key member` - 从集合中删除元素
+- `SMEMBERS key` - 获取集合中的所有元素
+- `SISMEMBER key member` - 判断元素是否在集合中
+- `SINTER key1 key2` - 获取两个集合的交集
+- `SUNION key1 key2` - 获取两个集合的并集
+
+### 2.4 哈希(Hash)
+哈希是键值对集合，适合存储对象。
+
+#### 常用命令：
+- `HSET key field value` - 设置哈希字段的值
+- `HGET key field` - 获取哈希字段的值
+- `HGETALL key` - 获取哈希中的所有字段和值
+- `HDEL key field` - 删除哈希字段
+
+### 2.5 有序集合(Sorted Set)
+有序集合与集合类似，但每个元素都关联一个分数，用于排序。
+
+#### 常用命令：
+- `ZADD key score member` - 向有序集合添加元素
+- `ZSCORE key member` - 获取有序集合中元素的分数
+- `ZRANGE key start end` - 获取有序集合指定范围的元素
+- `ZREVRANGE key start end` - 获取有序集合指定范围的元素（逆序）
+- `ZREM key member` - 删除有序集合中的元素
+
+## 3. 高级特性
+
+### 3.1 过期时间
+可以为键设置过期时间，Redis会自动删除过期的键。
+
+#### 常用命令：
+- `EXPIRE key seconds` - 设置键的过期时间
+- `TTL key` - 获取键的剩余生存时间
+- `PERSIST key` - 移除键的过期时间
+
+### 3.2 事务
+Redis事务允许将多个命令作为一个原子操作执行。
+
+#### 常用命令：
+- `MULTI` - 开始事务
+- `EXEC` - 执行事务
+- `DISCARD` - 取消事务
+
+### 3.3 发布/订阅
+Redis支持发布/订阅模式，用于消息传递。
+
+#### 常用命令：
+- `SUBSCRIBE channel` - 订阅频道
+- `PUBLISH channel message` - 发布消息到频道
+
+### 3.4 持久化
+Redis支持两种持久化方式：
+- RDB：在指定时间间隔内创建数据快照
+- AOF：记录每个写操作命令
+
+## 4. 实际应用场景
+
+### 4.1 缓存
+使用Redis作为缓存层，提高应用性能。
+
+### 4.2 会话存储
+存储用户会话信息，实现分布式会话管理。
+
+### 4.3 计数器
+使用Redis的原子操作实现计数器功能。
+
+### 4.4 消息队列
+利用列表实现简单的消息队列。
+
+### 4.5 排行榜
+使用有序集合实现排行榜功能。
+
+## 5. 学习建议
+
+### 5.1 从基础开始
+- 先掌握各种数据类型的使用
+- 理解Redis的内存模型和性能特点
+- 学会使用Redis命令行工具
+
+### 5.2 实践为主
+- 每学一个概念就动手实践
+- 编写测试用例验证功能
+- 尝试在实际项目中应用
+
+### 5.3 深入理解
+- 学习Redis的内部实现机制
+- 理解不同数据结构的适用场景
+- 掌握性能优化技巧
+
+## 6. 常见问题
+
+### 6.1 内存管理
+- Redis是内存数据库，要注意内存使用情况
+- 合理设置过期时间避免内存泄漏
+- 使用Redis内存优化技巧
+
+### 6.2 性能优化
+- 合理使用连接池
+- 避免大键和大值
+- 使用Pipeline批量操作
+
+### 6.3 数据安全
+- 配置密码保护
+- 启用持久化机制
+- 定期备份数据

LEARNING_PLAN.md

@@ -0,0 +1,73 @@
+# Redis 学习计划
+
+## 项目概述
+本项目旨在帮助您系统地学习Redis，从基础概念到高级应用。通过实践练习和测试样例，您将掌握Redis的核心功能和使用方法。
+
+## 学习阶段
+
+### 第1阶段：基础概念和环境搭建
+- [ ] 了解Redis是什么以及它的特点
+- [ ] 安装和配置Redis服务器
+- [ ] 理解Redis的数据类型和基本操作
+- [ ] 配置Spring Boot项目以使用Redis
+
+### 第2阶段：核心数据类型操作
+- [ ] 字符串(String)操作
+- [ ] 列表(List)操作
+- [ ] 集合(Set)操作
+- [ ] 哈希(Hash)操作
+- [ ] 有序集合(Sorted Set)操作
+
+### 第3阶段：高级功能和应用
+- [ ] 过期时间(TTL)和键空间通知
+- [ ] 事务和管道
+- [ ] 发布/订阅模式
+- [ ] 持久化机制
+- [ ] 集群和主从复制
+
+### 第4阶段：实际应用和测试
+- [ ] 实现缓存策略
+- [ ] 实现计数器和排行榜
+- [ ] 实现消息队列
+- [ ] 性能测试和优化
+
+## 项目结构
+
+```
+src/
+├── main/
+│   ├── java/
+│   │   └── cn/
+│   │       └── hezhaohui/
+│   │           ├── Application.java
+│   │           ├── redis/
+│   │           │   ├── RedisConnection.java
+│   │           │   ├── RedisStringOperations.java
+│   │           │   ├── RedisListOperations.java
+│   │           │   ├── RedisSetOperations.java
+│   │           │   ├── RedisHashOperations.java
+│   │           │   ├── RedisSortedSetOperations.java
+│   │           │   └── RedisBasicOperations.java
+│   │           └── test/
+│   │               └── RedisConnectionTest.java
+│   └── resources/
+│       └── application.yml
+└── test/
+    └── java/
+        └── cn/
+            └── hezhaohui/
+                └── RedisIntegrationTest.java
+```
+
+## 学习资源
+
+- [Redis官方文档](https://redis.io/documentation/)
+- [Redis中文文档](https://redisdoc.com/)
+- [Redis命令参考](https://redis.io/commands/)
+
+## 开始学习
+
+1. 确保已安装Redis服务器
+2. 启动Redis服务器
+3. 运行测试用例来验证环境配置
+4. 按照学习计划逐步完成各个任务

Makefile

@@ -0,0 +1,43 @@
+# Redis学习项目Makefile
+
+.PHONY: help build test run clean
+
+help:
+	@echo "Redis学习项目命令"
+	@echo "=================="
+	@echo "make help     - 显示帮助信息"
+	@echo "make build    - 编译项目"
+	@echo "make test     - 运行测试"
+	@echo "make run      - 运行项目"
+	@echo "make clean    - 清理项目"
+
+build:
+	@echo "编译项目..."
+	mvn compile
+
+test:
+	@echo "运行测试..."
+	mvn test
+
+run:
+	@echo "运行项目..."
+	mvn spring-boot:run
+
+clean:
+	@echo "清理项目..."
+	mvn clean
+
+# 启动Redis服务器
+redis-start:
+	@echo "启动Redis服务器..."
+	redis-server
+
+# 停止Redis服务器
+redis-stop:
+	@echo "停止Redis服务器..."
+	redis-cli shutdown
+
+# 检查Redis状态
+redis-status:
+	@echo "检查Redis状态..."
+	redis-cli ping

README.md

@@ -1,3 +1,96 @@
-# redis-template
+# Redis 学习项目
 
-🗂️ Redis 项目模板
+本项目旨在帮助您系统地学习Redis，从基础概念到高级应用。通过实践练习和测试样例，您将掌握Redis的核心功能和使用方法。
+
+## 项目结构
+
+```
+src/
+├── main/
+│   ├── java/
+│   │   └── cn/
+│   │       └── hezhaohui/
+│   │           ├── Application.java
+│   │           ├── redis/
+│   │           │   ├── RedisConnection.java
+│   │           │   ├── RedisStringOperations.java
+│   │           │   ├── RedisListOperations.java
+│   │           │   ├── RedisSetOperations.java
+│   │           │   ├── RedisHashOperations.java
+│   │           │   ├── RedisSortedSetOperations.java
+│   │           │   └── RedisBasicOperations.java
+│   │           └── test/
+│   │               └── RedisConnectionTest.java
+│   └── resources/
+│       └── application.yml
+└── test/
+    └── java/
+        └── cn/
+            └── hezhaohui/
+                └── RedisIntegrationTest.java
+```
+
+## 学习计划
+
+### 第1阶段：基础概念和环境搭建
+- [ ] 了解Redis是什么以及它的特点
+- [ ] 安装和配置Redis服务器
+- [ ] 理解Redis的数据类型和基本操作
+- [ ] 配置Spring Boot项目以使用Redis
+
+### 第2阶段：核心数据类型操作
+- [ ] 字符串(String)操作
+- [ ] 列表(List)操作
+- [ ] 集合(Set)操作
+- [ ] 哈希(Hash)操作
+- [ ] 有序集合(Sorted Set)操作
+
+### 第3阶段：高级功能和应用
+- [ ] 过期时间(TTL)和键空间通知
+- [ ] 事务和管道
+- [ ] 发布/订阅模式
+- [ ] 持久化机制
+- [ ] 集群和主从复制
+
+### 第4阶段：实际应用和测试
+- [ ] 实现缓存策略
+- [ ] 实现计数器和排行榜
+- [ ] 实现消息队列
+- [ ] 性能测试和优化
+
+## 开始学习
+
+1. 确保已安装Redis服务器
+2. 启动Redis服务器
+3. 运行测试用例来验证环境配置
+4. 按照学习计划逐步完成各个任务
+
+## 配置说明
+
+项目使用Spring Boot框架，配置文件位于 `src/main/resources/application.yml`。
+
+## 测试说明
+
+所有测试用例位于 `src/test/java/cn/hezhaohui/` 目录下，使用JUnit进行测试。
+
+## 学习资源
+
+- [Redis官方文档](https://redis.io/documentation/)
+- [Redis中文文档](https://redisdoc.com/)
+- [Redis命令参考](https://redis.io/commands/)
+
+## 项目说明
+
+本项目包含以下组件：
+
+1. **RedisConnection.java** - Redis连接管理类
+2. **RedisStringOperations.java** - 字符串操作类
+3. **RedisListOperations.java** - 列表操作类
+4. **RedisSetOperations.java** - 集合操作类
+5. **RedisHashOperations.java** - 哈希操作类
+6. **RedisSortedSetOperations.java** - 有序集合操作类
+7. **RedisBasicOperations.java** - 基础操作类
+8. **RedisConnectionTest.java** - 连接测试类
+9. **RedisIntegrationTest.java** - 集成测试类
+
+每个类都包含TODO注释，指导您逐步实现功能。

USAGE.md

@@ -0,0 +1,92 @@
+# Redis学习项目使用说明
+
+## 项目结构说明
+
+本项目包含以下主要文件和目录：
+
+### 源代码目录
+- `src/main/java/cn/hezhaohui/redis/` - Redis操作类目录
+  - `RedisConnection.java` - Redis连接管理类
+  - `RedisStringOperations.java` - 字符串操作类
+  - `RedisListOperations.java` - 列表操作类
+  - `RedisSetOperations.java` - 集合操作类
+  - `RedisHashOperations.java` - 哈希操作类
+  - `RedisSortedSetOperations.java` - 有序集合操作类
+  - `RedisBasicOperations.java` - 基础操作类
+- `src/main/java/cn/hezhaohui/test/` - 测试类目录
+  - `RedisConnectionTest.java` - 连接测试类
+- `src/main/resources/application.yml` - Spring Boot配置文件
+
+### 测试目录
+- `src/test/java/cn/hezhaohui/RedisIntegrationTest.java` - 集成测试类
+
+### 文档文件
+- `README.md` - 项目说明文档
+- `LEARNING_GUIDE.md` - 详细学习指南
+- `LEARNING_PLAN.md` - 学习计划文档
+
+## 使用方法
+
+### 1. 环境准备
+确保已安装以下软件：
+- Java 17或更高版本
+- Maven
+- Redis服务器
+
+### 2. 启动Redis服务器
+在终端中运行：
+```bash
+redis-server
+```
+
+### 3. 编译项目
+```bash
+mvn compile
+```
+
+### 4. 运行测试
+```bash
+# 运行连接测试
+mvn exec:java -Dexec.mainClass="cn.hezhaohui.RedisConnectionTest"
+
+# 运行所有测试
+mvn test
+```
+
+### 5. 使用启动脚本
+- Linux/Mac: `./start.sh`
+- Windows: `start.bat`
+
+### 6. 使用Makefile
+```bash
+# 显示帮助
+make help
+
+# 编译项目
+make build
+
+# 运行测试
+make test
+
+# 启动Redis服务器
+make redis-start
+
+# 检查Redis状态
+make redis-status
+```
+
+## 学习建议
+
+1. **从基础开始**：先理解Redis的基本概念和数据类型
+2. **动手实践**：每个类都有TODO注释，按照注释逐步实现功能
+3. **编写测试**：为每个功能编写测试用例验证正确性
+4. **循序渐进**：按照学习计划的阶段逐步学习
+5. **查阅文档**：参考Redis官方文档和学习指南
+
+## 项目特点
+
+- 完整的Redis操作类实现
+- 详细的TODO注释指导学习
+- 集成测试框架
+- Spring Boot配置支持
+- 跨平台支持（Windows/Linux/Mac）

init.bat

@@ -0,0 +1,56 @@
+@echo off
+REM Redis学习项目初始化脚本
+
+echo Redis学习项目初始化
+echo ===================
+
+REM 检查必要的工具
+echo 检查必要工具...
+java -version >nul 2>&1
+if %errorlevel% == 0 (
+    echo ✓ Java已安装
+) else (
+    echo 错误: 未找到Java，请先安装Java 17或更高版本
+    pause
+    exit /b 1
+)
+
+mvn -version >nul 2>&1
+if %errorlevel% == 0 (
+    echo ✓ Maven已安装
+) else (
+    echo 错误: 未找到Maven，请先安装Maven
+    pause
+    exit /b 1
+)
+
+redis-server --version >nul 2>&1
+if %errorlevel% == 0 (
+    echo ✓ Redis服务器已安装
+) else (
+    echo 警告: 未找到Redis服务器，请先安装Redis
+)
+
+echo 工具检查完成
+
+REM 编译项目
+echo 编译项目...
+mvn compile
+if %errorlevel% == 0 (
+    echo ✓ 项目编译成功
+    
+    REM 运行连接测试
+    echo 运行连接测试...
+    mvn exec:java -Dexec.mainClass="cn.hezhaohui.RedisConnectionTest"
+    
+    echo.
+    echo 初始化完成！
+    echo 请按照LEARNING_PLAN.md中的学习计划逐步学习Redis。
+    echo 所有Redis操作类都包含TODO注释，指导您实现具体功能。
+) else (
+    echo ✗ 项目编译失败
+    pause
+    exit /b 1
+)
+
+pause

init.sh

@@ -0,0 +1,43 @@
+#!/bin/bash
+# Redis学习项目初始化脚本
+
+echo "Redis学习项目初始化"
+echo "==================="
+
+# 检查必要的工具
+echo "检查必要工具..."
+if ! command -v java &> /dev/null; then
+    echo "错误: 未找到Java，请先安装Java 17或更高版本"
+    exit 1
+fi
+
+if ! command -v mvn &> /dev/null; then
+    echo "错误: 未找到Maven，请先安装Maven"
+    exit 1
+fi
+
+if ! command -v redis-server &> /dev/null; then
+    echo "警告: 未找到Redis服务器，请先安装Redis"
+fi
+
+echo "工具检查完成"
+
+# 编译项目
+echo "编译项目..."
+mvn compile
+
+if [ $? -eq 0 ]; then
+    echo "✓ 项目编译成功"
+    
+    # 运行连接测试
+    echo "运行连接测试..."
+    mvn exec:java -Dexec.mainClass="cn.hezhaohui.test.RedisConnectionTest"
+    
+    echo ""
+    echo "初始化完成！"
+    echo "请按照LEARNING_PLAN.md中的学习计划逐步学习Redis。"
+    echo "所有Redis操作类都包含TODO注释，指导您实现具体功能。"
+else
+    echo "✗ 项目编译失败"
+    exit 1
+fi

pom.xml

@@ -7,12 +7,48 @@
     <artifactId>redis-template</artifactId>
     <version>1.0-SNAPSHOT</version>
 
+    <properties>
+        <maven.compiler.source>21</maven.compiler.source>
+        <maven.compiler.target>21</maven.compiler.target>
+        <spring.boot.version>3.2.2</spring.boot.version>
+    </properties>
+
     <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-redis</artifactId>
-            <version>3.2.2</version>
+            <version>${spring.boot.version}</version>
+            <exclusions>
+                <exclusion>
+                    <artifactId>lettuce-core</artifactId>
+                    <groupId>io.lettuce</groupId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        
+        <!-- Jedis客户端依赖 -->
+        <dependency>
+            <groupId>redis.clients</groupId>
+            <artifactId>jedis</artifactId>
+            <version>4.4.3</version>
+        </dependency>
+        
+        <!-- Spring Boot测试依赖 -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <version>${spring.boot.version}</version>
+            <scope>test</scope>
         </dependency>
     </dependencies>
 
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>${spring.boot.version}</version>
+            </plugin>
+        </plugins>
+    </build>
 </project>

src/main/java/cn/hezhaohui/Application.java

@@ -3,9 +3,15 @@ package cn.hezhaohui;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
+/**
+ * Redis学习项目启动类
+ * TODO: 添加Spring Boot启动配置
+ * TODO: 配置Redis自动装配
+ */
 @SpringBootApplication
 public class Application {
     public static void main(String[] args) {
+        // TODO: 启动Spring Boot应用
         SpringApplication.run(Application.class, args);
     }
 }

src/main/java/cn/hezhaohui/redis/RedisBasicOperations.java

@@ -0,0 +1,74 @@
+package cn.hezhaohui.redis;
+
+import java.util.Set;
+
+/**
+ * Redis基础操作类
+ * TODO: 实现基础的键操作方法
+ * TODO: 添加异常处理机制
+ * TODO: 实现键的过期和生存时间操作
+ */
+public class RedisBasicOperations {
+    
+    /**
+     * 检查键是否存在
+     * TODO: 实现exists方法
+     */
+    public boolean exists(String key) {
+        // TODO: 检查键是否存在
+        return false;
+    }
+    
+    /**
+     * 删除键
+     * TODO: 实现del方法
+     */
+    public long delete(String key) {
+        // TODO: 删除键
+        return 0;
+    }
+    
+    /**
+     * 获取所有匹配的键
+     * TODO: 实现keys方法
+     */
+    public Set<String> keys(String pattern) {
+        // TODO: 获取所有匹配的键
+        return null;
+    }
+    
+    /**
+     * 设置键的过期时间
+     * TODO: 实现expire方法
+     */
+    public boolean setExpiry(String key, int seconds) {
+        // TODO: 设置键的过期时间
+        return false;
+    }
+    
+    /**
+     * 获取键的剩余生存时间
+     * TODO: 实现ttl方法
+     */
+    public long timeToLive(String key) {
+        // TODO: 获取键的剩余生存时间
+        return 0;
+    }
+    
+    /**
+     * 获取键的类型
+     * TODO: 实现type方法
+     */
+    public String type(String key) {
+        // TODO: 获取键的类型
+        return null;
+    }
+    
+    /**
+     * 清空数据库
+     * TODO: 实现flushDB方法
+     */
+    public void flushDatabase() {
+        // TODO: 清空数据库
+    }
+}

src/main/java/cn/hezhaohui/redis/RedisConnection.java

@@ -0,0 +1,47 @@
+package cn.hezhaohui.redis;
+
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisPool;
+import redis.clients.jedis.JedisPoolConfig;
+
+/**
+ * Redis连接管理类
+ * TODO: 实现Redis连接池的配置和管理
+ * TODO: 添加连接状态检查和重连机制
+ * TODO: 实现连接参数的配置化
+ */
+public class RedisConnection {
+    private static JedisPool jedisPool;
+    
+    static {
+        // TODO: 配置连接池参数
+        JedisPoolConfig config = new JedisPoolConfig();
+        // TODO: 设置最大连接数、最小空闲连接数等参数
+        jedisPool = new JedisPool(config, "localhost", 6379);
+    }
+    
+    /**
+     * 获取Redis连接
+     * TODO: 实现连接获取逻辑
+     */
+    public static Jedis getJedis() {
+        // TODO: 返回连接池中的连接
+        return null;
+    }
+    
+    /**
+     * 关闭连接
+     * TODO: 实现连接关闭逻辑
+     */
+    public static void closeJedis(Jedis jedis) {
+        // TODO: 关闭连接
+    }
+    
+    /**
+     * 关闭连接池
+     * TODO: 实现连接池关闭逻辑
+     */
+    public static void closePool() {
+        // TODO: 关闭连接池
+    }
+}

src/main/java/cn/hezhaohui/redis/RedisHashOperations.java

@@ -0,0 +1,93 @@
+package cn.hezhaohui.redis;
+
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Redis哈希操作类
+ * TODO: 实现哈希的基本操作方法
+ * TODO: 添加异常处理机制
+ * TODO: 实现哈希的批量操作方法
+ */
+public class RedisHashOperations {
+    
+    /**
+     * 设置哈希中的字段值
+     * TODO: 实现hset方法
+     */
+    public long set(String key, String field, String value) {
+        // TODO: 设置哈希中的字段值
+        return 0;
+    }
+    
+    /**
+     * 获取哈希中字段的值
+     * TODO: 实现hget方法
+     */
+    public String get(String key, String field) {
+        // TODO: 获取哈希中字段的值
+        return null;
+    }
+    
+    /**
+     * 获取哈希中所有字段的值
+     * TODO: 实现hgetAll方法
+     */
+    public Map<String, String> getAll(String key) {
+        // TODO: 获取哈希中所有字段的值
+        return null;
+    }
+    
+    /**
+     * 获取哈希中所有字段名
+     * TODO: 实现hkeys方法
+     */
+    public Set<String> keys(String key) {
+        // TODO: 获取哈希中所有字段名
+        return null;
+    }
+    
+    /**
+     * 获取哈希中所有值
+     * TODO: 实现hvals方法
+     */
+    public Set<String> values(String key) {
+        // TODO: 获取哈希中所有值
+        return null;
+    }
+    
+    /**
+     * 获取哈希中字段的数量
+     * TODO: 实现hlen方法
+     */
+    public long length(String key) {
+        // TODO: 获取哈希中字段的数量
+        return 0;
+    }
+    
+    /**
+     * 批量设置哈希字段
+     * TODO: 实现hmset方法
+     */
+    public void setMultiple(String key, Map<String, String> hash) {
+        // TODO: 批量设置哈希字段
+    }
+    
+    /**
+     * 批量获取哈希字段的值
+     * TODO: 实现hmget方法
+     */
+    public Set<String> getMultiple(String key, String... fields) {
+        // TODO: 批量获取哈希字段的值
+        return null;
+    }
+    
+    /**
+     * 删除哈希中的字段
+     * TODO: 实现hdel方法
+     */
+    public long remove(String key, String... fields) {
+        // TODO: 删除哈希中的字段
+        return 0;
+    }
+}

src/main/java/cn/hezhaohui/redis/RedisListOperations.java

@@ -0,0 +1,83 @@
+package cn.hezhaohui.redis;
+
+import java.util.List;
+
+/**
+ * Redis列表操作类
+ * TODO: 实现列表的基本操作方法
+ * TODO: 添加异常处理机制
+ * TODO: 实现列表的截取和长度操作
+ */
+public class RedisListOperations {
+    
+    /**
+     * 在列表左侧添加元素
+     * TODO: 实现lpush方法
+     */
+    public long leftPush(String key, String... values) {
+        // TODO: 在列表左侧添加元素
+        return 0;
+    }
+    
+    /**
+     * 在列表右侧添加元素
+     * TODO: 实现rpush方法
+     */
+    public long rightPush(String key, String... values) {
+        // TODO: 在列表右侧添加元素
+        return 0;
+    }
+    
+    /**
+     * 从列表左侧弹出元素
+     * TODO: 实现lpop方法
+     */
+    public String leftPop(String key) {
+        // TODO: 从列表左侧弹出元素
+        return null;
+    }
+    
+    /**
+     * 从列表右侧弹出元素
+     * TODO: 实现rpop方法
+     */
+    public String rightPop(String key) {
+        // TODO: 从列表右侧弹出元素
+        return null;
+    }
+    
+    /**
+     * 获取列表指定范围的元素
+     * TODO: 实现lrange方法
+     */
+    public List<String> range(String key, long start, long end) {
+        // TODO: 获取列表指定范围的元素
+        return null;
+    }
+    
+    /**
+     * 获取列表长度
+     * TODO: 实现llen方法
+     */
+    public long length(String key) {
+        // TODO: 获取列表长度
+        return 0;
+    }
+    
+    /**
+     * 设置列表指定索引的值
+     * TODO: 实现lset方法
+     */
+    public void set(String key, long index, String value) {
+        // TODO: 设置列表指定索引的值
+    }
+    
+    /**
+     * 删除列表中指定值的元素
+     * TODO: 实现lrem方法
+     */
+    public long remove(String key, long count, String value) {
+        // TODO: 删除列表中指定值的元素
+        return 0;
+    }
+}

src/main/java/cn/hezhaohui/redis/RedisSetOperations.java

@@ -0,0 +1,84 @@
+package cn.hezhaohui.redis;
+
+import java.util.Set;
+
+/**
+ * Redis集合操作类
+ * TODO: 实现集合的基本操作方法
+ * TODO: 添加异常处理机制
+ * TODO: 实现集合间的操作方法
+ */
+public class RedisSetOperations {
+    
+    /**
+     * 向集合添加元素
+     * TODO: 实现sadd方法
+     */
+    public long add(String key, String... members) {
+        // TODO: 向集合添加元素
+        return 0;
+    }
+    
+    /**
+     * 从集合中移除元素
+     * TODO: 实现srem方法
+     */
+    public long remove(String key, String... members) {
+        // TODO: 从集合中移除元素
+        return 0;
+    }
+    
+    /**
+     * 获取集合中的所有元素
+     * TODO: 实现smembers方法
+     */
+    public Set<String> members(String key) {
+        // TODO: 获取集合中的所有元素
+        return null;
+    }
+    
+    /**
+     * 判断元素是否在集合中
+     * TODO: 实现sismember方法
+     */
+    public boolean isMember(String key, String member) {
+        // TODO: 判断元素是否在集合中
+        return false;
+    }
+    
+    /**
+     * 获取集合的大小
+     * TODO: 实现scard方法
+     */
+    public long size(String key) {
+        // TODO: 获取集合的大小
+        return 0;
+    }
+    
+    /**
+     * 获取两个集合的交集
+     * TODO: 实现sinter方法
+     */
+    public Set<String> intersect(String... keys) {
+        // TODO: 获取两个集合的交集
+        return null;
+    }
+    
+    /**
+     * 获取两个集合的并集
+     * TODO: 实现sunion方法
+     */
+    public Set<String> union(String... keys) {
+        // TODO: 获取两个集合的并集
+        return null;
+    }
+    
+    /**
+     * 获取两个集合的差集
+     * TODO: 实现sdiff方法
+     */
+    public Set<String> difference(String... keys) {
+        // TODO: 获取两个集合的差集
+        return null;
+    }
+}

src/main/java/cn/hezhaohui/redis/RedisSortedSetOperations.java

@@ -0,0 +1,93 @@
+package cn.hezhaohui.redis;
+
+import java.util.Set;
+
+/**
+ * Redis有序集合操作类
+ * TODO: 实现有序集合的基本操作方法
+ * TODO: 添加异常处理机制
+ * TODO: 实现有序集合的范围查询方法
+ */
+public class RedisSortedSetOperations {
+    
+    /**
+     * 向有序集合添加元素
+     * TODO: 实现zadd方法
+     */
+    public long add(String key, double score, String member) {
+        // TODO: 向有序集合添加元素
+        return 0;
+    }
+    
+    /**
+     * 获取有序集合中元素的分数
+     * TODO: 实现zscore方法
+     */
+    public Double getScore(String key, String member) {
+        // TODO: 获取有序集合中元素的分数
+        return null;
+    }
+    
+    /**
+     * 获取有序集合中元素的排名
+     * TODO: 实现zrank方法
+     */
+    public Long getRank(String key, String member) {
+        // TODO: 获取有序集合中元素的排名
+        return null;
+    }
+    
+    /**
+     * 获取有序集合中元素的逆序排名
+     * TODO: 实现zrevrank方法
+     */
+    public Long getReverseRank(String key, String member) {
+        // TODO: 获取有序集合中元素的逆序排名
+        return null;
+    }
+    
+    /**
+     * 获取有序集合中指定范围的元素
+     * TODO: 实现zrange方法
+     */
+    public Set<String> range(String key, long start, long end) {
+        // TODO: 获取有序集合中指定范围的元素
+        return null;
+    }
+    
+    /**
+     * 获取有序集合中指定分数范围的元素
+     * TODO: 实现zrangeByScore方法
+     */
+    public Set<String> rangeByScore(String key, double min, double max) {
+        // TODO: 获取有序集合中指定分数范围的元素
+        return null;
+    }
+    
+    /**
+     * 获取有序集合的大小
+     * TODO: 实现zcard方法
+     */
+    public long size(String key) {
+        // TODO: 获取有序集合的大小
+        return 0;
+    }
+    
+    /**
+     * 删除有序集合中的元素
+     * TODO: 实现zrem方法
+     */
+    public long remove(String key, String... members) {
+        // TODO: 删除有序集合中的元素
+        return 0;
+    }
+    
+    /**
+     * 增加元素的分数
+     * TODO: 实现zincrby方法
+     */
+    public double increment(String key, double increment, String member) {
+        // TODO: 增加元素的分数
+        return 0;
+    }
+}

src/main/java/cn/hezhaohui/redis/RedisStringOperations.java

@@ -0,0 +1,73 @@
+package cn.hezhaohui.redis;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Redis字符串操作类
+ * TODO: 实现字符串的基本操作方法
+ * TODO: 添加异常处理机制
+ * TODO: 实现批量操作方法
+ */
+public class RedisStringOperations {
+    
+    /**
+     * 设置字符串值
+     * TODO: 实现set方法
+     */
+    public void setString(String key, String value) {
+        // TODO: 使用Jedis设置字符串值
+    }
+    
+    /**
+     * 获取字符串值
+     * TODO: 实现get方法
+     */
+    public String getString(String key) {
+        // TODO: 使用Jedis获取字符串值
+        return null;
+    }
+    
+    /**
+     * 设置带过期时间的字符串
+     * TODO: 实现setex方法
+     */
+    public void setStringWithExpiry(String key, String value, int seconds) {
+        // TODO: 设置带过期时间的字符串
+    }
+    
+    /**
+     * 批量设置字符串
+     * TODO: 实现mset方法
+     */
+    public void setStrings(Map<String, String> keyValueMap) {
+        // TODO: 批量设置字符串
+    }
+    
+    /**
+     * 批量获取字符串
+     * TODO: 实现mget方法
+     */
+    public List<String> getStrings(List<String> keys) {
+        // TODO: 批量获取字符串
+        return null;
+    }
+    
+    /**
+     * 增加数字值
+     * TODO: 实现incr方法
+     */
+    public long increment(String key) {
+        // TODO: 增加数字值
+        return 0;
+    }
+    
+    /**
+     * 增加指定数值
+     * TODO: 实现incrby方法
+     */
+    public long incrementBy(String key, long increment) {
+        // TODO: 增加指定数值
+        return 0;
+    }
+}

src/main/resources/application.yml

@@ -1,7 +1,14 @@
+server:
+  port: 8080
+
 spring:
   data:
     redis:
-      database: 0
       host: 47.121.181.112
       port: 6379
+      # Redis数据库索引（默认为0）
+      database: 0
+      # Redis服务器连接密码（默认为空）
       password: dn293830
+      # 连接超时时间（毫秒）
+      timeout: 2000ms

src/test/java/cn/hezhaohui/RedisConnectionTest.java

@@ -0,0 +1,83 @@
+package cn.hezhaohui;
+
+import redis.clients.jedis.Jedis;
+
+/**
+ * Redis连接测试类
+ * TODO: 实现Redis连接测试
+ * TODO: 验证Redis服务器是否正常运行
+ * TODO: 测试基本的Redis操作
+ */
+public class RedisConnectionTest {
+    
+    public static void main(String[] args) {
+        System.out.println("开始Redis连接测试...");
+        
+        // 测试Redis连接
+        testRedisConnection();
+        
+        // 测试基本操作
+        testBasicOperations();
+        
+        System.out.println("Redis测试完成!");
+    }
+    
+    /**
+     * 测试Redis连接
+     * TODO: 实现连接测试逻辑
+     */
+    private static void testRedisConnection() {
+        System.out.println("测试Redis连接...");
+        try {
+            // 创建Jedis连接
+            Jedis jedis = new Jedis("localhost", 6379);
+            
+            // 测试连接
+            String pingResult = jedis.ping();
+            System.out.println("Redis连接测试结果: " + pingResult);
+            
+            // 关闭连接
+            jedis.close();
+            
+            if ("PONG".equals(pingResult)) {
+                System.out.println("✓ Redis连接成功");
+            } else {
+                System.out.println("✗ Redis连接失败");
+            }
+        } catch (Exception e) {
+            System.out.println("✗ Redis连接异常: " + e.getMessage());
+        }
+    }
+    
+    /**
+     * 测试基本操作
+     * TODO: 实现基本操作测试逻辑
+     */
+    private static void testBasicOperations() {
+        System.out.println("测试基本操作...");
+        try {
+            Jedis jedis = new Jedis("localhost", 6379);
+            
+            // 测试字符串操作
+            jedis.set("test_key", "test_value");
+            String value = jedis.get("test_key");
+            System.out.println("字符串操作测试: " + value);
+            
+            // 测试计数器
+            jedis.incr("counter");
+            long counter = jedis.incr("counter");
+            System.out.println("计数器测试: " + counter);
+            
+            // 清理测试数据
+            jedis.del("test_key");
+            jedis.del("counter");
+            
+            // 关闭连接
+            jedis.close();
+            
+            System.out.println("✓ 基本操作测试成功");
+        } catch (Exception e) {
+            System.out.println("✗ 基本操作测试失败: " + e.getMessage());
+        }
+    }
+}

src/test/java/cn/hezhaohui/RedisIntegrationTest.java

@@ -0,0 +1,104 @@
+package cn.hezhaohui;
+
+import cn.hezhaohui.redis.*;
+import org.junit.jupiter.api.*;
+import redis.clients.jedis.Jedis;
+
+import java.util.*;
+
+/**
+ * Redis集成测试类
+ * TODO: 实现完整的Redis功能集成测试
+ * TODO: 添加测试数据清理机制
+ * TODO: 实现测试环境的初始化和清理
+ */
+public class RedisIntegrationTest {
+    
+    private static Jedis jedis;
+    
+    @BeforeAll
+    public static void setUp() {
+        // TODO: 初始化Redis连接
+        // jedis = new Jedis("localhost", 6379);
+    }
+    
+    @AfterAll
+    public static void tearDown() {
+        // TODO: 关闭Redis连接
+        // if (jedis != null) {
+        //     jedis.close();
+        // }
+    }
+    
+    @BeforeEach
+    public void beforeEach() {
+        // TODO: 每个测试前的准备工作
+        // 清空数据库
+        // if (jedis != null) {
+        //     jedis.flushDB();
+        // }
+    }
+    
+    @Test
+    public void testStringOperations() {
+        // TODO: 测试字符串操作功能
+        // 1. 测试set/get操作
+        // 2. 测试批量操作
+        // 3. 测试计数器功能
+        Assertions.assertTrue(true); // 占位符
+    }
+    
+    @Test
+    public void testListOperations() {
+        // TODO: 测试列表操作功能
+        // 1. 测试push/pop操作
+        // 2. 测试范围查询
+        // 3. 测试长度操作
+        Assertions.assertTrue(true); // 占位符
+    }
+    
+    @Test
+    public void testSetOperations() {
+        // TODO: 测试集合操作功能
+        // 1. 测试添加/删除元素
+        // 2. 测试集合运算
+        // 3. 测试成员检查
+        Assertions.assertTrue(true); // 占位符
+    }
+    
+    @Test
+    public void testHashOperations() {
+        // TODO: 测试哈希操作功能
+        // 1. 测试字段设置/获取
+        // 2. 测试批量操作
+        // 3. 测试字段查询
+        Assertions.assertTrue(true); // 占位符
+    }
+    
+    @Test
+    public void testSortedSetOperations() {
+        // TODO: 测试有序集合操作功能
+        // 1. 测试添加元素
+        // 2. 测试范围查询
+        // 3. 测试分数操作
+        Assertions.assertTrue(true); // 占位符
+    }
+    
+    @Test
+    public void testBasicOperations() {
+        // TODO: 测试基础操作功能
+        // 1. 测试键存在性检查
+        // 2. 测试键删除
+        // 3. 测试过期时间
+        Assertions.assertTrue(true); // 占位符
+    }
+    
+    @Test
+    public void testAdvancedFeatures() {
+        // TODO: 测试高级功能
+        // 1. 测试事务
+        // 2. 测试发布/订阅
+        // 3. 测试持久化
+        Assertions.assertTrue(true); // 占位符
+    }
+}

src/test/java/cn/hezhaohui/RedisTest.java

@@ -0,0 +1,90 @@
+package cn.hezhaohui;
+
+
+/**
+ * Redis学习测试类
+ * TODO: 实现各个Redis操作类的测试方法
+ * TODO: 添加测试用例验证功能正确性
+ * TODO: 实现测试数据的清理机制
+ */
+public class RedisTest {
+    
+    public static void main(String[] args) {
+        // TODO: 创建测试用例来验证各个Redis操作
+        System.out.println("Redis学习测试开始...");
+        
+        // 测试基础操作
+        testBasicOperations();
+        
+        // 测试字符串操作
+        testStringOperations();
+        
+        // 测试列表操作
+        testListOperations();
+        
+        // 测试集合操作
+        testSetOperations();
+        
+        // 测试哈希操作
+        testHashOperations();
+        
+        // 测试有序集合操作
+        testSortedSetOperations();
+        
+        System.out.println("Redis学习测试完成!");
+    }
+    
+    /**
+     * 测试基础操作
+     * TODO: 实现基础操作的测试方法
+     */
+    private static void testBasicOperations() {
+        System.out.println("测试基础操作...");
+        // TODO: 实现基础操作测试
+    }
+    
+    /**
+     * 测试字符串操作
+     * TODO: 实现字符串操作的测试方法
+     */
+    private static void testStringOperations() {
+        System.out.println("测试字符串操作...");
+        // TODO: 实现字符串操作测试
+    }
+    
+    /**
+     * 测试列表操作
+     * TODO: 实现列表操作的测试方法
+     */
+    private static void testListOperations() {
+        System.out.println("测试列表操作...");
+        // TODO: 实现列表操作测试
+    }
+    
+    /**
+     * 测试集合操作
+     * TODO: 实现集合操作的测试方法
+     */
+    private static void testSetOperations() {
+        System.out.println("测试集合操作...");
+        // TODO: 实现集合操作测试
+    }
+    
+    /**
+     * 测试哈希操作
+     * TODO: 实现哈希操作的测试方法
+     */
+    private static void testHashOperations() {
+        System.out.println("测试哈希操作...");
+        // TODO: 实现哈希操作测试
+    }
+    
+    /**
+     * 测试有序集合操作
+     * TODO: 实现有序集合操作的测试方法
+     */
+    private static void testSortedSetOperations() {
+        System.out.println("测试有序集合操作...");
+        // TODO: 实现有序集合操作测试
+    }
+}

start.bat

@@ -0,0 +1,35 @@
+@echo off
+REM Redis学习项目启动脚本
+
+echo Redis学习项目启动脚本
+echo ======================
+
+REM 检查Redis服务器是否运行
+echo 检查Redis服务器状态...
+tasklist | findstr redis-server >nul
+if %errorlevel% == 0 (
+    echo ✓ Redis服务器正在运行
+) else (
+    echo ✗ Redis服务器未运行
+    echo 请先启动Redis服务器: redis-server
+    pause
+    exit /b 1
+)
+
+REM 编译项目
+echo 编译项目...
+mvn compile
+if %errorlevel% == 0 (
+    echo ✓ 项目编译成功
+) else (
+    echo ✗ 项目编译失败
+    pause
+    exit /b 1
+)
+
+REM 运行连接测试
+echo 运行Redis连接测试...
+mvn exec:java -Dexec.mainClass="cn.hezhaohui.RedisConnectionTest"
+
+echo 测试完成!
+pause

start.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+# Redis学习项目启动脚本
+
+echo "Redis学习项目启动脚本"
+echo "======================"
+
+# 检查Redis服务器是否运行
+echo "检查Redis服务器状态..."
+if pgrep redis-server > /dev/null; then
+    echo "✓ Redis服务器正在运行"
+else
+    echo "✗ Redis服务器未运行"
+    echo "请先启动Redis服务器: redis-server"
+    exit 1
+fi
+
+# 编译项目
+echo "编译项目..."
+mvn compile
+
+if [ $? -eq 0 ]; then
+    echo "✓ 项目编译成功"
+else
+    echo "✗ 项目编译失败"
+    exit 1
+fi
+
+# 运行连接测试
+echo "运行Redis连接测试..."
+mvn exec:java -Dexec.mainClass="cn.hezhaohui.test.RedisConnectionTest"
+
+echo "测试完成!"