【入门篇】1.2 Redis 客户端之 Jedis 详解和示例

文章目录

1. 简介
2. Jedis的依赖
- - 下载Jedis
  - 导入Jedis jar包
  - 配置Redis服务器的地址和端口
3. Jedis 的基本操作
- - 连接 Redis 服务器
  - 设置和获取字符串类型的键值对
  - 判断键是否存在
  - 删除键
  - 设置键的过期时间
4. Jedis 的数据类型操作
- - 字符串类型
  - 列表类型
  - 集合类型
  - 哈希类型
  - 有序集合类型
5. Jedis 的事务操作
- - 开启和提交事务。
  - 回滚事务。
  - 监视键。
6. Jedis 的发布订阅操作
- - 发布消息。
  - 订阅消息。
7. Jedis 的管道操作
8. Jedis 的连接池配置和使用
9. Jedis 的异常处理
- 1. 处理连接异常
- 2. 处理命令执行异常：
10. Jedis 的性能优化
11. 示例代码

1. 简介

Jedis 是一个流行的 Java 编写的 Redis 客户端库，它提供了连接和操作 Redis 服务器的功能。Jedis具有以下特点：

简单易用：Jedis 提供了简洁的 API，方便开发人员使用，减少了连接和操作 Redis 的复杂性。
高性能：Jedis 是通过直接与 Redis 服务器进行通信来实现操作的，因此具有较高的性能。
支持多种数据类型：Jedis 支持操作 Redis 的各种数据类型，包括字符串、哈希、列表、集合、有序集合等。
支持事务和管道：Jedis 提供了事务和管道的支持，可以将多个操作打包成一个原子操作，提高了操作的效率。
支持连接池：Jedis 支持连接池，可以复用连接，避免频繁建立和关闭连接的开销，提高了性能。

Jedis 是一个功能强大、易用性高的 Redis 客户端库，适用于 Java 开发人员在项目中连接和操作 Redis 服务器。接下来，将介绍 Jedis 的使用方法和示例。

2. Jedis的依赖

下载Jedis

首先，下载 Jedis。Jedis 的源代码托管在 Github 上，可以直接从这里获取。也可以通过 Maven 或 Gradle 添加 Jedis 的依赖。在的 pom.xml 或者 build.gradle 文件中添加以下内容：

对于 Maven，添加以下依赖：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>最新版本号</version>
</dependency>

对于 Gradle，添加以下依赖：

dependencies {
    implementation 'redis.clients:jedis:最新版本号'
}

Jedis是Java语言的Redis客户端库，它的版本号可以通过查看Jedis的Maven依赖或者JAR包的版本信息来获取。以下是一些常见的Jedis版本号范例：

Jedis 2.x版本：例如2.10.0、2.9.0等。
Jedis 3.x版本：例如3.6.0、3.5.2等。

请替换 最新版本号 为最新的 Jedis 版本号。

导入Jedis jar包

如果不使用 Maven 或 Gradle 进行项目管理，需要手动下载 Jedis 的 jar 文件，并将其添加到项目的类路径中。需要下载 Jedis 的 Jar 包并导入到项目中。可以在以下网址下载 Jedis Jar 包：https://github.com/xetorthio/jedis/releases

配置Redis服务器的地址和端口

在 Java 程序中，需要提供 Redis 服务器的地址和端口，以便 Jedis 能够连接到 Redis。以下是一段示例代码：

import redis.clients.jedis.Jedis;

public class Main {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        // 测试连接
        System.out.println("Connection Successful");
        System.out.println("Server is running: "+jedis.ping());
    }
}

创建了一个新的 Jedis 对象，然后提供了 Redis 服务器的地址（“localhost”）和默认端口（6379）。然后，调用 jedis.ping() 来测试与 Redis 服务器的连接。
如果 Redis 服务器需要密码验证，可以在连接时添加密码参数：

Jedis jedis = new Jedis("localhost", 6379);
jedis.auth("password");

其中，“password” 是 Redis 服务器的密码。

配置完成后，就可以通过 Jedis 连接和操作 Redis 服务器了。接下来，将介绍 Jedis 的常用操作方法和示例。

3. Jedis 的基本操作

连接 Redis 服务器

在 Java 程序中，使用 Jedis 对象来连接到 Redis 服务器。这里是一个例子：

import redis.clients.jedis.Jedis;

public class Main {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost", 6379);
        System.out.println("Connection Successful");
        System.out.println("Server is running: "+jedis.ping());
    }
}

设置和获取字符串类型的键值对

以下是如何使用 Jedis 的 set 和 get 方法来设置和获取字符串类型的键值对的例子：

jedis.set("mykey", "myvalue");
String value = jedis.get("mykey");
System.out.println("Stored string in redis:: " + value);

判断键是否存在

可以使用 exists 方法来检查一个键是否存在。以下是一个例子：

boolean keyExists = jedis.exists("mykey");
System.out.println("Does key 'mykey' exists? " + keyExists);

删除键

可以使用 del 方法来删除一个键。以下是一个例子：

jedis.del("mykey");

设置键的过期时间

可以使用 expire 方法来为一个键设置过期时间（以秒为单位）。以下是一个例子：

jedis.set("mykey", "myvalue");
jedis.expire("mykey", 60);  // 这个键将在60秒后过期

4. Jedis 的数据类型操作

字符串类型

字符串类型：

jedis.set("key", "value"); // 设置字符串类型的键值对
String value = jedis.get("key"); // 获取字符串类型的键对应的值

// 批量设置字符串类型的键值对
jedis.mset("key1", "value1", "key2", "value2");

// 批量获取字符串类型的键对应的值
List<String> values = jedis.mget("key1", "key2");

设置和获取字符串类型的键值对：

jedis.set("mykey", "myvalue");
String value = jedis.get("mykey");
System.out.println("Stored string in redis:: " + value);

批量设置和获取键值对：

jedis.mset("key1", "value1", "key2", "value2");
List<String> values = jedis.mget("key1", "key2");

列表类型

// 添加元素到列表头部和尾部
jedis.lpush("list", "element1", "element2"); // 头部添加
jedis.rpush("list", "element3", "element4"); // 尾部添加

// 获取列表的长度
Long length = jedis.llen("list");

// 获取指定范围内的元素
List<String> elements = jedis.lrange("list", 0, -1); // 获取所有元素

添加元素到列表头部和尾部：

jedis.lpush("mylist", "element1", "element2");
jedis.rpush("mylist", "element3");

获取列表的长度：

Long length = jedis.llen("mylist");

获取指定范围内的元素：

List<String> elements = jedis.lrange("mylist", 0, -1);

集合类型

// 添加元素到集合
jedis.sadd("set", "element1", "element2");

// 获取集合的大小
Long size = jedis.scard("set");

// 判断元素是否存在于集合中
boolean exists = jedis.sismember("set", "element1");

添加元素到集合：

jedis.sadd("myset", "element1", "element2");

获取集合的大小：

Long size = jedis.scard("myset");

判断元素是否存在于集合中：

boolean exists = jedis.sismember("myset", "element1");

哈希类型

// 设置和获取哈希字段的值
jedis.hset("hash", "field1", "value1");
String value = jedis.hget("hash", "field1");

// 获取哈希中所有字段和值
Map<String, String> hash = jedis.hgetAll("hash");

设置和获取哈希字段的值：

jedis.hset("myhash", "field1", "value1");
String value = jedis.hget("myhash", "field1");

获取哈希中所有字段和值：

Map<String, String> allFieldsAndValues = jedis.hgetAll("myhash");

有序集合类型

// 添加元素到有序集合
jedis.zadd("zset", 1, "member1");
jedis.zadd("zset", 2, "member2");

// 获取有序集合的成员和分数
Set<Tuple> membersWithScores = jedis.zrangeWithScores("zset", 0, -1);

// 根据分数范围获取有序集合的成员
Set<String> membersInRange = jedis.zrangeByScore("zset", 1, 2);

添加元素到有序集合：

jedis.zadd("myzset", 1, "element1");
jedis.zadd("myzset", 2, "element2");

获取有序集合的成员和分数：

Set<String> elements = jedis.zrange("myzset", 0, -1);

根据分数范围获取有序集合的成员：

Set<String> elements = jedis.zrangeByScore("myzset", 1, 2);

5. Jedis 的事务操作

Jedis是Redis的Java客户端库，它提供了丰富的API来操作Redis数据库。在Jedis中，可以使用事务操作来执行一系列的Redis命令，并保证这些命令的原子性。

开启和提交事务。

在 Jedis 中，可以使用 multi() 方法来开启一个事务，然后使用 exec() 方法来提交事务。在这两个方法之间的所有命令都会被放入事务队列中，等待 exec() 方法的调用。

Transaction t = jedis.multi();
t.set("foo", "bar");
t.exec();

回滚事务。

Jedis 提供了 discard() 方法来回滚事务。注意，只有当在调用 multi() 方法之后，还没有调用 exec() 方法之前，才可以调用 discard() 方法。

Transaction t = jedis.multi();
t.set("foo", "bar");
t.discard();

监视键。

watch() 方法可以用来监视一个或多个键，如果在事务执行之前这些键被其他命令所改变，那么事务将被打断。

jedis.watch("foo");
Transaction t = jedis.multi();
t.set("foo", "bar");
t.exec();

如果 “foo” 这个键在事务执行之前被其他命令改变了，那么 exec() 方法将返回 null。

6. Jedis 的发布订阅操作

Jedis是提供了丰富的功能来与Redis进行交互。其中，发布订阅是Jedis库的一项重要功能，允许客户端在订阅频道时接收发布到频道的消息。

发布消息。

在 Jedis 中，可以使用 publish() 方法来发布消息。第一个参数是频道的名称，第二个参数是消息的内容。

Jedis jedis = new Jedis("localhost", 6379);
String channel = "myChannel";
String message = "Hello subscribers!";
jedis.publish(channel, message);
jedis.close();

订阅消息。

订阅消息需要创建一个 JedisPubSub 对象，并重写它的 onMessage() 方法。然后使用 subscribe() 方法来订阅一个或多个频道。

Jedis jedis = new Jedis("localhost", 6379);
JedisPubSub jedisPubSub = new JedisPubSub() {
    @Override
    public void onMessage(String channel, String message) {
        System.out.println("Received message: " + message + " from channel: " + channel);
    }
};
String channel = "myChannel";
jedis.subscribe(jedisPubSub, channel);
jedis.close();

定义了一个JedisPubSub对象，该对象覆盖了onMessage方法，用于处理接收到的消息。然后，指定要订阅的频道名称，并使用subscribe方法进行订阅。

需要注意的是，subscribe方法是阻塞的，它会一直等待直到接收到消息。因此，在实际应用中，通常会将订阅操作放在单独的线程中进行，以避免阻塞主线程。

在订阅消息后，如果需要取消订阅，可以使用unsubscribe方法。

jedis.unsubscribe(jedisPubSub, channel);

7. Jedis 的管道操作

Jedis提供了管道（pipeline）操作来批量执行多个命令，以减少网络延迟和提高性能。管道操作允许在客户端一次性发送多个命令到Redis服务器，并在服务器端依次执行这些命令，最后将结果一次性返回给客户端。

使用Jedis进行管道操作的步骤如下：

创建Jedis对象：首先，创建一个Jedis对象来与Redis服务器进行通信。
开启管道：通过调用Jedis对象的pipelined()方法来开启管道。
执行命令：使用Jedis对象执行需要批量执行的命令。可以使用Jedis对象的各种命令方法，如set()、get()等。
提交管道：通过调用Jedis对象的sync()方法来提交管道操作。这将一次性将所有命令发送到Redis服务器执行，并返回所有命令的结果。
关闭Jedis对象：最后，记得关闭Jedis对象以释放资源。
在Jedis中，可以使用管道（Pipeline）来批量执行多个命令，以提高命令执行的效率。管道通过将多个命令打包在一起发送到Redis服务器，从而减少了网络I/O的开销。

使用Jedis管道的简单示例：

Pipeline pipeline = jedis.pipelined();

for (int i = 0; i < 100; i++) {
    pipeline.set("key" + i, "value" + i);
}

pipeline.sync();

创建了一个Pipeline对象，然后连续调用了100次set()方法。调用sync()方法会将之前调用的所有命令一次性发送到Redis服务器。

管道中的命令不保证原子性，也就是说，如果管道中的某个命令执行失败，不会影响到其他命令的执行。如果需要保证一组命令的原子性，应该使用Redis的事务功能。

此外，管道中的命令默认是不会立即返回结果的，如果需要获取命令的返回结果，可以使用syncAndReturnAll()方法来替代sync()方法。这将返回一个List，其中包含了管道中每个命令的返回结果。

使用Jedis进行管道操作的示例代码

创建了一个Jedis对象，并通过调用pipelined()方法开启了管道。执行三个命令：设置一个字符串类型的键值对、获取该键的值，以及设置一个哈希类型的字段值对。最后，通过调用syncAndReturnAll()方法提交管道操作，并返回了所有命令的结果。
可以通过遍历结果列表来处理每个命令的返回值。最后，记得关闭Jedis对象以释放资源。

Jedis jedis = new Jedis("localhost", 6379);
Pipeline pipeline = jedis.pipelined();

// 执行多个命令
pipeline.set("key1", "value1");
pipeline.get("key1");
pipeline.hset("hashKey", "field1", "value2");

// 提交管道
List<Object> results = pipeline.syncAndReturnAll();

// 处理结果
for (Object result : results) {
    System.out.println(result);
}

// 关闭Jedis对象
jedis.close();

使用管道操作可以显著提高性能，特别是在需要批量执行多个命令时。然而，需要注意的是，管道操作是无法使用事务的。如果需要支持事务操作，可以考虑使用Redis的事务功能。

8. Jedis 的连接池配置和使用

在实际使用中，通常会使用连接池来管理Jedis连接。Jedis的连接池使用Apache Commons Pool2实现。
配置和使用Jedis连接池的示例：

创建了一个JedisPoolConfig对象，并设置了各种连接池参数。然后使用这个配置对象，以及Redis服务器的地址和端口，创建了一个JedisPool对象。

在需要使用Jedis连接的地方，使用getResource()方法从连接池中获取一个Jedis连接。这个连接使用完毕后，Jedis会自动将其归还到连接池中。

注意，在获取Jedis连接时，使用了Java的try-with-resources语句，这样可以确保无论是否发生异常，Jedis连接都会被正确关闭。

配置连接池参数：

JedisPoolConfig poolConfig = new JedisPoolConfig();
// 最大连接数
poolConfig.setMaxTotal(128);
// 最大空闲连接数
poolConfig.setMaxIdle(64);
// 最小空闲连接数
poolConfig.setMinIdle(10);
// 获取连接时的最大等待毫秒数
poolConfig.setMaxWaitMillis(2000);
// 在获取连接的时候检查有效性
poolConfig.setTestOnBorrow(true);

创建Jedis连接池：

JedisPool jedisPool = new JedisPool(poolConfig, "localhost", 6379);

从连接池中获取Jedis连接：

try (Jedis jedis = jedisPool.getResource()) {
    // 使用Jedis连接执行命令
    jedis.set("key", "value");
    System.out.println(jedis.get("key"));
} catch (Exception e) {
    // 异常处理
}

9. Jedis 的异常处理

处理Jedis连接或命令执行异常的一般方法是使用try/catch块来捕获并处理这些异常。
在使用Jedis时，我们需要对连接异常和命令执行异常进行适当的处理。

1. 处理连接异常

在创建连接池对象时，可以设置连接超时时间和读写超时时间，以及设置连接失败重试次数。
在获取Jedis连接对象时，可以捕获JedisConnectionException异常来处理连接异常，例如重新获取连接或进行其他操作。
在使用Jedis连接对象进行Redis操作时，如果发生连接异常，可以捕获JedisConnectionException异常，并根据具体情况进行处理，例如重新获取连接或进行其他操作。

示例代码如下：

JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(100);
config.setMaxIdle(50);
config.setMinIdle(10);
config.setTestOnBorrow(true);
config.setTestOnReturn(true);

JedisPool jedisPool = new JedisPool(config, "localhost", 6379, 5000, "password");

Jedis jedis = null;
try {
    jedis = jedisPool.getResource();
    // 进行Redis操作
} catch (JedisConnectionException e) {
    // 处理连接异常，例如重新获取连接或进行其他操作
} finally {
    if (jedis != null) {
        jedis.close();
    }
}

Jedis连接异常通常是由于网络问题或者Redis服务器问题引起的。当尝试获取一个Jedis连接，或者使用一个已经获取的连接进行操作时，都可能触发这种异常。

2. 处理命令执行异常：

当尝试执行一个无效的Redis命令，或者传递给命令的参数不正确时，Jedis会抛出一个JedisDataException。

Jedis jedis = new Jedis("localhost", 6379);
try {
    jedis.hset("key", "field", "value");
} catch (JedisDataException e) {
    // 命令执行异常处理
} finally {
    jedis.close();
}

如果hset命令的参数不正确，例如key不存在，或者field已经存在，那么会抛出一个JedisDataException。需要捕获并处理这个异常。

在使用Jedis连接对象执行Redis命令时，可能会发生JedisDataException异常，例如命令格式不正确或参数类型不匹配等。
在使用Jedis连接对象执行Redis命令时，也可能会发生JedisException异常，例如Redis服务器出现问题或连接被关闭等。
在捕获这些异常时，可以根据具体情况进行处理，例如打印错误信息、回滚事务或进行其他操作。

示例代码如下：

try {
    jedis.set("key", "value");
} catch (JedisDataException e) {
    // 处理命令执行异常，例如命令格式不正确或参数类型不匹配等
} catch (JedisException e) {
    // 处理命令执行异常，例如Redis服务器出现问题或连接被关闭等
}

10. Jedis 的性能优化

使用连接池：在并发环境下，频繁地建立和释放连接会消耗大量的系统资源，影响应用性能。Jedis提供了连接池功能，可以复用已经建立的连接，减少连接的开销。

JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost");
Jedis jedis = null;
try {
    jedis = pool.getResource();
    // 使用jedis进行Redis操作
} finally {
    if (jedis != null) {
        jedis.close(); // 实际上是将连接返还给连接池，而不是关闭连接
    }
}

批量执行命令：如果需要执行多个Redis命令，那么可以使用Jedis的管道（Pipeline）功能，一次性发送所有命令，然后一次性接收所有结果。这样可以避免每次命令执行都需要进行一次网络通信。

Jedis jedis = new Jedis("localhost");
Pipeline pipeline = jedis.pipelined();
pipeline.set("key1", "value1");
pipeline.set("key2", "value2");
pipeline.sync();

在上述代码中，两个set命令会一次性发送到Redis服务器，然后sync方法会一次性接收两个命令的结果。这样可以避免每次命令执行都需要进行一次网络通信，减少了网络开销。

使用正确的数据结构和命令：Redis提供了多种数据结构和命令，根据具体的业务需求，选择最合适的数据结构和命令，可以大大提高性能。
避免长时间操作：对于耗时较长的操作，尽量避免在主线程中执行，可以考虑使用异步处理或者使用多线程处理。
适当使用持久化：根据业务需求，可以选择适当的持久化策略，例如RDB或者AOF。RDB性能较高，但是可能会丢失最近一段时间的数据；AOF性能较低，但是数据更安全。
尽量避免使用Keys命令：Keys命令会遍历整个数据库，对性能影响较大。尽量使用Scan命令代替。

11. 示例代码

pom.xml文件

 
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.3.0</version> <!-- 可以使用最新版本 -->
    </dependency>

代码示例

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.Pipeline;

public class JedisExample {
    public static void main(String[] args) {
        // 创建Jedis实例，连接本地Redis
        Jedis jedis = new Jedis("localhost");
        
        // 设置键值
        jedis.set("key", "value");
        // 获取键值
        System.out.println(jedis.get("key"));

        // 使用连接池
        JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost");
        Jedis jedisFromPool = null;
        try {
            jedisFromPool = pool.getResource();
            // 使用jedisFromPool进行Redis操作
            jedisFromPool.set("key1", "value1");
            System.out.println(jedisFromPool.get("key1"));
        } finally {
            if (jedisFromPool != null) {
                jedisFromPool.close();  // 实际上是将连接返还给连接池，而不是关闭连接
            }
        }

        // 使用Pipeline
        Pipeline pipeline = jedis.pipelined();
        pipeline.set("key2", "value2");
        pipeline.set("key3", "value3");
        pipeline.sync(); // 一次性发送所有命令

        // 关闭Jedis
        jedis.close();
    }
}