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.56 port: 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; @Bean public 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 { @Autowired private Jedis jedisClient; @Test public 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.56 port: 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 { @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(connectionFactory); // 使用StringRedisSerializer来序列化key StringRedisSerializer stringRedisSerializer = new StringRedisSerializer(); template.setKeySerializer(stringRedisSerializer); template.setHashKeySerializer(stringRedisSerializer); // 使用Jackson2JsonRedisSerializer来序列化value Jackson2JsonRedisSerializer<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 { @Autowired private RedisTemplate redisTemplate; @Test public 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); } @Test public 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); } @Test public 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.56 port: 26379 server: port: 8999

2.3.3 测试

@SpringBootTest(classes = Application.class) @RunWith(SpringRunner.class) @Slf4j public class ApiTest { @Autowired private RedissonClient redissonClient; @Test public 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");