Redis——Lettuce基本使用

转x33g5p2x  于2022-05-05 转载在 Redis  
字(5.9k)|赞(0)|评价(0)|浏览(746)

Lettuce比Jedis好的点之一就是有官网：Lettuce

Lettuce的使用由4块组成：

  1. URI：定义连接信息；
  2. Client：redis客户端，集群使用专用的RedisClusterClient；
  3. Connection：redis连接，有多种类型（单机，哨兵，集群，订阅发布）；
  4. Command：用户操作api，基本包含了redis全部命令；

使用流程也很简单：使用指定的URI创建Client，使用Client创建Connection，使用Connection创建Command，然后就可以操作Command的api了，最后关闭连接关闭客户端；

Command有三种类型：

  1. sync：同步，跟jedis差不多
  2. async：异步
  3. reactive：响应式

RedisURI的创建有3种方式：

  1. 使用字符串：RedisURI.create("redis://localhost/");
  2. 使用builder：RedisURI.Builder.redis("localhost", 6379).auth("password").database(1).build();
  3. 使用new对象：new RedisURI("localhost", 6379, 60, TimeUnit.SECONDS);

另外，使用字符串的时候几种不同的语法：

  • 单机：redis://[[username:]password@]host:port][/database][?[timeout=timeout[d|h|m|s|ms|us|ns]]
  • 单机（ssl）：rediss://[[username:]password@]host:port][/database][?[timeout=timeout[d|h|m|s|ms|us|ns]]
  • 单机（Unix Domain Sockets）：redis-socket://[[username:]password@]path[?[timeout=timeout[d|h|m|s|ms|us|ns]][&database=database]]
  • 哨兵：redis-sentinel://[[username:]password@]host1[:port1][,host2[:port2]],hostN[:portN]][/database][?[timeout=timeout[d|h|m|s|ms|us|ns]][&sentinelMasterId=sentinelMasterId]

超时时间单位：

  • d 天
  • h 小时
  • m 分钟
  • s 秒
  • ms 毫秒
  • us 微秒
  • ns 纳秒

简单Demo：（使用的redis版本为6.2.6，Lettuce为6.1.8）

maven导入

  1. <dependency>
  2. 	    <groupId>io.lettuce</groupId>
  3. 	    <artifactId>lettuce-core</artifactId>
  4. 	    <version>6.1.8.RELEASE</version>
  5. 	</dependency>

测试代码

  1. /**
  2.  * 2022年4月25日上午11:10:59
  3.  */
  4. package testlettuce;
  6. import java.time.Duration;
  7. import java.util.concurrent.ExecutionException;
  8. import java.util.concurrent.TimeUnit;
  9. import java.util.concurrent.TimeoutException;
  11. import io.lettuce.core.ClientOptions;
  12. import io.lettuce.core.RedisClient;
  13. import io.lettuce.core.RedisFuture;
  14. import io.lettuce.core.RedisURI;
  15. import io.lettuce.core.TimeoutOptions;
  16. import io.lettuce.core.api.StatefulRedisConnection;
  17. import io.lettuce.core.api.async.RedisAsyncCommands;
  18. import io.lettuce.core.api.push.PushListener;
  19. import io.lettuce.core.api.push.PushMessage;
  20. import io.lettuce.core.api.reactive.RedisReactiveCommands;
  21. import io.lettuce.core.api.sync.RedisCommands;
  22. import io.lettuce.core.pubsub.RedisPubSubListener;
  23. import io.lettuce.core.pubsub.StatefulRedisPubSubConnection;
  24. import io.lettuce.core.pubsub.api.async.RedisPubSubAsyncCommands;
  25. import io.lettuce.core.pubsub.api.sync.RedisPubSubCommands;
  26. import io.lettuce.core.resource.ClientResources;
  27. import io.lettuce.core.resource.DefaultClientResources;
  28. import io.lettuce.core.resource.Delay;
  29. import reactor.core.publisher.Flux;
  30. import reactor.core.publisher.Mono;
  32. /**
  33.  * @author XWF
  34.  *
  35.  */
  36. public class TestLettuce {
  38. 	/**
  39. 	 * @param args
  40. 	 */
  41. 	public static void main(String[] args) {
  42. //		RedisURI uri = RedisURI.create("redis://default:123456@192.168.1.31:6379/0?timeout=5s");
  43. 		
  44. //		RedisURI uri = new RedisURI("192.168.1.31", 6379, Duration.ofSeconds(5));
  45. //		uri.setPassword("123456".toCharArray());
  46. 		
  47. 		RedisURI uri = RedisURI.builder()
  48. 				.withHost("192.168.1.31")
  49. 				.withPort(6379)
  50. 				.withAuthentication("default", "123456")
  51. 				.build();
  52. 		ClientResources resources = DefaultClientResources.builder()
  53.                 .ioThreadPoolSize(4)	//设置I/O线程池大小（默认cpu数）仅在没有提供eventLoopGroupProvider时有效
  54.                 .computationThreadPoolSize(4)	//设置用于计算的任务线程数（默认cpu数）仅在没有提供eventExecutorGroup时有效
  55. //                .reconnectDelay(Delay.constant(Duration.ofSeconds(10)))	//设置无状态尝试重连延迟，默认延迟上限30s
  56.                 .build();
  57. 		RedisClient client = RedisClient.create(resources, uri);
  58. 		ClientOptions options = ClientOptions.builder()
  59. 				.autoReconnect(true)	//设置自动重连
  60. 				.pingBeforeActivateConnection(true)	//激活连接前执行PING命令
  61. //				.timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(5)))	//命令超时
  62. 				.build();
  63. 		client.setOptions(options);
  64. 		client.setDefaultTimeout(Duration.ofSeconds(3));	//为客户端创建的连接设置默认超时时间，适用于尝试连接和非阻塞命令
  65. 		StatefulRedisConnection<String, String> conn = client.connect();
  66. 		
  67. 		System.out.println("==sync==");
  68. 		RedisCommands<String, String> syncCmd = conn.sync();
  69. 		System.out.println(syncCmd.set("a", "aaaa"));
  70. 		String geta = syncCmd.get("a");
  71. 		System.out.println(geta);
  72. 		
  73. 		System.out.println("==async==");
  74. 		RedisAsyncCommands<String, String> asyncCmd = conn.async();
  75. 		RedisFuture<String> setb = asyncCmd.set("b", "bbbb");
  76. 		try {
  77. 			System.out.println(setb.get(1, TimeUnit.SECONDS));
  78. 		} catch (InterruptedException | ExecutionException | TimeoutException e1) {
  79. 			e1.printStackTrace();
  80. 		}
  81. 		RedisFuture<String> getb = asyncCmd.get("b");
  82. //		a2.thenAccept(x -> {
  83. //			System.out.println(x + x.length());
  84. //		});
  85. 		getb.whenCompleteAsync((x, t) -> {
  86. 			System.out.println(x + t);
  87. 		});
  88. 		
  89. 		System.out.println("==reactive==");
  90. 		RedisReactiveCommands<String, String> reactiveCmd = conn.reactive();
  91. 		Mono<String> setc = reactiveCmd.set("c", "cccc");
  92. 		System.out.println(setc.block());
  93. 		Mono<String> getc = reactiveCmd.get("c");
  94. 		getc.subscribe(System.out::println);
  95. 		Flux<String> keys = reactiveCmd.keys("*");
  96. 		keys.subscribe(System.out::println);
  97. 		
  98. 		try {Thread.sleep(500);} catch (InterruptedException e) {}
  99. 		
  100. 		System.out.println("==pubsub==");
  101. 		StatefulRedisPubSubConnection<String, String> pubsubConn = client.connectPubSub();
  102. 		pubsubConn.addListener(new RedisPubSubListener<String, String>() {
  103. 			@Override
  104. 			public void unsubscribed(String channel, long count) {
  105. 				System.out.println("[unsubscribed]" + channel);
  106. 			}
  107. 			@Override
  108. 			public void subscribed(String channel, long count) {
  109. 				System.out.println("[subscribed]" + channel);
  110. 			}
  111. 			@Override
  112. 			public void punsubscribed(String pattern, long count) {
  113. 			}
  114. 			@Override
  115. 			public void psubscribed(String pattern, long count) {
  116. 			}
  117. 			@Override
  118. 			public void message(String pattern, String channel, String message) {
  119. 			}
  120. 			@Override
  121. 			public void message(String channel, String message) {
  122. 				System.out.println("[message]" + channel + " -> " + message);
  123. 			}
  124. 		});
  125. 		RedisPubSubAsyncCommands<String, String> pubsubCmd = pubsubConn.async();
  126. 		pubsubCmd.subscribe("CH");
  127. 		pubsubCmd.subscribe("CH2");
  128. 		pubsubCmd.publish("CH", "helloworld");
  129. 		pubsubCmd.publish("CH2", "HELLOWORLD");
  130. 		pubsubCmd.unsubscribe("CH");
  131. 		pubsubCmd.unsubscribe("CH2");
  132. 		
  133. 		try {Thread.sleep(500);} catch (InterruptedException e) {}
  134. 	}
  136. }

运行结果

参考：Lettuce Reference Guide

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/FlyLikeButterfly/article/details/124490079

内容来源于网络，如有侵权，请联系作者删除！

redisDatabaselettuce数据库

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com