Redis客户端（Jedis、RedisTemplate、Redisson）

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");