Java入门级教程25——Jedis连接Redis、五大核心数据类型
·
目录
3.1 String 类型：基础键值对操作（Chapter1）
1.Redis是什么
Redis（Remote Dictionary Server，远程字典服务）是一款开源的、高性能的键值对（Key-Value）内存数据库，基于C语言编写、遵循BSD协议，支持数据持久化（RDB、AOF），可将内存中的数据同步到磁盘，避免服务重启后数据丢失。
具备高可用、多客户端兼容、拓展性强等特点。核心支持String、List、Set、Hash、Zset五大数据类型，广泛应用于缓存、消息队列、计数器等场景，是后端开发核心组件。
2.Jedis 连接 Redis
所有操作的前提是通过 Jedis 客户端建立与 Redis 的连接，具体操作如下：
2.1 启动redis
① 找到已下载的 redis，可选择双击 redis-server.exe 启动
② 启动成功
2.2 使用Redis Desktop Manager
① 点击底部Connect to Redis Server，输入Connection Name 和 redis-server Host
② 创建完成后，右击选择Reload
③ 点击db0，右击选择Reload
2.3 连接Redis
2.3.1 新建 Maven 项目 redisdemo
2.3.2 添加 Maven 依赖
2.3.3 具体实现
package com.hy.chapter1;
import redis.clients.jedis.Jedis;
public class Chapter1 {
static Jedis jedis;
// 静态初始化块确保连接复用
static {
jedis = new Jedis("127.0.0.1", 6379);
System.out.println("连接成功:" + jedis);
}
public static void test() {
jedis.set("name", "hhhy");
}
public static void main(String[] args) {
test();
}
}
2.3.4 运行与测试
① 控制台输出连接成功
② Redis Desktop Manager 重新加载后成功显示 name-hhhy
③ 可以右击db0，选择Flush database一键清空，来保证后面支持的数据类型测试结果准确
3.Redis支持的五大核心数据类型
Redis 作为高性能的键值对数据库，支持多种数据类型，五大核心数据类型有： String、List、Set、Hash、Zset ，所有案例均基于 Jedis 客户端实现本地 Redis 连接（默认地址 (127.0.0.1:6379)）。
3.1 String 类型：基础键值对操作（Chapter1）
String是Redis最基础的数据类型，底层以字节数组存储，适用于存储单个字符串、数字、JSON串等场景，单个String最大存储容量为512MB，操作简单且支持原子性。
核心操作：
-
set(key, value)：存储键值对； -
get(key)：获取指定键的值； -
del(key)：删除指定键； -
incr(key)：数字值自增； -
mset(key1, value1, key2, value2...)：批量存储多个键值对。
3.1.1 具体实现
package com.hy.chapter1;
import redis.clients.jedis.Jedis;
/**
* Chapter1类：Redis连接初始化 + String类型基础操作
*/
public class Chapter1 {
// 静态Jedis实例，全局复用（实际开发用连接池）
static Jedis jedis;
// 静态初始化块：启动时创建Redis连接
static {
try {
// 连接本地Redis服务器（默认地址127.0.0.1，端口6379）
jedis = new Jedis("127.0.0.1", 6379);
// 可选：若Redis设置密码，添加授权（jedis.auth("yourPassword")）
System.out.println("Redis连接成功，客户端信息：" + jedis);
} catch (Exception e) {
System.err.println("Redis连接失败：" + e.getMessage());
}
}
// 测试String类型基础操作
public static void main(String[] args) {
// 调用String类型操作方法
stringBasicOperation();
// 关闭连接（连接池场景无需手动关闭）
jedis.close();
}
/**
* String类型基础操作：set、get、del、incr、mset
*/
public static void stringBasicOperation() {
// 1. set(key, value)：存储键值对
jedis.set("name", "hhhy");
System.out.println("存储name键值对：" + jedis.get("name")); // 输出：hhhy
// 2. get(key)：获取指定键的值
String age = jedis.get("age");
System.out.println("获取age键（未设置，返回null）：" + age);
// 3. incr(key)：数字值自增1（仅支持整数类型）
jedis.set("age", "20"); // 先设置整数类型值
jedis.incr("age"); // 自增1，age从20变为21
System.out.println("age自增后：" + jedis.get("age"));
// 4. mset(key1, value1, key2, value2...)：批量存储多个键值对
jedis.mset("gender", "女", "address", "南京");
System.out.println("批量获取键值对：" + jedis.mget("name", "gender", "address"));
// 5. del(key)：删除指定键
jedis.del("address");
System.out.println("删除address后，是否存在：" + jedis.exists("address")); // 输出：false
}
}3.1.2 运行与测试
3.1.3 补充高频操作
incrBy(key, step)：按指定步长自增；setex(key, seconds, value)：存储键值对并设置过期时间；getSet(key, newValue)：获取旧值并设置新值；exists(key)：判断键是否存在；
具体实现：
package com.hy.chapter1;
import redis.clients.jedis.Jedis;
/**
* Chapter1补充：String类型高频操作
*/
public class Chapter1_2 {
// 静态Jedis实例，全局复用（实际开发用连接池）
static Jedis jedis;
// 静态初始化块：启动时创建Redis连接
static {
try {
// 连接本地Redis服务器（默认地址127.0.0.1，端口6379）
jedis = new Jedis("127.0.0.1", 6379);
// 可选：若Redis设置密码，添加授权（jedis.auth("yourPassword")）
System.out.println("Redis连接成功，客户端信息：" + jedis);
} catch (Exception e) {
System.err.println("Redis连接失败：" + e.getMessage());
}
}
public static void stringAdvancedOperation() {
// 补充1. incrBy(key, step)：按指定步长自增（如年龄+5）
jedis.set("age", "21");
jedis.incrBy("age", 5); // 步长为5，age从21变为26
System.out.println("age按步长5自增后：" + jedis.get("age"));
// 补充2. setex(key, seconds, value)：存储键值对并设置过期时间（验证码场景常用）
jedis.setex("code", 60, "123456"); // 验证码123456，60秒后过期
System.out.println("验证码（60秒过期）：" + jedis.get("code"));
System.out.println("验证码剩余过期时间（秒）：" + jedis.ttl("code"));
// 补充3. getSet(key, newValue)：获取旧值并设置新值（原子操作，适用于更新场景）
String oldName = jedis.getSet("name", "张三"); // 获取旧值"hhhy"，设置新值"张三"
System.out.println("name旧值：" + oldName + "，新值：" + jedis.get("name"));
// 补充4. exists(key)：判断键是否存在
boolean isNameExist = jedis.exists("name");
boolean isAddressExist = jedis.exists("address");
System.out.println("name是否存在：" + isNameExist); // 输出：true
System.out.println("address是否存在：" + isAddressExist); // 输出：false
}
// 主方法中调用补充操作
public static void main(String[] args) {
stringAdvancedOperation(); // 调用补充高频操作
jedis.close();
}
}
运行结果：
3.2 List 类型：有序列表操作（Chapter2）
List基于双向链表实现（Redis 3.2+ 优化为quicklist结构），支持首尾高效插入/删除，保持元素插入顺序，允许重复元素，适用于消息队列、最新消息列表等场景。
核心操作：
- 基础操作：
lpush(key, value...)：从列表左侧（表头）插入一个或多个元素；lrange(key, start, end)：获取列表指定范围的元素（end=-1表示获取所有元素）；
- 补充高频操作：
rpush(key, value...)：从列表右侧（表尾）插入元素；lpop(key)：删除并返回列表左侧第一个元素；rpop(key)：删除并返回列表右侧第一个元素；llen(key)：获取列表长度、；lrem(key, count, value)：删除列表中指定元素（count=0删除所有匹配元素，count>0从左删count个，count<0从右删）；
3.2.1 具体实现
package com.hy.chapter2;
import redis.clients.jedis.Jedis;
import java.util.List;
/**
* Chapter2类：List类型操作（lpush、lrange等）
*/
public class Chapter2 {
static Jedis jedis;
static {
// 复用Redis连接逻辑（与Chapter1一致）
jedis = new Jedis("127.0.0.1", 6379);
System.out.println("Redis连接成功：" + jedis);
}
public static void main(String[] args) {
// 调用List类型操作方法
listOperation();
jedis.close();
}
/**
* List类型：基础操作 + 补充高频操作
*/
public static void listOperation() {
// 先删除原有list（避免重复测试数据干扰）
jedis.del("language");
// 基础操作1. lpush(key, value...)：从列表左侧（表头）插入一个或多个元素
jedis.lpush("language", "Java", "Go", "Python"); // 插入顺序：Java → Go → Python（左侧插入，最终列表顺序相反）
System.out.println("lpush后列表所有元素：" + jedis.lrange("language", 0, -1)); // 输出：[Python, Go, Java]
// 基础操作2. lrange(key, start, end)：获取列表指定范围元素（end=-1表示获取所有元素）
List<String> firstTwo = jedis.lrange("language", 0, 1); // 获取前2个元素
System.out.println("列表前2个元素：" + firstTwo); // 输出：[Python, Go]
// 补充操作1. rpush(key, value...)：从列表右侧（表尾）插入元素
jedis.rpush("language", "JavaScript", "C++"); // 表尾插入，列表变为[Python, Go, Java, JavaScript, C++]
System.out.println("rpush后列表所有元素：" + jedis.lrange("language", 0, -1));
// 补充操作2. lpop(key)：删除并返回列表左侧第一个元素
String leftPop = jedis.lpop("language");
System.out.println("lpop删除的元素：" + leftPop + "，删除后列表：" + jedis.lrange("language", 0, -1));
// 补充操作3. rpop(key)：删除并返回列表右侧第一个元素
String rightPop = jedis.rpop("language");
System.out.println("rpop删除的元素：" + rightPop + "，删除后列表：" + jedis.lrange("language", 0, -1));
// 补充操作4. llen(key)：获取列表长度（比lrange(key,0,-1).size()更高效）
long listLen = jedis.llen("language");
System.out.println("当前列表长度：" + listLen);
// 补充操作5. lrem(key, count, value)：删除列表中指定元素
// count=0：删除所有匹配元素；count>0：从左删除count个；count<0：从右删除count个
jedis.lrem("language", 0, "Go"); // 删除所有"Go"元素
System.out.println("删除Go后列表：" + jedis.lrange("language", 0, -1));
}
}3.2.2 运行与测试
3.3 Set 类型：无序去重集合（Chapter3）
Set是基于哈希表实现的无序集合，自动去重（重复元素添加无效），支持交集、并集、差集等丰富的集合运算，适用于用户标签、好友列表、抽奖等场景。
核心操作：
- 基础操作：
sadd(key, member...)：向集合添加元素（重复元素自动忽略）；srem(key, member...)：删除集合中的指定元素；sismember(key, member)：判断元素是否在集合中；scard(key)：获取集合的元素个数；
- 补充高频操作：
smembers(key)：获取集合中所有元素（元素过多时慎用，会阻塞线程）；spop(key)：随机删除并返回一个元素（适用于抽奖场景）；sinter(key1, key2)：求两个集合的交集（如共同好友）；sunion(key1, key2)：求两个集合的并集（如合并好友列表）；sdiff(key1, key2)：求两个集合的差集（如 key1 中有但 key2 中没有的元素）；
3.3.1 具体实现
package com.hy.chapter3;
import redis.clients.jedis.Jedis;
import java.util.Set;
/**
* Chapter3类：Set类型操作（sadd、srem、sismember等）
*/
public class Chapter3 {
static Jedis jedis;
static {
jedis = new Jedis("127.0.0.1", 6379);
System.out.println("Redis连接成功：" + jedis);
}
public static void main(String[] args) {
setOperation();
jedis.close();
}
/**
* Set类型：基础操作 + 补充高频操作
*/
public static void setOperation() {
// 删除原有set，避免测试干扰
jedis.del("users", "users1", "users2");
// 基础操作1. sadd(key, member...)：向集合添加元素（重复元素自动忽略）
jedis.sadd("users", "李1", "李2", "李3", "李2"); // "李2"重复，仅添加1次
System.out.println("users集合所有元素（去重后）：" + jedis.smembers("users")); // 输出：[李1, 李2, 李3]
// 基础操作2. srem(key, member...)：删除集合中的指定元素
jedis.srem("users", "李3"); // 删除元素"李3"
System.out.println("删除李3后，users集合：" + jedis.smembers("users"));
// 基础操作3. sismember(key, member)：判断元素是否在集合中
boolean isLi2Exist = jedis.sismember("users", "李2");
System.out.println("李2是否在users集合中：" + isLi2Exist); // 输出：true
// 基础操作4. scard(key)：获取集合的元素个数
long userCount = jedis.scard("users");
System.out.println("users集合元素个数：" + userCount);
// 补充操作1. smembers(key)：获取集合中所有元素（元素过多时慎用，会阻塞线程）
// 补充操作2. spop(key)：随机删除并返回一个元素（抽奖场景常用）
String randomUser = jedis.spop("users");
System.out.println("随机删除的元素（抽奖中奖者）：" + randomUser);
System.out.println("抽奖后，users集合：" + jedis.smembers("users"));
// 补充操作3. 集合运算（交集、并集、差集）
// 准备测试数据
jedis.sadd("users1", "李1", "李2", "李4");
jedis.sadd("users2", "李2", "李3", "李4");
// sinter(key1, key2)：求交集（共同元素）
Set<String> commonUsers = jedis.sinter("users1", "users2");
System.out.println("users1和users2的共同元素（交集）：" + commonUsers); // 输出：[李2, 李4]
// sunion(key1, key2)：求并集（合并去重）
Set<String> allUsers = jedis.sunion("users1", "users2");
System.out.println("users1和users2的合并元素（并集）：" + allUsers);
// sdiff(key1, key2)：求差集（key1有、key2没有）
Set<String> diffUsers = jedis.sdiff("users1", "users2");
System.out.println("users1中有、users2中没有的元素（差集）：" + diffUsers); // 输出：[李1]
}
}3.3.2 运行与测试
3.4 Hash 类型：对象属性存储（Chapter4）
Hash是“键值对的集合”，底层以哈希表存储，适用于存储对象的多个属性（如用户信息、商品详情），无需序列化整个对象，可直接操作单个属性，灵活性极高。
核心操作：
- 基础操作：
hmset(key, hashMap)：批量存储对象属性；
- 补充高频操作：
hset(key, field, value)：存储单个对象属性；hget(key, field)：获取对象单个属性的值；hmget(key, field1, field2...)：批量获取对象多个属性的值；hdel(key, field...)：删除对象的指定属性；hkeys(key)：获取对象的所有属性名；hvals(key)：获取对象的所有属性值；hexists(key, field)：判断对象的某个属性是否存在；
3.4.1 具体实现
package com.hy.chapter4;
import redis.clients.jedis.Jedis;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Chapter4类：Hash类型操作（hmset等）
*/
public class Chapter4 {
static Jedis jedis;
static {
jedis = new Jedis("127.0.0.1", 6379);
System.out.println("Redis连接成功：" + jedis);
}
public static void main(String[] args) {
hashOperation();
jedis.close();
}
/**
* Hash类型：基础操作 + 补充高频操作
*/
public static void hashOperation() {
// 删除原有hash，避免测试干扰
jedis.del("user:100", "product:101");
// 基础操作1. hmset(key, hashMap)：批量存储对象属性
Map<String, String> userMap = new HashMap<>();
userMap.put("name", "kkkz");
userMap.put("age", "22");
userMap.put("gender", "男");
userMap.put("address", "北京");
jedis.hmset("user:100", userMap); // 存储用户100的所有属性
System.out.println("用户100的所有属性：" + jedis.hgetAll("user:100"));
// 补充操作1. hset(key, field, value)：存储单个对象属性
jedis.hset("user:100", "phone", "13800138000"); // 给用户100添加手机号属性
System.out.println("用户100添加手机号后：" + jedis.hgetAll("user:100"));
// 补充操作2. hget(key, field)：获取对象单个属性的值
String userName = jedis.hget("user:100", "name");
System.out.println("用户100的姓名：" + userName); // 输出：kkkz
// 补充操作3. hmget(key, field1, field2...)：批量获取对象多个属性的值
List<String> userInfo = jedis.hmget("user:100", "name", "age", "phone");
System.out.println("批量获取用户100的属性：" + userInfo); // 输出：[kkkz, 22, 13800138000]
// 补充操作4. hdel(key, field...)：删除对象的指定属性
jedis.hdel("user:100", "address"); // 删除用户100的address属性
System.out.println("删除address后，用户100的属性：" + jedis.hgetAll("user:100"));
// 补充操作5. hkeys(key)：获取对象的所有属性名
Set<String> userFields = jedis.hkeys("user:100");
System.out.println("用户100的所有属性名：" + userFields); // 输出：[name, age, gender, phone]
// 补充操作6. hvals(key)：获取对象的所有属性值
List<String> userValues = jedis.hvals("user:100");
System.out.println("用户100的所有属性值：" + userValues);
// 补充操作7. hexists(key, field)：判断对象的某个属性是否存在
boolean hasPhone = jedis.hexists("user:100", "phone");
System.out.println("用户100是否有phone属性：" + hasPhone); // 输出：true
}
}3.4.2 运行与测试
3.5 Zset 类型：有序分值集合（Chapter5）
Zset（有序集合）是Redis最强大的数据类型之一，兼具Set的去重特性与List的有序性，通过“分值（score）”排序，底层以跳表+哈希表实现，查询效率高（O(logN)），适用于积分排行榜、优先级任务队列等场景。
核心操作：
- 基础操作：
zadd(key, score, member...)：添加元素并指定分值；zrange(key, start, end)：按分值升序获取指定范围元素；
- 补充高频操作：
zrevrange(key, start, end)：按分值降序获取指定范围元素（如排行榜倒序）；zincrby(key, increment, member)：给元素的分值增加指定增量（如积分 + 10）；zscore(key, member)：获取元素的分值；zrank(key, member)：获取元素的升序排名；zrevrank(key, member)：获取元素的降序排名；zcard(key)：获取有序集合的元素个数；zrem(key, member...)：删除有序集合中的指定元素；
3.5.1 具体实现
package com.hy.chapter5;
import redis.clients.jedis.Jedis;
import java.util.List;
import java.util.Set;
/**
* Chapter5类：Zset类型操作（zadd、zrange等）
*/
public class Chapter5 {
static Jedis jedis;
static {
jedis = new Jedis("127.0.0.1", 6379);
System.out.println("Redis连接成功：" + jedis);
}
public static void main(String[] args) {
zsetOperation();
jedis.close();
}
/**
* Zset类型：基础操作 + 补充高频操作
*/
public static void zsetOperation() {
// 删除原有zset，避免测试干扰
jedis.del("scoreRank", "taskQueue");
// 基础操作1. zadd(key, score, member...)：添加元素并指定分值
jedis.zadd("scoreRank", 95.0, "李1");
jedis.zadd("scoreRank", 88.0, "李2");
jedis.zadd("scoreRank", 90.0, "李3");
jedis.zadd("scoreRank", 80.0, "李4");
// 输出升序排列的所有元素（默认按score升序）
System.out.println("积分排行榜（升序）：" + jedis.zrange("scoreRank", 0, -1));
// 基础操作2. zrange(key, start, end)：按分值升序获取指定范围元素
List<String> lowScore = jedis.zrange("scoreRank", 0, 1); // 获取分值最低的2个元素
System.out.println("积分最低的2个用户：" + lowScore);
// 补充操作1. zrevrange(key, start, end)：按分值降序获取指定范围元素（排行榜常用）
List<String> top3 = jedis.zrevrange("scoreRank", 0, 2); // 获取前3名（降序）
System.out.println("积分排行榜前3名（降序）：" + top3);
// 补充操作2. zincrby(key, increment, member)：给元素的分值增加指定增量（积分增加场景）
jedis.zincrby("scoreRank", 5.0, "李2"); // 李2积分+5，从88变为93
System.out.println("李2积分+5后，排行榜前3名：" + jedis.zrevrange("scoreRank", 0, 2));
// 补充操作3. zscore(key, member)：获取元素的分值
Double li1Score = jedis.zscore("scoreRank", "李1");
System.out.println("李1的积分：" + li1Score); // 输出：95.0
// 补充操作4. zrank(key, member)：获取元素的升序排名（从0开始）
long li2AscRank = jedis.zrank("scoreRank", "李2");
System.out.println("李2的升序排名（从0开始）：" + li2AscRank);
// 补充操作5. zrevrank(key, member)：获取元素的降序排名（从0开始）
long li1DescRank = jedis.zrevrank("scoreRank", "李1");
System.out.println("李1的降序排名（从0开始）：" + li1DescRank); // 输出：0（第一名）
// 补充操作6. zcard(key)：获取有序集合的元素个数
long rankCount = jedis.zcard("scoreRank");
System.out.println("积分排行榜总人数：" + rankCount);
// 补充操作7. zrem(key, member...)：删除有序集合中的指定元素
jedis.zrem("scoreRank", "李4"); // 删除李4
System.out.println("删除李4后，排行榜：" + jedis.zrevrange("scoreRank", 0, -1));
}
}3.5.2 运行与测试
汇聚全球AI编程工具，助力开发者即刻编程。
更多推荐
11
0- 0
已为社区贡献6条内容
所有评论(0)