百度360必应搜狗淘宝本站头条
php redisredis 命令redis 锁redis 主从redis 删除
当前位置：网站首页 > 技术教程 > 正文

Redis进阶十二之Lettuce使用技巧详解

mhr18 2024-12-05 15:04 19 浏览 0 评论

前言

Lettuce 是 Redis 的一款高级 Java 客户端，与 Jedis 并列成为最热门的客户端之一，目前已成为 SpringBoot 2.0 版本默认的 Redis 客户端。

相比老牌 Jedis，Lettuce 属于后起之秀，不仅功能丰富，而且提供了很多新的功能特性，比如异步操作、响应式编程等等，同时还解决了 Jedis 中线程不安全的问题。

Lettuce是一个可扩展的线程安全Redis客户端，用于同步、异步和反应式使用。如果多个线程避免阻塞和事务性操作（如BLPOP和MULTI/EXEC），则它们可以共享一个连接。支持高级Redis功能，如Sentinel、Cluster、Pipelining、Auto Reconnect和Redis数据模型。

引入依赖

要使用Lettuce ，需要引入Lettuce的maven 依赖

<dependency>
	<groupId>io.lettuce</groupId>
	<artifactId>lettuce-core</artifactId>
	<version>5.3.1.RELEASE</version>
</dependency>

入门案例

public class LettuceTest {

    public static void main(String[] args) {
        //创建RedisClient客户端
        RedisClient client = createRedisClient();
        //打开Redis独立连接。端点是从初始化的RedisClient使用的
        StatefulRedisConnection<String, String> connection = client.connect();
        //获取用于同步执行的命令API。Lettuce也支持异步和反应式执行模型。
        RedisCommands<String, String> commands = connection.sync();
        //发出GET命令以获取name。
        String value = commands.get("name");

        System.out.println(value);
    }

    /**
     * 创建RedisClient客户端
     */
    private static RedisClient createRedisClient() {
        //创建RedisClient实例并提供指向localhost端口6379（默认端口）的Redis URI。
        RedisURI redisURI = RedisURI
                .builder()
                .withHost("127.0.0.1")
                .withPort(6379)
                .build();
        return RedisClient.create(redisURI);
    }
}

RedisURI

RedisURI包含主机/端口，可以携带身份验证/数据库详细信息。成功连接后，您将获得身份验证，然后选择数据库。

Redis URI也可以通过URI字符串创建。支持的格式有：

redis://[password@]host[:port][/databaseNumber] Plaintext Redis connection

rediss://[password@]host[:port][/databaseNumber] SSL Redis connection

redis-sentinel://[password@]host[:port][,host2[:port2]][/databaseNumber]#sentinelMasterId for using Redis Sentinel

redis-socket:///path/to/socket Unix Domain Socket connection to Redis

Asynchronous API

除此之外，Lettuce 还支持异步操作，将上面的操作改成异步处理，结果如下！

import io.lettuce.core.LettuceFutures;
import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisFuture;
import io.lettuce.core.RedisURI;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.async.RedisAsyncCommands;

import java.time.Duration;
import java.time.temporal.ChronoUnit;

public class LettuceTest {

    public static void main(String[] args) throws Exception {
        //创建RedisClient客户端
        RedisClient client = createRedisClient();
        //打开Redis独立连接。端点是从初始化的RedisClient使用的
        StatefulRedisConnection<String, String> connection = client.connect();
        //获取用于异步执行的命令API。Lettuce也支持异步和反应式执行模型。
        RedisAsyncCommands<String, String> async = connection.async();
        RedisFuture<String> set = async.set("name", "yangyanping");
        RedisFuture<String> get = async.get("name");

        if (LettuceFutures.awaitAll(Duration.of(2, ChronoUnit.SECONDS), set, get)) {
            System.out.println(set.get());
            System.out.println(get.get());
        }
    }

    /**
     * 创建RedisClient客户端
     */
    private static RedisClient createRedisClient() {
        //创建RedisClient实例并提供指向localhost端口6379（默认端口）的Redis URI。
        RedisURI redisURI = RedisURI
                .builder()
                .withHost("127.0.0.1")
                .withPort(6379)
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();
        return RedisClient.create(redisURI);
    }
}

响应式编程

Lettuce 除了支持异步编程以外，还支持响应式编程。

import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.reactive.RedisReactiveCommands;
import reactor.core.publisher.Mono;

import java.time.Duration;
import java.time.temporal.ChronoUnit;

public class LettuceTest {

    public static void main(String[] args) throws Exception {
        //创建RedisClient客户端
        RedisClient client = createRedisClient();
        StatefulRedisConnection<String,String> connection = client.connect();
        RedisReactiveCommands<String,String> reactive =  connection.reactive();
        Mono<String> set = reactive.set("name","yangyanping");
        Mono<String> get = reactive.get("name");
        set.subscribe();
        System.out.println(get.block());
    }

    /**
     * 创建RedisClient客户端
     */
    private static RedisClient createRedisClient() {
        //创建RedisClient实例并提供指向localhost端口6379（默认端口）的Redis URI。
        RedisURI redisURI = RedisURI
                .builder()
                .withHost("127.0.0.1")
                .withPort(6379)
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();
        return RedisClient.create(redisURI);
    }
}

发布和订阅

Redis 发布订阅（Pub/Sub）是一种消息通信模式：发送者通过 PUBLISH发布消息，订阅者通过 SUBSCRIBE 订阅接收消息或通过UNSUBSCRIBE 取消订阅。

主要包含三个部分组成：「发布者」、「订阅者」、「Channel」。

发布者和订阅者属于客户端，Channel 是 Redis 服务端，发布者将消息发布到频道，订阅这个频道的订阅者则收到消息。

如下图所示，三个「订阅者」订阅「Channel」频道：

在Redis中发布消息

127.0.0.1:6379> PUBLISH channel name
(integer) 1
import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.pubsub.RedisPubSubListener;
import io.lettuce.core.pubsub.api.sync.RedisPubSubCommands;

import java.time.Duration;
import java.time.temporal.ChronoUnit;

public class LettuceTest {

    public static void main(String[] args) throws Exception {
        //创建RedisClient客户端
        RedisClient client = createRedisClient();
        RedisPubSubCommands<String,String> commands = client.connectPubSub().sync();
        commands.getStatefulConnection().addListener(new RedisPubSubListener<String, String>() {
            @Override
            public void message(String channel, String message) {
                System.out.println("[message]" + channel + " -> " + message);
            }

            @Override
            public void message(String pattern, String channel, String message) {
                System.out.println("[message]" + channel + " -> " + message);
            }

            @Override
            public void subscribed(String s, long l) {

            }

            @Override
            public void psubscribed(String s, long l) {

            }

            @Override
            public void unsubscribed(String s, long l) {

            }

            @Override
            public void punsubscribed(String s, long l) {

            }
        });

        commands.subscribe("channel");

        System.in.read();
    }

    /**
     * 创建RedisClient客户端
     */
    private static RedisClient createRedisClient() {
        //创建RedisClient实例并提供指向localhost端口6379（默认端口）的Redis URI。
        RedisURI redisURI = RedisURI
                .builder()
                .withHost("127.0.0.1")
                .withPort(6379)
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();
        return RedisClient.create(redisURI);
    }
}

输出结果

[message]channel -> name

线程池配置

Lettuce 连接设计的时候，就是线程安全的，所以一个连接可以被多个线程共享，同时 lettuce 连接默认是自动重连的，使用单连接基本可以满足业务需求，大多数情况下不需要配置连接池，多连接并不会给操作带来性能上的提升。

但在某些特殊场景下，比如事务操作，使用连接池会是一个比较好的方案，那么如何配置线程池呢？

首先引入依赖

<dependency>
	<groupId>org.apache.commons</groupId>
	<artifactId>commons-pool2</artifactId>
	<version>2.11.1</version>
</dependency>
import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;
import io.lettuce.core.support.ConnectionPoolSupport;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

import java.time.Duration;
import java.time.temporal.ChronoUnit;

public class LettuceTest {

    public static void main(String[] args) throws Exception {
       RedisClient client = createRedisClient();
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMinIdle(50);

        GenericObjectPool<StatefulRedisConnection<String, String>> pool = ConnectionPoolSupport.createGenericObjectPool(client::connect, poolConfig);
        StatefulRedisConnection<String, String> connection = pool.borrowObject();
        RedisCommands<String, String> commands = connection.sync();
        commands.set("name", "yyp");
        System.out.println(commands.get("name"));
    }

    /**
     * 创建RedisClient客户端
     */
    private static RedisClient createRedisClient() {
        //创建RedisClient实例并提供指向localhost端口6379（默认端口）的Redis URI。
        RedisURI redisURI = RedisURI
                .builder()
                .withHost("127.0.0.1")
                .withPort(6379)
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();
        return RedisClient.create(redisURI);
    }
}

客户端资源与参数配置

Lettuce 客户端的通信框架集成了 Netty 的非阻塞 IO 操作，客户端资源的设置与 Lettuce 的性能、并发和事件处理紧密相关，如果不是特别熟悉客户端参数配置，不建议在没有经验的前提下凭直觉修改默认值，保持默认配置就行。

非集群环境下，具体的配置案例如下：

public static void main(String[] args) throws Exception {
        RedisURI redisURI = RedisURI
                .builder()
                .withHost("127.0.0.1")
                .withPort(6379)
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();
        ClientResources resources = DefaultClientResources.builder()
                .ioThreadPoolSize(4) //I/O线程数
                .computationThreadPoolSize(4) //任务线程数
                .build();

        ClusterClientOptions options = ClusterClientOptions.builder()
                .autoReconnect(true)//是否自动重连
                .pingBeforeActivateConnection(true)//连接激活之前是否执行PING命令
                .validateClusterNodeMembership(true)//是否校验集群节点的成员关系
                .build();
        RedisClusterClient client = RedisClusterClient.create(resources, redisURI);
        client.setOptions(options);
        StatefulRedisClusterConnection<String, String> connection = client.connect();
        RedisAdvancedClusterCommands<String, String> commands = connection.sync();
        commands.set("name", "yyp");
        System.out.println(commands.get("name"));
    }

Cluster 集群模式配置

Cluster 集群模式，是之后推出的一种高可用的架构模型，主要是采用分片方式来存储数据，具体配置如下：

import io.lettuce.core.RedisURI;
import io.lettuce.core.cluster.RedisClusterClient;
import io.lettuce.core.cluster.api.StatefulRedisClusterConnection;
import io.lettuce.core.cluster.api.sync.RedisAdvancedClusterCommands;

import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;

public class LettuceTest {

    public static void main(String[] args) throws Exception {
        RedisURI redisURI1 = RedisURI
                .builder()
                .withHost("127.0.0.1")
                .withPort(6379)
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();

        RedisURI redisURI2 = RedisURI
                .builder()
                .withHost("127.0.0.1")
                .withPort(6389)
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();

        RedisURI redisURI3 = RedisURI
                .builder()
                .withHost("127.0.0.1")
                .withPort(6399)
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();


        RedisClusterClient client = RedisClusterClient.create(Arrays.asList(redisURI1, redisURI2, redisURI3));

        StatefulRedisClusterConnection<String, String> connection = client.connect();
        RedisAdvancedClusterCommands<String, String> commands = connection.sync();
        commands.set("name", "yyp");
        System.out.println(commands.get("name"));
    }
}

相关推荐

Redis合集-使用benchmark性能测试

采用开源Redis的redis-benchmark工具进行压测，它是Redis官方的性能测试工具，可以有效地测试Redis服务的性能。本次测试使用Redis官方最新的代码进行编译，详情请参见Redis...

Java简历总被已读不回?面试挂到怀疑人生?这几点你可能真没做好

最近看了几十份简历，发现大部分人不是技术差，而是不会“卖自己”——一、简历死穴：你写的不是经验，是岗位说明书！反面教材：ד使用SpringBoot开发项目”ד负责用户模块功能实现”救命写法：...

redission YYDS（redission官网）

每天分享一个架构知识Redission是一个基于Redis的分布式Java锁框架，它提供了各种锁实现，包括可重入锁、公平锁、读写锁等。使用Redission可以方便地实现分布式锁。red...

从数据库行锁到分布式事务:电商库存防超卖的九重劫难与破局之道

2023年6月18日我们维护的电商平台在零点刚过3秒就遭遇了严重事故。监控大屏显示某爆款手机SKU_IPHONE13_PRO_MAX在库存仅剩500台时，订单系统却产生了1200笔有效订单。事故复盘发...

SpringBoot系列——实战11:接口幂等性的形而上思...

欢迎关注、点赞、收藏。幂等性不仅是一种技术需求，更是数字文明对确定性追求的体现。在充满不确定性的网络世界中，它为我们建立起可依赖的存在秩序，这或许正是技术哲学最深刻的价值所在。幂等性的本质困境在支付系...

如何优化系统架构设计缓解流量压力提升并发性能?Java实战分享

如何优化系统架构设计缓解流量压力提升并发性能？Java实战分享在高流量场景下。首先，我需要回忆一下常见的优化策略，比如负载均衡、缓存、数据库优化、微服务拆分这些。不过，可能还需要考虑用户的具体情况，比...

Java面试题: 项目开发中的有哪些成长?该如何回答

在Java面试中，当被问到“项目中的成长点”时，面试官不仅想了解你的技术能力，更希望看到你的问题解决能力、学习迭代意识以及对项目的深度思考。以下是回答的策略和示例，帮助你清晰、有说服力地展示成长点：一...

互联网大厂后端必看!Spring Boot 如何实现高并发抢券逻辑?

你有没有遇到过这样的情况？在电商大促时，系统上线了抢券活动，结果活动刚一开始，服务器就不堪重负，出现超卖、系统崩溃等问题。又或者用户疯狂点击抢券按钮，最后却被告知无券可抢，体验极差。作为互联网大厂的后...

每日一题 |10W QPS高并发限流方案设计(含真实代码)

面试场景还原面试官：“如果系统要承载10WQPS的高并发流量，你会如何设计限流方案？”你：“（稳住，我要从限流算法到分布式架构全盘分析）…”一、为什么需要限流？核心矛盾：系统资源（CPU/内存/数据...

Java面试题:服务雪崩如何解决?90%人栽了

服务雪崩是指微服务架构中，由于某个服务出现故障，导致故障在服务之间不断传递和扩散，最终造成整个系统崩溃的现象。以下是一些解决服务雪崩问题的常见方法：限流限制请求速率：通过限流算法（如令牌桶算法、漏桶算...

面试题官:高并发经验有吗，并发量多少，如何回复?

一、有实际高并发经验（建议结构）直接量化"在XX项目中，系统日活用户约XX万，核心接口峰值QPS达到XX，TPS处理能力为XX/秒。通过压力测试验证过XX并发线程下的稳定性。"技术方案...

瞬时流量高并发“保命指南”:这样做系统稳如泰山，老板跪求加薪

“系统崩了，用户骂了，年终奖飞了！”——这是多少程序员在瞬时大流量下的真实噩梦？双11秒杀、春运抢票、直播带货……每秒百万请求的冲击，你的代码扛得住吗？2025年了，为什么你的系统一遇高并发就“躺平”...

其实很多Java工程师不是能力不够，是没找到展示自己的正确姿势。

其实很多Java工程师不是能力不够，是没找到展示自己的正确姿势。比如上周有个小伙伴找我，五年经验但简历全是'参与系统设计''优化接口性能'这种空话。我就问他：你做的秒杀...

PHP技能评测（php等级考试）

公司出了一些自我评测的PHP题目，现将题目和答案记录于此，以方便记忆。1.魔术函数有哪些,分别在什么时候调用?__construct()，类的构造函数__destruct()，类的析构函数__cal...

你的简历在HR眼里是青铜还是王者?

你的简历在HR眼里是青铜还是王者？兄弟，简历投了100份没反应？面试总在第三轮被刷？别急着怀疑人生，你可能只是踩了这些"隐形求职雷"。帮3630+程序员改简历+面试指导和处理空窗期时间...

取消回复欢迎 你 发表评论:

一周热门
最近发表
标签列表