当前位置：首页 > news >正文

Redis客户端（Jedis、RedisTemplate、Redisson）

news 文章来源：https://blog.csdn.net/weixin_44929475/article/details/144362955 2025/1/11 5:46:02

1. 简介

Redis作为一个当下很火热的非关系型数据库，Java从业人员基本都离不开对Redis的使用。在Java程序中该数据库，需要借助于市面上的开源客户端，如Jedis、Spring Data Redis、Redisson，它们可以作为操作Redis非关系型数据库的桥梁。

2. 实例

2.1 Jedis

Jedis 是一个用 Java 编写的 Redis 客户端库，它提供了丰富的 API 来访问 Redis 支持的所有数据结构。Jedis 是同步的和阻塞的，这意味着在执行操作时，当前线程会被阻塞直到操作完成。

2.1.1 添加依赖

在Spring中集成Jedis。

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId>
</dependency>
<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId>
</dependency>

2.1.2 添加配置

application.yml：

spring:redis:host: 116.198.242.56port: 26379
server:port: 8999

生成bean：

package com.xiaokai.config;import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.Jedis;/*** Author:yang* Date:2024-12-09 13:42*/
@Component
public class JedisConfig {@Value("${spring.redis.host}")private String host;@Value("${spring.redis.port}")private int port;@Beanpublic Jedis jedisClient() {Jedis jedis = new Jedis(new HostAndPort(host, port));return jedis;}
}

2.1.3 测试

package com.xiaokai;import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;
import redis.clients.jedis.Jedis;/*** Author:yang* Date:2024-12-09 10:58*/
@SpringBootTest(classes = Application.class)
@RunWith(SpringRunner.class)
@Slf4j
public class ApiTest {@Autowiredprivate Jedis jedisClient;@Testpublic void testJedis() {String s = jedisClient.set("jedis", "jedis");log.info("设置成功：{}", s);String value = jedisClient.get("jedis");log.info("获取成功：{}", value);}
}# 设置成功：OK
# 获取成功：jedis

可以看到Redis中已经存下了当前key-value

127.0.0.1:6379> get jedis
"jedis"

2.1.4 Jedis API

2.1.4.1 连接与断开连接

Jedis jedis = new Jedis("localhost", 6379);：创建一个新的 Jedis 实例连接到本地的 Redis 服务器。
jedis.connect();：建立连接（现在这个步骤通常是自动的，不建议手动调用）。
jedis.disconnect();：断开连接。

2.1.4.2 键操作

jedis.exists(String key);：检查给定的键是否存在。
jedis.del(String key);：删除给定的键。
jedis.keys(String pattern);：返回匹配给定模式的所有键。
jedis.ttl(String key);：返回给定键的剩余生存时间（以秒为单位）。

2.1.4.3 字符串（String）操作

jedis.set(String key, String value);：设置键的值。
jedis.get(String key);：获取与给定键相关联的值。
jedis.append(String key, String value);：将值追加到键的当前值。
jedis.incr(String key);：将键的值增加 1。
jedis.decr(String key);：将键的值减少 1。

2.1.4.4 列表（List）操作

jedis.lpush(String key, String... values);：将一个或多个值插入到列表的头部。
jedis.rpush(String key, String... values);：将一个或多个值插入到列表的尾部。
jedis.lpop(String key);：移除并返回列表的第一个元素。
jedis.rpop(String key);：移除并返回列表的最后一个元素。
jedis.lrange(String key, long start, long end);：返回列表中指定范围内的元素。

2.1.4.5 集合（Set）操作

jedis.sadd(String key, String... members);：向集合添加一个或多个成员。
jedis.smembers(String key);：返回集合中的所有成员。
jedis.srem(String key, String... members);：移除集合中的一个或多个成员。
jedis.sismember(String key, String member);：检查成员是否是集合的成员。

2.1.4.6 有序集合（Sorted Set）操作

jedis.zadd(String key, double score, String member);：向有序集合添加一个成员。
jedis.zrange(String key, long start, long end);：返回有序集合中指定范围内的成员。
jedis.zrem(String key, String... members);：移除有序集合中的一个或多个成员。
jedis.zscore(String key, String member);：返回成员的分数。

2.1.4.7 哈希（Hash）操作

jedis.hset(String key, String field, String value);：将哈希表的字段设置为值。
jedis.hget(String key, String field);：获取哈希表中字段的值。
jedis.hgetAll(String key);：获取哈希表中所有的字段和值。
jedis.hdel(String key, String... fields);：删除哈希表中的一个或多个字段。

2.1.4.8 发布/订阅（Pub/Sub）操作

jedis.publish(String channel, String message);：发布消息到频道。
JedisPubSub jedisPubSub = new JedisPubSub() {...};：创建一个新的 JedisPubSub 实例来订阅频道。

2.1.4.9 事务

jedis.multi();：开始一个事务。
jedis.exec();：执行事务。

2.1.4.10 脚本

jedis.eval(String script, int keyCount, String... params);：执行 Lua 脚本。

2.2 Spring Data Redis

Spring Data Redis 是 Spring 提供的一套操作 Redis 的抽象，它包括 RedisTemplate 和 StringRedisTemplate 等模板类，简化了 Redis 的操作。Spring Data Redis 默认使用 Lettuce 作为客户端，但也支持 Jedis。

2.2.1 添加依赖

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

2.2.2 添加配置

application.yml：

spring:redis:host: 116.198.242.56port: 26379
server:port: 8999

序列化配置：

import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.DefaultBaseTypeLimitingValidator;
import com.fasterxml.jackson.databind.jsontype.impl.StdTypeResolverBuilder;@Configuration
public class RedisConfig {@Beanpublic RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {RedisTemplate<String, Object> template = new RedisTemplate<>();template.setConnectionFactory(connectionFactory);// 使用StringRedisSerializer来序列化keyStringRedisSerializer stringRedisSerializer = new StringRedisSerializer();template.setKeySerializer(stringRedisSerializer);template.setHashKeySerializer(stringRedisSerializer);// 使用Jackson2JsonRedisSerializer来序列化valueJackson2JsonRedisSerializer<Object> jsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);ObjectMapper objectMapper = new ObjectMapper();// 配置ObjectMapper以处理多态objectMapper.activateDefaultTyping(objectMapper.getPolymorphicTypeValidator(),ObjectMapper.DefaultTyping.NON_FINAL,JsonTypeInfo.As.PROPERTY);objectMapper.setDefaultTyping(new ObjectMapper.DefaultTypeResolverBuilder(ObjectMapper.DefaultTyping.NON_FINAL,new DefaultBaseTypeLimitingValidator(Object.class)).init(null,Jackson2JsonRedisSerializer.Typing.NON_FINAL,null).inclusion(JsonTypeInfo.As.PROPERTY));jsonRedisSerializer.setObjectMapper(objectMapper);template.setValueSerializer(jsonRedisSerializer);template.setHashValueSerializer(jsonRedisSerializer);template.afterPropertiesSet();return template;}
}

注：如果不设置序列化器，默认使用jdk序列化，存储的key为\xac\xed\x00\x05t\x00\x04test

2.2.3 测试

@SpringBootTest(classes = Application.class)
@RunWith(SpringRunner.class)
@Slf4j
public class ApiTest {@Autowiredprivate RedisTemplate redisTemplate;@Testpublic void testRedis() {try{redisTemplate.opsForValue().set("test", "test");log.info("设置成功");}catch (Exception e){log.error("设置失败", e);}String test = (String) redisTemplate.opsForValue().get("test");log.info("获取成功：{}", test);String bless = (String) redisTemplate.opsForValue().get("Bless");log.info("获取成功：{}", bless);}@Testpublic void testRedisList() {redisTemplate.opsForList().leftPush("list", "1");redisTemplate.opsForList().leftPush("list", "2");redisTemplate.opsForList().leftPush("list", "3");String list = (String) redisTemplate.opsForList().rightPop("list");log.info("获取成功：{}", list);}@Testpublic void testRedisMap() {redisTemplate.opsForHash().put("user", "key1", "value1");}
}

注：RedisTemplate可以直接使用，不需要去生成一个专有bean。

2.2.4 相关API

2.2.4.1 设置和获取键值

set(key, value)：设置键值。
opsForValue().set(key, value)：设置字符串（简单值）。
opsForValue().get(key)：获取字符串值。
opsForValue().getAndSet(key, value)：将旧的值替换为新的值，并返回旧的值。

2.2.4.2 过期时间操作

expire(key, timeout, unit)：设置键的过期时间。
getExpire(key)：返回键的剩余过期时间。
getExpire(key, unit)：返回剩余过期时间并且指定时间单位。

2.2.4.3 键的操作

hasKey(key)：判断键是否存在。
delete(key)：删除单个键。
delete(Collection<K> keys)：批量删除键。
keys(pattern)：查找匹配的键值，返回一个 Set 集合类型。

2.2.4.4 列表操作

opsForList().leftPush(key, value)：在列表左侧插入值。
opsForList().rightPush(key, value)：在列表右侧插入值。
opsForList().multiGet(keys)：批量获取列表中的值。

2.2.4.5集合操作

opsForSet().add(key, value)：向集合中添加元素。
opsForSet().members(key)：获取集合中的所有成员。

2.2.4.6 有序集合操作

opsForZSet().add(key, value, score)：向有序集合中添加元素。
opsForZSet().range(key, start, end)：获取有序集合中指定范围的元素。

2.2.4.7 哈希操作

opsForHash().put(key, hashKey, hashValue)：向哈希中添加键值对。
opsForHash().entries(key)：获取哈希中的所有键值对。

2.2.4.8 地理空间操作

opsForGeo().add(key, geoLocation)：向地理空间添加位置。
opsForGeo().radius(key, circle)：根据半径查询地理空间中的位置。

2.2.4.9 事务操作

execute(SessionCallback action)：执行 Redis 事务。

2.2.4.10 流操作

opsForStream().add(record)：向 Redis 流中添加记录。
opsForStream().read(recordClass, StreamOffset)：从 Redis 流中读取记录。

2.3 Redisson

Redisson 是一个基于 Java 的 Redis 客户端库，它提供了多种分布式数据结构和服务，如分布式锁、原子变量、集合等。Redisson 支持多种 Redis 模式，包括单机、主从、集群和哨兵模式。

2.3.1 添加依赖

<dependency><groupId>org.redisson</groupId><artifactId>redisson-spring-boot-starter</artifactId><version>3.17.6</version>
</dependency>

2.3.2 添加配置

application.yml（使用配置文件）

spring:redis:host: 116.198.242.56port: 26379
server:port: 8999

2.3.3 测试

@SpringBootTest(classes = Application.class)
@RunWith(SpringRunner.class)
@Slf4j
public class ApiTest {@Autowiredprivate RedissonClient redissonClient;@Testpublic void testRedissonClient() {RBucket<String> bucket = redissonClient.getBucket("test");bucket.set("test");log.info("设置成功");String test = bucket.get();log.info("获取成功：{}", test);RBucket<Object> bless = redissonClient.getBucket("Bless");bless.set("Bless");String value = (String) bless.get();log.info("获取成功：{}", value);}}

注：

配置文件不需要额外的bean可以直接使用。
编程式使用：

单机模式

Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:6379").setPassword("password").setDatabase(0);
RedissonClient redisson = Redisson.create(config);

集群模式

Config config = new Config();
ClusterServersConfig clusterConfig = config.useClusterServers().addNodeAddress("redis://127.0.0.1:7000", "redis://127.0.0.1:7001").addNodeAddress("redis://127.0.0.1:7002");
clusterConfig.setPassword("password");
RedissonClient redisson = Redisson.create(config);

2.3.4 相关API

2.3.4.1 连接与断开连接

// 创建 Redisson 客户端实例，默认连接到本地的 Redis 服务器
RedissonClient redisson = Redisson.create();// 断开连接
redisson.shutdown();

2.3.4.2 键操作

// 检查给定的键是否存在
boolean exists = redisson.getKeys().exists("key");// 删除给定的键
redisson.getKeys().delete("key");// 返回匹配给定模式的所有键
Set<String> keys = redisson.getKeys().getKeysByPattern("pattern");// 返回给定键的剩余生存时间（以秒为单位）
long ttl = redisson.getKeys().getTTL("key");

2.3.4.3 字符串（String）操作

// 设置键的值
RBucket<String> bucket = redisson.getBucket("key");
bucket.set("value");// 获取与给定键相关联的值
String value = bucket.get();// 将值追加到键的当前值
long length = bucket.append("value");// 将键的值增加 1
RAtomicLong atomicLong = redisson.getAtomicLong("key");
atomicLong.increment();// 将键的值减少 1
atomicLong.decrement();

2.3.4.4 列表（List）操作

// 将一个或多个值插入到列表的头部
RList<String> list = redisson.getList("list");
list.leftPush("value");// 将一个或多个值插入到列表的尾部
list.rightPush("value");// 移除并返回列表的第一个元素
String element = list.leftPop();// 移除并返回列表的最后一个元素
element = list.rightPop();// 返回列表中指定范围内的元素
List<String> range = list.range(0, -1);

2.3.4.5 集合（Set）操作

// 向集合添加一个或多个成员
RSet<String> set = redisson.getSet("set");
set.add("value");// 返回集合中的所有成员
Set<String> members = set.readAll();// 移除集合中的一个或多个成员
set.remove("value");// 检查成员是否是集合的成员
boolean isMember = set.contains("value");

2.3.4.6 有序集合（Sorted Set）操作

// 向有序集合添加一个成员
RScoredSortedSet<String> sortedSet = redisson.getScoredSortedSet("sortedSet");
sortedSet.add(10.0, "value");// 返回有序集合中指定范围内的成员
List<String> range = sortedSet.getValues(0, -1);// 移除有序集合中的一个或多个成员
sortedSet.remove("value");// 返回成员的分数
Double score = sortedSet.getScore("value");

2.3.4.7 哈希（Hash）操作

// 将哈希表的字段设置为值
RMap<String, String> map = redisson.getMap("map");
map.fastPut("field", "value");// 获取哈希表中字段的值
String value = map.get("field");// 获取哈希表中所有的字段和值
Map<String, String> entries = map.readAllMap();// 删除哈希表中的一个或多个字段
map.fastRemove("field");

2.3.4.8 发布/订阅（Pub/Sub）操作

// 发布消息到频道
RTopic<String> topic = redisson.getTopic("channel");
topic.publish("message");// 创建一个新的订阅实例来订阅频道
topic.addListener(String.class, (channel, message) -> {System.out.println("Received message: " + message);
});

2.3.4.9 事务

// 开始一个事务
TransactionResult result = redisson.multi();// 执行事务中的所有命令
result.exec();

2.3.4.10 脚本

// 执行 Lua 脚本
RScript script = redisson.getScript();
RObject eval = script.eval(RScript.Mode.READ_ONLY, "return redis.call('get', KEYS[1])", RScript.ReturnType.VALUE, "myKey");