本文内容纲要：
-1、引入依赖
-2、基本操作
-3、高级操作
Lettuce是一个高性能基于Java编写的Redis驱动框架，底层集成了ProjectReactor提供天然的反应式编程，通信框架集成了Netty使用了非阻塞IO，5.x版本之后融合了JDK1.8的异步编程特性，在保证高性能的同时提供了十分丰富易用的API。本文主要介绍使用lettuce操作redis，使用到的软件版本：Java1.8.0_191、Redis5.0.8、lettuce5.3.1.RELEASE。
1、引入依赖
<dependency>
<groupId>io.lettuce</groupId>
<artifactId>lettuce-core</artifactId>
<version>5.3.1.RELEASE</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.8.0</version>
</dependency>
2、基本操作
packagecom.inspur.demo.general.redis;
importio.lettuce.core.RedisClient;
importio.lettuce.core.RedisURI;
importio.lettuce.core.SetArgs;
importio.lettuce.core.api.StatefulRedisConnection;
importio.lettuce.core.api.async.RedisAsyncCommands;
importio.lettuce.core.api.reactive.RedisReactiveCommands;
importio.lettuce.core.api.sync.RedisCommands;
importorg.junit.After;
importorg.junit.Before;
importorg.junit.Test;
importreactor.core.publisher.Mono;
importjava.time.Duration;
importjava.time.temporal.ChronoUnit;
importjava.util.concurrent.Future;
/**
*使用Lettuce操作redis
*/
publicclassLettuceBaseCase{
privatestaticRedisClientclient;
privateStatefulRedisConnection<String,String>connection;
@Before
publicvoidbefore(){
RedisURIredisUri=RedisURI.builder()
.withHost("10.49.196.10").withPort(6379).withPassword("123456")
.withTimeout(Duration.of(10,ChronoUnit.SECONDS))
.build();
client=RedisClient.create(redisUri);
connection=client.connect();
}
@After
publicvoidafter(){
connection.close();
client.shutdown();
}
/**
*同步操作
*api和jedis很类型
*/
@Test
publicvoidsync(){
RedisCommands<String,String>commands=connection.sync();
Stringresult=commands.set("name","mayun");
System.out.println(result);
SetArgsargs=SetArgs.Builder.nx().ex(10);
result=commands.set("age","30",args);
System.out.println(result);
}
/**
*异步操作
*/
@Test
publicvoidasync()throwsException{
RedisAsyncCommands<String,String>commands=connection.async();
Future<String>future=commands.set("name","mayun");
System.out.println(future.get());
SetArgsargs=SetArgs.Builder.nx().ex(10);
future=commands.set("age","30",args);
System.out.println(future.get());
}
/**
*响应式API
*/
@Test
publicvoidreactive()throwsException{
RedisReactiveCommands<String,String>commands=connection.reactive();
Mono<String>result=commands.set("name","mayun");
System.out.println(result.block());
SetArgsargs=SetArgs.Builder.nx().ex(10);
result=commands.set("age","30",args);
result.subscribe(value->System.out.println(value));
//开启一个事务，先把counter设置为1，再将counter自增1
commands.multi().doOnSuccess(r->{
commands.set("count","1").doOnNext(System.out::println).subscribe();
commands.incr("count").doOnNext(c->System.out.println(c)).subscribe();
}).flatMap(s->commands.exec())
.doOnNext(transactionResult->System.out.println(transactionResult.wasDiscarded())).subscribe();
Thread.sleep(1000*5);
}
}
3、高级操作
packagecom.inspur.demo.general.redis;
importio.lettuce.core.ClientOptions;
importio.lettuce.core.ReadFrom;
importio.lettuce.core.RedisClient;
importio.lettuce.core.RedisURI;
importio.lettuce.core.api.StatefulRedisConnection;
importio.lettuce.core.api.sync.RedisCommands;
importio.lettuce.core.cluster.ClusterClientOptions;
importio.lettuce.core.cluster.RedisClusterClient;
importio.lettuce.core.cluster.api.StatefulRedisClusterConnection;
importio.lettuce.core.cluster.api.sync.Executions;
importio.lettuce.core.cluster.api.sync.NodeSelection;
importio.lettuce.core.cluster.api.sync.NodeSelectionCommands;
importio.lettuce.core.cluster.api.sync.RedisAdvancedClusterCommands;
importio.lettuce.core.codec.StringCodec;
importio.lettuce.core.masterreplica.MasterReplica;
importio.lettuce.core.masterreplica.StatefulRedisMasterReplicaConnection;
importio.lettuce.core.resource.ClientResources;
importio.lettuce.core.resource.DefaultClientResources;
importio.lettuce.core.support.ConnectionPoolSupport;
importorg.apache.commons.pool2.impl.GenericObjectPool;
importorg.apache.commons.pool2.impl.GenericObjectPoolConfig;
importorg.junit.Test;
importjava.time.Duration;
importjava.time.temporal.ChronoUnit;
importjava.util.*;
/**
*高级操作
*/
publicclassLettuceAdvanceCase{
/**
*主从模式操作
*/
@Test
publicvoidmasterSlave(){
//这里只需要配置一个节点的连接信息，不一定需要是主节点的信息，从节点也可以;可以自动发现主从节点
RedisURIuri=RedisURI.builder().withHost("10.49.196.20").withPort(6379).withPassword("123456").build();
RedisClientclient=RedisClient.create(uri);
StatefulRedisMasterReplicaConnection<String,String>connection=MasterReplica.connect(client,StringCodec.UTF8,uri);
//从节点读书数据
connection.setReadFrom(ReadFrom.REPLICA);
RedisCommands<String,String>commands=connection.sync();
commands.set("name","刘备");
System.out.println(commands.get("name"));
connection.close();
client.shutdown();
}
/**
*主从模式操作2
*/
@Test
publicvoidmasterSlave2(){
List<RedisURI>uris=newArrayList();
uris.add(RedisURI.builder().withHost("10.49.196.20").withPort(6379).withPassword("123456").build());
uris.add(RedisURI.builder().withHost("10.49.196.21").withPort(6379).withPassword("123456").build());
uris.add(RedisURI.builder().withHost("10.49.196.22").withPort(6379).withPassword("123456").build());
RedisClientclient=RedisClient.create();
StatefulRedisMasterReplicaConnection<String,String>connection=MasterReplica.connect(client,StringCodec.UTF8,uris);
//从节点读书数据
connection.setReadFrom(ReadFrom.REPLICA);
RedisCommands<String,String>commands=connection.sync();
commands.set("name","张飞");
System.out.println(commands.get("name"));
connection.close();
client.shutdown();
}
/**
*哨兵模式操作
*/
@Test
publicvoidsentinel(){
List<RedisURI>uris=newArrayList();
uris.add(RedisURI.builder().withSentinel("10.49.196.20",26379).withSentinelMasterId("mymaster").withPassword("123456").build());
uris.add(RedisURI.builder().withSentinel("10.49.196.21",26379).withSentinelMasterId("mymaster").withPassword("123456").build());
uris.add(RedisURI.builder().withSentinel("10.49.196.22",26379).withSentinelMasterId("mymaster").withPassword("123456").build());
RedisClientclient=RedisClient.create();
StatefulRedisMasterReplicaConnection<String,String>connection=MasterReplica.connect(client,StringCodec.UTF8,uris);
//从节点读书数据
connection.setReadFrom(ReadFrom.REPLICA);
RedisCommands<String,String>commands=connection.sync();
commands.set("name","赵云");
System.out.println(commands.get("name"));
connection.close();
client.shutdown();
}
/**
*集群操作
*/
@Test
publicvoidcluster(){
Set<RedisURI>uris=newHashSet<>();
uris.add(RedisURI.builder().withHost("10.49.196.20").withPort(7000).withPassword("123456").build());
uris.add(RedisURI.builder().withHost("10.49.196.20").withPort(7001).withPassword("123456").build());
uris.add(RedisURI.builder().withHost("10.49.196.21").withPort(7000).withPassword("123456").build());
uris.add(RedisURI.builder().withHost("10.49.196.21").withPort(7001).withPassword("123456").build());
uris.add(RedisURI.builder().withHost("10.49.196.22").withPort(7000).withPassword("123456").build());
uris.add(RedisURI.builder().withHost("10.49.196.22").withPort(7001).withPassword("123456").build());
RedisClusterClientclient=RedisClusterClient.create(uris);
StatefulRedisClusterConnection<String,String>connection=client.connect();
RedisAdvancedClusterCommands<String,String>commands=connection.sync();
commands.set("name","关羽");
System.out.println(commands.get("name"));
//选择从节点,只读
NodeSelection<String,String>replicas=commands.replicas();
NodeSelectionCommands<String,String>nodeSelectionCommands=replicas.commands();
Executions<List<String>>keys=nodeSelectionCommands.keys("*");
keys.forEach(key->System.out.println(key));
connection.close();
client.shutdown();
}
/**
*配置客户端资源(ClientResources)及客户端参数(ClientOptions)
*/
@Test
publicvoidresourceAndOption(){
ClientResourcesresources=DefaultClientResources.builder()
.ioThreadPoolSize(4)//I/O线程数
.computationThreadPoolSize(4)//任务线程数
.build();
RedisURIredisUri=RedisURI.builder()
.withHost("10.49.196.10").withPort(6379).withPassword("123456")
.withTimeout(Duration.of(10,ChronoUnit.SECONDS))
.build();
ClientOptionsoptions=ClientOptions.builder()
.autoReconnect(true)//是否自动重连
.pingBeforeActivateConnection(true)//连接激活之前是否执行PING命令
.build();
RedisClientclient=RedisClient.create(resources,redisUri);
client.setOptions(options);
StatefulRedisConnection<String,String>connection=client.connect();
RedisCommands<String,String>commands=connection.sync();
System.out.println(commands.get("name"));
connection.close();
client.shutdown();
resources.shutdown();
}
/**
*配置客户端资源(ClientResources)及客户端参数(ClientOptions)
*集群
*/
@Test
publicvoidresourceAndOption2(){
ClientResourcesresources=DefaultClientResources.builder()
.ioThreadPoolSize(4)//I/O线程数
.computationThreadPoolSize(4)//任务线程数
.build();
//集群地址，配置其中一个即可，不需要配置全
RedisURIredisUri=RedisURI.builder()
.withHost("10.49.196.20").withPort(7000).withPassword("123456")
.withTimeout(Duration.of(10,ChronoUnit.SECONDS))
.build();
ClusterClientOptionsoptions=ClusterClientOptions.builder()
.autoReconnect(true)//是否自动重连
.pingBeforeActivateConnection(true)//连接激活之前是否执行PING命令
.validateClusterNodeMembership(true)//是否校验集群节点的成员关系
.build();
RedisClusterClientclient=RedisClusterClient.create(resources,redisUri);
client.setOptions(options);
StatefulRedisClusterConnection<String,String>connection=client.connect();
RedisAdvancedClusterCommands<String,String>commands=connection.sync();
System.out.println(commands.get("name"));
connection.close();
client.shutdown();
resources.shutdown();
}
/**
*连接池
*/
@Test
publicvoidpool()throwsException{
RedisURIredisUri=RedisURI.builder()
.withHost("10.49.196.10").withPort(6379).withPassword("123456")
.withTimeout(Duration.of(10,ChronoUnit.SECONDS))
.build();
RedisClientclient=RedisClient.create(redisUri);
GenericObjectPoolConfigpoolConfig=newGenericObjectPoolConfig();
GenericObjectPool<StatefulRedisConnection<String,String>>pool=ConnectionPoolSupport.createGenericObjectPool(client::connect,poolConfig);
StatefulRedisConnection<String,String>connection=pool.borrowObject();
RedisCommands<String,String>commands=connection.sync();
System.out.println(commands.get("name"));
connection.close();
pool.close();
client.shutdown();
}
}
本文内容总结：1、引入依赖，2、基本操作，3、高级操作，
原文链接：https://www.cnblogs.com/wuyongyin/p/13206947.html
