组件整合之Redisson
Redisson简介
Redisson是一个在Redis的基础上实现的Java驻内存数据网格(In-Memory Data Grid)。它不仅提供了一系列的分布式的Java常用对象,还提供了许多分布式服务。其中包括(BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson提供了使用Redis的最简单和最便捷的方法。Redisson的宗旨是促进使用者对Redis的关注分离(Separation of Concern),从而让使用者能够将精力更集中地放在处理业务逻辑上。
快速入门
pom配置
<!--redisson-->
<dependency>
<groupId>org.redisson</groupId>
<artifactId>redisson</artifactId>
<version>3.15.0</version>
</dependency>
Redission配置
程序化配置
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.codec.JsonJacksonCodec;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
@Configuration
public class RedissonConfig {
private static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
/**
* 单机模式自动装配
* @return
*/
@Bean
public RedissonClient redissonSingle(){
Config config = new Config();
config.useSingleServer()
.setAddress("redis://localhost:6379")
.setConnectionMinimumIdleSize(10);
config.setCodec(new JsonJacksonCodec(objectMapper()));
RedissonClient redissonClient = Redisson.create(config);
return redissonClient;
}
/**
* 主从模式
* @return
*/
@Bean
public RedissonClient masterSlave(){
Config config = new Config();
config.useMasterSlaveServers()
//可以用"rediss://"来启用SSL连接
.setMasterAddress("redis://127.0.0.1:6379")
.addSlaveAddress("redis://127.0.0.1:6389", "redis://127.0.0.1:6332", "redis://127.0.0.1:6419")
.addSlaveAddress("redis://127.0.0.1:6399");
return Redisson.create(config);
}
/**
* 哨兵模式自动装配
* @return
*/
@Bean
public RedissonClient redissonSentinel(){
Config config = new Config();
List<String> newNodes = new ArrayList();
newNodes.add("redis://192.168.1.10:6379");
newNodes.add("redis://192.168.1.11:16379");
newNodes.add("redis://192.168.1.12:16379");
config.useSentinelServers()
.addSentinelAddress(newNodes.toArray(new String[0]))
.setMasterName("mymaster")
.setMasterConnectionPoolSize(250)
.setMasterConnectionMinimumIdleSize(20)
.setSlaveConnectionPoolSize(250)
.setSlaveConnectionMinimumIdleSize(20);
config.setCodec(new JsonJacksonCodec(objectMapper()));
return Redisson.create(config);
}
/**
* 集群模式自动装配
* @return
*/
@Bean
public RedissonClient redissionClusterNodes(){
Config config = new Config();
List<String> newNodes = new ArrayList();
newNodes.add("redis://127.0.0.1:6380");
newNodes.add("redis://127.0.0.1:6381");
newNodes.add("redis://127.0.0.1:6382");
config.useClusterServers()
.addNodeAddress(newNodes.toArray(new String[0]));
config.setCodec(new JsonJacksonCodec(objectMapper()));
return Redisson.create(config);
}
public ObjectMapper objectMapper() {
ObjectMapper mapper = new ObjectMapper();
//大小写不敏感
mapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.setDateFormat(new SimpleDateFormat(DEFAULT_DATE_TIME_FORMAT));
JavaTimeModule javaTimeModule = new JavaTimeModule();
javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
mapper.registerModule(javaTimeModule);
return mapper;
}
}
文件方式配置
Redisson也可以通过用户提供的JSON或YAML格式的文本文件来配置:
(1)可以通过调用Config.fromJSON方法并指定一个File实例来实现读取JSON格式的配置
Config config = Config.fromJSON(new File("config-file.json"));
RedissonClient redisson = Redisson.create(config);
config-file.json示例:
{
"clusterServersConfig":{
"idleConnectionTimeout":10000,
"pingTimeout":1000,
"connectTimeout":10000,
"timeout":3000,
"retryAttempts":3,
"retryInterval":1500,
"reconnectionTimeout":3000,
"failedAttempts":3,
"password":null,
"subscriptionsPerConnection":5,
"clientName":null,
"loadBalancer":{
"class":"org.redisson.connection.balancer.RoundRobinLoadBalancer"
},
"slaveSubscriptionConnectionMinimumIdleSize":1,
"slaveSubscriptionConnectionPoolSize":50,
"slaveConnectionMinimumIdleSize":32,
"slaveConnectionPoolSize":64,
"masterConnectionMinimumIdleSize":32,
"masterConnectionPoolSize":64,
"readMode":"SLAVE",
"nodeAddresses":[
"redis://127.0.0.1:7004",
"redis://127.0.0.1:7001",
"redis://127.0.0.1:7000"
],
"scanInterval":1000
},
"threads":0,
"nettyThreads": 0,
"codec":{
"class":"org.redisson.codec.JsonJacksonCodec"
},
"transportMode":"NIO"
}
(2)通过调用config.fromYAML方法并指定一个File实例来实现读取YAML格式的配置
Config config = Config.fromYAML(new File("config-file.yaml"));
RedissonClient redisson = Redisson.create(config);
config-file.yaml示例:
singleServerConfig:
#连接空闲超时,单位:毫秒
idleConnectionTimeout: 10000
pingTimeout: 1000
#连接超时,单位:毫秒
connectTimeout: 10000
#命令等待超时,单位:毫秒
timeout: 3000
#命令失败重试次数
retryAttempts: 3
#命令重试发送时间间隔,单位:毫秒
retryInterval: 1500
#重新连接时间间隔,单位:毫秒
reconnectionTimeout: 3000
#执行失败最大次数
failedAttempts: 3
#单个连接最大订阅数量
subscriptionsPerConnection: 5
#客户端名称
clientName: null
#地址
address: "redis://192.168.1.16:6379"
#数据库编号
database: 0
#密码
password: xiaokong
#发布和订阅连接的最小空闲连接数
subscriptionConnectionMinimumIdleSize: 1
#发布和订阅连接池大小
subscriptionConnectionPoolSize: 50
#最小空闲连接数
connectionMinimumIdleSize: 32
#连接池大小
connectionPoolSize: 64
#是否启用DNS监测
dnsMonitoring: false
#DNS监测时间间隔,单位:毫秒
dnsMonitoringInterval: 5000
threads: 0
nettyThreads: 0
codec: !<org.redisson.codec.JsonJacksonCodec> {}
transportMode : "NIO"
Config类
Redisson程序化的配置方法是通过构建Config对象实例来实现的。
以下是org.redisson.Config类的配置参数,它适用于所有Redis组态模式(单机,集群和哨兵)。
codec(编码)
默认值是:org.redisson.codec.JsonJacksonCodec
Redisson的对象编码类是用于将对象进行序列化和反序列化,以实现对该对象在Redis里的读取和存储。Redisson提供了以下几种的对象编码应用,以供大家选择:
编码类名称 | 说明 |
org.redisson.codec.JsonJacksonCodec | Jackson JSON 编码 默认编码 |
org.redisson.codec.KryoCodec | Kryo 二进制对象序列化编码 |
org.redisson.codec.SerializationCodec | JDK序列化编码 |
org.redisson.codec.FstCodec | FST 10倍于JDK序列化性能而且100%兼容的编码 |
org.redisson.client.codec.JsonJacksonMapCodec | 基于Jackson的映射类使用的编码。可用于避免序列化类的信息,以及用于解决使用byte[]遇到的问题。 |
org.redisson.client.codec.ByteArrayCodec | 字节数组编码 |
org.redisson.codec.CompositeCodec | 用来组合多种不同编码在一起 |
属性配置
属性名 | 属性简介 | 默认值 | 详细说明 |
threads | 线程池数量 | 当前处理核数量 * 2 | 这个线程池数量被所有RTopic对象监听器,RRemoteService调用者和RExecutorService任务共同共享。 |
nettyThreads | Netty线程池数量 | 当前处理核数量 * 2 |
这个线程池数量是在一个Redisson实例内,被其创建的所有分布式数据类型和服务,以及底层客户端所一同共享的线程池里保存的线程数量。 |
executor | 线程池 | 单独提供一个用来执行所有RTopic对象监听器,RRemoteService调用者和RExecutorService任务的线程池(ExecutorService)实例。 | |
eventLoopGroup |
用于特别指定一个EventLoopGroup. EventLoopGroup是用来处理所有通过Netty与Redis服务之间的连接发送和接受的消息。 每一个Redisson都会在默认情况下自己创建管理一个EventLoopGroup实例。 因此,如果在同一个JVM里面可能存在多个Redisson实例的情况下,采取这个配置实现多个Redisson实例共享一个EventLoopGroup的目的。 只有io.netty.channel.epoll.EpollEventLoopGroup或io.netty.channel.nio.NioEventLoopGroup才是允许的类型。 |
||
transportMode | 传输模式 | TransportMode.NIO |
可选参数: |
lockWatchdogTimeout |
监控锁的看门狗超时。单位:毫秒 |
30000 |
监控锁的看门狗超时时间单位为毫秒。该参数只适用于分布式锁的加锁请求中未明确使用leaseTimeout参数的情况。 如果该看门口未使用lockWatchdogTimeout去重新调整一个分布式锁的lockWatchdogTimeout超时,那么这个锁将变为失效状态。 这个参数可以用来避免由Redisson客户端节点宕机或其他原因造成死锁的情况。 |
keepPubSubOrder | 保持订阅发布顺序 | true | 通过该参数来修改是否按订阅发布消息的接收顺序出来消息,如果选否将对消息实行并行处理,该参数只适用于订阅发布消息的情况。 |
performanceMode | 高性能模式 |
HIGHER_THROUGHPUT |
用来指定高性能引擎的行为。由于该变量值的选用与使用场景息息相关(NORMAL除外)我们建议对每个参数值都进行尝试。 该参数仅限于Redisson PRO版本。 可选模式: HIGHER_THROUGHPUT - 将高性能引擎切换到 高通量 模式。 LOWER_LATENCY_AUTO - 将高性能引擎切换到 低延时 模式并自动探测最佳设定。 LOWER_LATENCY_MODE_1 - 将高性能引擎切换到 低延时 模式并调整到预设模式1。 LOWER_LATENCY_MODE_2 - 将高性能引擎切换到 低延时 模式并调整到预设模式2。 NORMAL - 将高性能引擎切换到 普通 模式 |
ClusterServersConfig类
ClusterServersConfig clusterConfig = config.useClusterServers();
nodeAddresses(添加节点地址)
可以通过host:port的格式来添加Redis集群节点的地址。多个节点可以一次性批量添加。
scanInterval(集群扫描间隔时间)
默认值: 1000,对Redis集群节点状态扫描的时间间隔。单位是毫秒。
slots(分片数量)
默认值: 231用于指定数据分片过程中的分片数量。支持数据分片/框架结构有:集(Set)、映射(Map)、BitSet、Bloom filter, Spring Cache和Hibernate Cache等.
readMode(读取操作的负载均衡模式)
默认值: SLAVE(只在从服务节点里读取)注:在从服务节点里读取的数据说明已经至少有两个节点保存了该数据,确保了数据的高可用性。设置读取操作选择节点的模式。可用值为:SLAVE - 只在从服务节点里读取。MASTER - 只在主服务节点里读取。MASTER_SLAVE - 在主从服务节点里都可以读取。
subscriptionMode(订阅操作的负载均衡模式)
默认值:SLAVE(只在从服务节点里订阅),设置订阅操作选择节点的模式。可用值为:SLAVE - 只在从服务节点里订阅。MASTER - 只在主服务节点里订阅。
loadBalancer(负载均衡算法类的选择)
默认值: org.redisson.connection.balancer.RoundRobinLoadBalancer
在多Redis服务节点的环境里,可以选用以下几种负载均衡方式选择一个节点:org.redisson.connection.balancer.WeightedRoundRobinBalancer - 权重轮询调度算法org.redisson.connection.balancer.RoundRobinLoadBalancer - 轮询调度算法org.redisson.connection.balancer.RandomLoadBalancer - 随机调度算法
subscriptionConnectionMinimumIdleSize(从节点发布和订阅连接的最小空闲连接数)
默认值:1。多从节点的环境里,每个 从服务节点里用于发布和订阅连接的最小保持连接数(长连接)。Redisson内部经常通过发布和订阅来实现许多功能。长期保持一定数量的发布订阅连接是必须的。
subscriptionConnectionPoolSize(从节点发布和订阅连接池大小)
默认值:50。多从节点的环境里,每个 从服务节点里用于发布和订阅连接的连接池最大容量。连接池的连接数量自动弹性伸缩。
slaveConnectionMinimumIdleSize(从节点最小空闲连接数)
默认值:32。多从节点的环境里,每个 从服务节点里用于普通操作(非 发布和订阅)的最小保持连接数(长连接)。长期保持一定数量的连接有利于提高瞬时读取反映速度。
slaveConnectionPoolSize(从节点连接池大小)
默认值:64。多从节点的环境里,每个 从服务节点里用于普通操作(非 发布和订阅)连接的连接池最大容量。连接池的连接数量自动弹性伸缩。
masterConnectionMinimumIdleSize(主节点最小空闲连接数)
默认值:32。多节点的环境里,每个 主节点的最小保持连接数(长连接)。长期保持一定数量的连接有利于提高瞬时写入反应速度。
masterConnectionPoolSize(主节点连接池大小)
默认值:64。多主节点的环境里,每个 主节点的连接池最大容量。连接池的连接数量自动弹性伸缩。
idleConnectionTimeout(连接空闲超时,单位:毫秒)
默认值:10000。如果当前连接池里的连接数量超过了最小空闲连接数,而同时有连接空闲时间超过了该数值,那么这些连接将会自动被关闭,并从连接池里去掉。时间单位是毫秒。
connectTimeout(连接超时,单位:毫秒)
默认值:10000。同任何节点建立连接时的等待超时。时间单位是毫秒。
timeout(命令等待超时,单位:毫秒)
默认值:3000。等待节点回复命令的时间。该时间从命令发送成功时开始计时。
retryAttempts(命令失败重试次数)
默认值:3。如果尝试达到 retryAttempts(命令失败重试次数) 仍然不能将命令发送至某个指定的节点时,将抛出错误。如果尝试在此限制之内发送成功,则开始启用 timeout(命令等待超时) 计时。
retryInterval(命令重试发送时间间隔,单位:毫秒)
默认值:1500。在一条命令发送失败以后,等待重试发送的时间间隔。时间单位是毫秒。
reconnectionTimeout(重新连接时间间隔,单位:毫秒)
默认值:3000。当与某个节点的连接断开时,等待与其重新建立连接的时间间隔。时间单位是毫秒。
failedAttempts(执行失败最大次数)
默认值:3。在某个节点执行相同或不同命令时,连续 失败 failedAttempts(执行失败最大次数) 时,该节点将被从可用节点列表里清除,直到 reconnectionTimeout(重新连接时间间隔) 超时以后再次尝试。
password(密码)
默认值:null。用于节点身份验证的密码。
subscriptionsPerConnection(单个连接最大订阅数量)
默认值:5。每个连接的最大订阅数量。
clientName(客户端名称)
默认值:null。在Redis节点里显示的客户端名称。
sslEnableEndpointIdentification(启用SSL终端识别)
默认值:true。开启SSL终端识别能力。
sslProvider(SSL实现方式)
默认值:JDK。确定采用哪种方式(JDK或OPENSSL)来实现SSL连接。
sslTruststore(SSL信任证书库路径)
默认值:null。指定SSL信任证书库的路径。
sslTruststorePassword(SSL信任证书库密码)
默认值:null。指定SSL信任证书库的密码。
sslKeystore(SSL钥匙库路径)
默认值:null。指定SSL钥匙库的路径。
sslKeystorePassword(SSL钥匙库密码)
默认值:null。指定SSL钥匙库的密码。
SingleServerConfig类
SingleServerConfig singleConfig = config.useSingleServer();
address(节点地址)
可以通过host:port的格式来指定节点地址。
subscriptionConnectionMinimumIdleSize(发布和订阅连接的最小空闲连接数)
默认值:1。用于发布和订阅连接的最小保持连接数(长连接)。Redisson内部经常通过发布和订阅来实现许多功能。长期保持一定数量的发布订阅连接是必须的。
subscriptionConnectionPoolSize(发布和订阅连接池大小)
默认值:50。用于发布和订阅连接的连接池最大容量。连接池的连接数量自动弹性伸缩。
connectionMinimumIdleSize(最小空闲连接数)
默认值:32。最小保持连接数(长连接)。长期保持一定数量的连接有利于提高瞬时写入反应速度。
connectionPoolSize(连接池大小)
默认值:64。连接池最大容量。连接池的连接数量自动弹性伸缩。
dnsMonitoring(是否启用DNS监测)
默认值:false。在启用该功能以后,Redisson将会监测DNS的变化情况。
dnsMonitoringInterval(DNS监测时间间隔,单位:毫秒)
默认值:5000。监测DNS的变化情况的时间间隔。
idleConnectionTimeout(连接空闲超时,单位:毫秒)
默认值:10000。如果当前连接池里的连接数量超过了最小空闲连接数,而同时有连接空闲时间超过了该数值,那么这些连接将会自动被关闭,并从连接池里去掉。时间单位是毫秒。
connectTimeout(连接超时,单位:毫秒)
默认值:10000。同节点建立连接时的等待超时。时间单位是毫秒。
timeout(命令等待超时,单位:毫秒)
默认值:3000。等待节点回复命令的时间。该时间从命令发送成功时开始计时。
retryAttempts(命令失败重试次数)
默认值:3。如果尝试达到 retryAttempts(命令失败重试次数) 仍然不能将命令发送至某个指定的节点时,将抛出错误。如果尝试在此限制之内发送成功,则开始启用 timeout(命令等待超时) 计时。
retryInterval(命令重试发送时间间隔,单位:毫秒)
默认值:1500。在一条命令发送失败以后,等待重试发送的时间间隔。时间单位是毫秒。
reconnectionTimeout(重新连接时间间隔,单位:毫秒)
默认值:3000。当与某个节点的连接断开时,等待与其重新建立连接的时间间隔。时间单位是毫秒。
failedAttempts(执行失败最大次数)
默认值:3。在某个节点执行相同或不同命令时,连续 失败 failedAttempts(执行失败最大次数) 时,该节点将被从可用节点列表里清除,直到 reconnectionTimeout(重新连接时间间隔) 超时以后再次尝试。
database(数据库编号)
默认值:0。尝试连接的数据库编号。
password(密码)
默认值:null。用于节点身份验证的密码。
subscriptionsPerConnection(单个连接最大订阅数量)
默认值:5。每个连接的最大订阅数量。
clientName(客户端名称)
默认值:null。在Redis节点里显示的客户端名称。
sslEnableEndpointIdentification(启用SSL终端识别)
默认值:true。开启SSL终端识别能力。
sslProvider(SSL实现方式)
默认值:JDK。确定采用哪种方式(JDK或OPENSSL)来实现SSL连接。
sslTruststore(SSL信任证书库路径)
默认值:null。指定SSL信任证书库的路径。
sslTruststorePassword(SSL信任证书库密码)
默认值:null。指定SSL信任证书库的密码。
sslKeystore(SSL钥匙库路径)
默认值:null。指定SSL钥匙库的路径。
sslKeystorePassword(SSL钥匙库密码)
默认值:null。指定SSL钥匙库的密码。
SentinelServersConfig类
SentinelServersConfig sentinelConfig = config.useSentinelServers();
dnsMonitoringInterval(DNS监控间隔,单位:毫秒)
默认值:5000。用来指定检查节点DNS变化的时间间隔。使用的时候应该确保JVM里的DNS数据的缓存时间保持在足够低的范围才有意义。用-1来禁用该功能。
masterName(主服务器的名称)
主服务器的名称是哨兵进程中用来监测主从服务切换情况的。
addSentinelAddress(添加哨兵节点地址)
可以通过host:port的格式来指定哨兵节点的地址。多个节点可以一次性批量添加。
readMode(读取操作的负载均衡模式)
默认值: SLAVE(只在从服务节点里读取)注:在从服务节点里读取的数据说明已经至少有两个节点保存了该数据,确保了数据的高可用性。
设置读取操作选择节点的模式。可用值为:SLAVE - 只在从服务节点里读取。MASTER - 只在主服务节点里读取。MASTER_SLAVE - 在主从服务节点里都可以读取。
subscriptionMode(订阅操作的负载均衡模式)
默认值:SLAVE(只在从服务节点里订阅)。设置订阅操作选择节点的模式。可用值为:SLAVE - 只在从服务节点里订阅。MASTER - 只在主服务节点里订阅。
loadBalancer(负载均衡算法类的选择)
默认值: org.redisson.connection.balancer.RoundRobinLoadBalancer
在使用多个Redis服务节点的环境里,可以选用以下几种负载均衡方式选择一个节点:org.redisson.connection.balancer.WeightedRoundRobinBalancer - 权重轮询调度算法org.redisson.connection.balancer.RoundRobinLoadBalancer - 轮询调度算法org.redisson.connection.balancer.RandomLoadBalancer - 随机调度算法
subscriptionConnectionMinimumIdleSize(从节点发布和订阅连接的最小空闲连接数)
默认值:1。多从节点的环境里,每个 从服务节点里用于发布和订阅连接的最小保持连接数(长连接)。Redisson内部经常通过发布和订阅来实现许多功能。长期保持一定数量的发布订阅连接是必须的。
subscriptionConnectionPoolSize(从节点发布和订阅连接池大小)
默认值:50。多从节点的环境里,每个 从服务节点里用于发布和订阅连接的连接池最大容量。连接池的连接数量自动弹性伸缩。
slaveConnectionMinimumIdleSize(从节点最小空闲连接数)
默认值:32。多从节点的环境里,每个 从服务节点里用于普通操作(非 发布和订阅)的最小保持连接数(长连接)。长期保持一定数量的连接有利于提高瞬时读取反映速度。
slaveConnectionPoolSize(从节点连接池大小)
默认值:64。多从节点的环境里,每个 从服务节点里用于普通操作(非 发布和订阅)连接的连接池最大容量。连接池的连接数量自动弹性伸缩。
masterConnectionMinimumIdleSize(主节点最小空闲连接数)
默认值:32。多从节点的环境里,每个 主节点的最小保持连接数(长连接)。长期保持一定数量的连接有利于提高瞬时写入反应速度。
masterConnectionPoolSize(主节点连接池大小)
默认值:64。主节点的连接池最大容量。连接池的连接数量自动弹性伸缩。
idleConnectionTimeout(连接空闲超时,单位:毫秒)
默认值:10000。如果当前连接池里的连接数量超过了最小空闲连接数,而同时有连接空闲时间超过了该数值,那么这些连接将会自动被关闭,并从连接池里去掉。时间单位是毫秒。
connectTimeout(连接超时,单位:毫秒)
默认值:10000。同任何节点建立连接时的等待超时。时间单位是毫秒。
timeout(命令等待超时,单位:毫秒)
默认值:3000。等待节点回复命令的时间。该时间从命令发送成功时开始计时。
retryAttempts(命令失败重试次数)
默认值:3。如果尝试达到 retryAttempts(命令失败重试次数) 仍然不能将命令发送至某个指定的节点时,将抛出错误。如果尝试在此限制之内发送成功,则开始启用 timeout(命令等待超时) 计时。
retryInterval(命令重试发送时间间隔,单位:毫秒)
默认值:1500。在一条命令发送失败以后,等待重试发送的时间间隔。时间单位是毫秒。
reconnectionTimeout(重新连接时间间隔,单位:毫秒)
默认值:3000。当与某个节点的连接断开时,等待与其重新建立连接的时间间隔。时间单位是毫秒。
failedAttempts(执行失败最大次数)
默认值:3。在某个节点执行相同或不同命令时,连续 失败 failedAttempts(执行失败最大次数) 时,该节点将被从可用节点列表里清除,直到 reconnectionTimeout(重新连接时间间隔) 超时以后再次尝试。
database(数据库编号)
默认值:0。尝试连接的数据库编号。
password(密码)
默认值:null。用于节点身份验证的密码。
subscriptionsPerConnection(单个连接最大订阅数量)
默认值:5。每个连接的最大订阅数量。
clientName(客户端名称)
默认值:null。在Redis节点里显示的客户端名称。
sslEnableEndpointIdentification(启用SSL终端识别)
默认值:true。开启SSL终端识别能力。
sslProvider(SSL实现方式)
默认值:JDK。确定采用哪种方式(JDK或OPENSSL)来实现SSL连接。
sslTruststore(SSL信任证书库路径)
默认值:null。指定SSL信任证书库的路径。
sslTruststorePassword(SSL信任证书库密码)
默认值:null。指定SSL信任证书库的密码。
sslKeystore(SSL钥匙库路径)
默认值:null。指定SSL钥匙库的路径。
sslKeystorePassword(SSL钥匙库密码)
默认值:null。指定SSL钥匙库的密码。
MasterSlaveServersConfig类
MasterSlaveServersConfig masterSlaveConfig = config.useMasterSlaveServers();
dnsMonitoringInterval(DNS监控间隔,单位:毫秒)
默认值:5000。用来指定检查节点DNS变化的时间间隔。使用的时候应该确保JVM里的DNS数据的缓存时间保持在足够低的范围才有意义。用-1来禁用该功能。
masterAddress(主节点地址)
可以通过host:port的格式来指定主节点地址。
addSlaveAddress(添加从主节点地址)
可以通过host:port的格式来指定从节点的地址。多个节点可以一次性批量添加。
readMode(读取操作的负载均衡模式)
默认值: SLAVE(只在从服务节点里读取)。注:在从服务节点里读取的数据说明已经至少有两个节点保存了该数据,确保了数据的高可用性。
设置读取操作选择节点的模式。可用值为:SLAVE - 只在从服务节点里读取。MASTER - 只在主服务节点里读取。MASTER_SLAVE - 在主从服务节点里都可以读取。
subscriptionMode(订阅操作的负载均衡模式)
默认值:SLAVE(只在从服务节点里订阅)。设置订阅操作选择节点的模式。可用值为:SLAVE - 只在从服务节点里订阅。MASTER - 只在主服务节点里订阅。
loadBalancer(负载均衡算法类的选择)
默认值: org.redisson.connection.balancer.RoundRobinLoadBalancer
在使用多个Redis服务节点的环境里,可以选用以下几种负载均衡方式选择一个节点:org.redisson.connection.balancer.WeightedRoundRobinBalancer - 权重轮询调度算法org.redisson.connection.balancer.RoundRobinLoadBalancer - 轮询调度算法org.redisson.connection.balancer.RandomLoadBalancer - 随机调度算法
subscriptionConnectionMinimumIdleSize(从节点发布和订阅连接的最小空闲连接数)
默认值:1。多从节点的环境里,每个 从服务节点里用于发布和订阅连接的最小保持连接数(长连接)。Redisson内部经常通过发布和订阅来实现许多功能。长期保持一定数量的发布订阅连接是必须的。
subscriptionConnectionPoolSize(从节点发布和订阅连接池大小)
默认值:50。多从节点的环境里,每个 从服务节点里用于发布和订阅连接的连接池最大容量。连接池的连接数量自动弹性伸缩。
slaveConnectionMinimumIdleSize(从节点最小空闲连接数)
默认值:32。多从节点的环境里,每个 从服务节点里用于普通操作(非 发布和订阅)的最小保持连接数(长连接)。长期保持一定数量的连接有利于提高瞬时读取反映速度。
slaveConnectionPoolSize(从节点连接池大小)
默认值:64。多从节点的环境里,每个 从服务节点里用于普通操作(非 发布和订阅)连接的连接池最大容量。连接池的连接数量自动弹性伸缩。
masterConnectionMinimumIdleSize(主节点最小空闲连接数)
默认值:32。多从节点的环境里,每个 主节点的最小保持连接数(长连接)。长期保持一定数量的连接有利于提高瞬时写入反应速度。
masterConnectionPoolSize(主节点连接池大小)
默认值:64。主节点的连接池最大容量。连接池的连接数量自动弹性伸缩。
idleConnectionTimeout(连接空闲超时,单位:毫秒)
默认值:10000。如果当前连接池里的连接数量超过了最小空闲连接数,而同时有连接空闲时间超过了该数值,那么这些连接将会自动被关闭,并从连接池里去掉。时间单位是毫秒。
connectTimeout(连接超时,单位:毫秒)
默认值:10000。同任何节点建立连接时的等待超时。时间单位是毫秒。
timeout(命令等待超时,单位:毫秒)
默认值:3000。等待节点回复命令的时间。该时间从命令发送成功时开始计时。
retryAttempts(命令失败重试次数)
默认值:3。如果尝试达到 retryAttempts(命令失败重试次数) 仍然不能将命令发送至某个指定的节点时,将抛出错误。如果尝试在此限制之内发送成功,则开始启用 timeout(命令等待超时) 计时。
retryInterval(命令重试发送时间间隔,单位:毫秒)
默认值:1500。在一条命令发送失败以后,等待重试发送的时间间隔。时间单位是毫秒。
reconnectionTimeout(重新连接时间间隔,单位:毫秒)
默认值:3000。当与某个节点的连接断开时,等待与其重新建立连接的时间间隔。时间单位是毫秒。
failedAttempts(执行失败最大次数)
默认值:3。在某个节点执行相同或不同命令时,连续 失败 failedAttempts(执行失败最大次数) 时,该节点将被从可用节点列表里清除,直到 reconnectionTimeout(重新连接时间间隔) 超时以后再次尝试。
database(数据库编号)
默认值:0。尝试连接的数据库编号。
password(密码)
默认值:null。用于节点身份验证的密码。
subscriptionsPerConnection(单个连接最大订阅数量)
默认值:5。每个连接的最大订阅数量。
clientName(客户端名称)
默认值:null。在Redis节点里显示的客户端名称。
sslEnableEndpointIdentification(启用SSL终端识别)
默认值:true。开启SSL终端识别能力。
sslProvider(SSL实现方式)
默认值:JDK。确定采用哪种方式(JDK或OPENSSL)来实现SSL连接。
sslTruststore(SSL信任证书库路径)
默认值:null。指定SSL信任证书库的路径。
sslTruststorePassword(SSL信任证书库密码)
默认值:null
指定SSL信任证书库的密码。
sslKeystore(SSL钥匙库路径)
默认值:null。指定SSL钥匙库的路径。
sslKeystorePassword(SSL钥匙库密码)
默认值:null。指定SSL钥匙库的密码。
测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes={RootConfig.class, WebConfig.class}) //如果是Java Config配置的,指定相关的配置类
@WebAppConfiguration
public class RedissionTest {
@Autowired
private RedissonClient redissionClusterNodes;
@Test
public void testConnect(){
RBucket<String> stringRBucket = redissionClusterNodes.getBucket("test");
//设值
stringRBucket.set("1");
System.out.println(stringRBucket.get());
}
}
Redisson 操作API
分布式对象
分布式Object
通过泛型指定对象类型
RBucket<Integer> bucket = redissionClusterNodes.getBucket("test");
bucket.set(1);
Integer obj = bucket.get();
bucket.trySet(3);
bucket.compareAndSet(4, 5);
bucket.getAndSet(6);
分布式BitSet
BitSet是一个bit数据集,类似bit数组,和Set接口没啥关系。对于存储一些需要按位操作的数据是很理想的数据结构。对应于Java中 Java.util.BitSet。
RBucket<Integer> bucket = redissionClusterNodes.getBucket("test");
bucket.set(1);
Integer obj = bucket.get();
bucket.trySet(3);
bucket.compareAndSet(4, 5);
bucket.getAndSet(6);
分布式Lock
RLock lock = redissionClusterNodes.getLock("anyLock");
// Most familiar locking method
lock.lock();
// Lock time-to-live support
// releases lock automatically after 10 seconds
// if unlock method not invoked
lock.lock(10, TimeUnit.SECONDS);
// Wait for 100 seconds and automatically unlock it after 10 seconds
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
//...
lock.unlock();
一般我们在程序中的使用方式都是:
RLock lock = redissionClusterNodes.getLock("anyLock");
lock.lock();
try {
...
} finally {
lock.unlock();
}
分布式ReadWriteLock
RLock lock1 = redissionClusterNodes.getLock("lock1");
RLock lock2 = redissionClusterNodes.getLock("lock2");
RLock lock3 = redissionClusterNodes.getLock("lock3");
RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
lock.lock();
分布式ReadWriteLock
RReadWriteLock rwlock = redissionClusterNodes.getReadWriteLock("anyRWLock");
// Most familiar locking method
rwlock.readLock().lock();
// or
rwlock.writeLock().lock();
// Lock time-to-live support
// releases lock automatically after 10 seconds
// if unlock method not invoked
rwlock.readLock().lock(10, TimeUnit.SECONDS);
// or
rwlock.writeLock().lock(10, TimeUnit.SECONDS);
// Wait for 100 seconds and automatically unlock it after 10 seconds
boolean res = rwlock.readLock().tryLock(100, 10, TimeUnit.SECONDS);
// or
boolean res = rwlock.writeLock().tryLock(100, 10, TimeUnit.SECONDS);
分布式Semaphore
RSemaphore semaphore = redissionClusterNodes.getSemaphore("semaphore");
semaphore.acquire();
semaphore.acquire(23);
semaphore.tryAcquire();
semaphore.tryAcquire(23, TimeUnit.SECONDS);
semaphore.release(10);
semaphore.release();
分布式AtomicLong
RAtomicLong atomicLong = redissionClusterNodes.getAtomicLong("myAtomicLong");
atomicLong.set(3);
atomicLong.incrementAndGet();
atomicLong.get();
分布式AtomicDouble
RAtomicDouble atomicDouble = redissionClusterNodes.getAtomicDouble("myAtomicDouble");
atomicDouble.set(2.81);
atomicDouble.addAndGet(4.11);
atomicDouble.get();
分布式CountDownLatch
RCountDownLatch latch = redissionClusterNodes.getCountDownLatch("anyCountDownLatch");
latch.trySetCount(1);
latch.await();
// in other thread or other JVM
RCountDownLatch latch2 = redissionClusterNodes.getCountDownLatch("anyCountDownLatch");
latch2.countDown();
Topic
RTopic topic = redissionClusterNodes.getTopic("mytopic");
topic.addListener(String.class, new MessageListener<String>() {
@Override
public void onMessage(CharSequence channel, String s) {
System.out.println("channel=" + channel); //mytopic
System.out.println("接收到的消息:" + s);
}
});
// in other thread or JVM
RTopic topic2 = redissionClusterNodes.getTopic("mytopic");
long clientsReceivedMessage = topic.publish("1234567");
System.out.println(clientsReceivedMessage);
Topic patttern
// subscribe to all topics by `topic1.*` pattern
RPatternTopic topic1 = redissionClusterNodes.getPatternTopic("topic1.*");
topic1.addListener(String.class, new PatternMessageListener<String>() {
@Override
public void onMessage(CharSequence pattern, CharSequence channel, String msg) {
System.out.println("pattern=" + pattern); //topic1.*
System.out.println("channel=" + channel); //topic1.a
System.out.println("msg=" + msg); //1234567
}
});
RTopic topic2 = redissionClusterNodes.getTopic("topic1.a");
long clientsReceivedMessage = topic2.publish("1234567");
System.out.println(clientsReceivedMessage);
分布式集合
分布式Map
除此之外,还支持Multimap。
RMap<String, String> map = redissionClusterNodes.getMap("anyMap");
map.put("name", "hello");
//如果不存在,那么会向map中添加该键值对,并返回null。
//如果已经存在,那么不会覆盖已有的值,直接返回已经存在的值。
String currentValue = map.putIfAbsent("name", "harvey");
System.out.println("currentValue=" + currentValue);
//删除键的值,返回相应的值
String obj = map.remove("name");
System.out.println("obj=" + obj);
map.fastPut("name", "test");
map.fastRemove("name");
//异步设值,马上取无法取到设置的值
Future<String> putAsyncFuture = map.putAsync("alia", "cool");
System.out.println("asyncFuture value = " + putAsyncFuture.get());
//快速异步设值,只返回true或false,如果已存在返回的是false
RFuture<Boolean> rFuture = map.fastPutAsync("alia4", "mixue");
System.out.println("asyncFuture value boolean = " + rFuture.get());
map.fastPutAsync("321", "6666666");
map.fastRemoveAsync("321");
Map eviction
现在Redis没有过期清空Map中的某个entry的功能,只能是清空Map所有的entry。Redission提供了这种功能。
RMapCache<Object, Object> mapCache = redissionClusterNodes.getMapCache("anyMap");
// ttl = 10 minutes,
mapCache.put("key1", "hello", 10, TimeUnit.MINUTES);
// ttl = 10 minutes, maxIdleTime = 10 seconds
mapCache.put("key1", "hello", 10, TimeUnit.MINUTES, 10, TimeUnit.SECONDS);
// ttl = 3 seconds
mapCache.putIfAbsent("key2", "hello", 3, TimeUnit.SECONDS);
// ttl = 40 seconds, maxIdleTime = 10 seconds
mapCache.putIfAbsent("key2", "hello", 40, TimeUnit.SECONDS, 10, TimeUnit.SECONDS);
分布式Set
RSet<String> set = redissionClusterNodes.getSet("anySet");
set.add("11");
Set<String> stringSetting = set.readAll();
stringSetting.forEach(s->{
System.out.println(s);
});
set.remove("11");
除此之外还有,还支持Set eviction, SortedSet, ScoredSortedSet, LexSortedSet。
分布式List
RList<String> list = redissionClusterNodes.getList("anyList");
list.add("11");
List<String> stringList = list.readAll();
System.out.println(stringList);
list.get(0);
list.remove("11");
分布式Blocking Queue
RBlockingQueue<String> queue = redissionClusterNodes.getBlockingQueue("anyQueue");
queue.offer("111");
//查看首个元素,不会移除首个元素,如果队列是空的就返回null
String obj = queue.peek();
//查看首个元素,不会移除首个元素,如果队列是空的就抛出异常NoSuchElementException
String obj2 = queue.element();
//将首个元素从队列中弹出,如果队列是空的,就返回null
String someObj = queue.poll();
String ob = queue.poll(10, TimeUnit.MINUTES);
除此之外,还支持Queue, Deque, Blocking Deque。
其他功能
执行批量命令
//future列表
LinkedList<RFuture<Object>> futures = new LinkedList<>();
//结果集
LinkedList<Object> result = new LinkedList<>();
RBatch batch = redissionClusterNodes.createBatch();
for (int i = 0; i < 100; i++) {
RBucketAsync<Object> bucket = batch.getBucket("key" + i);
RFuture<Object> async = bucket.getAsync();
futures.add(async);
}
//批量执行
batch.execute();
while (futures.size() > 0) {
RFuture<Object> first = futures.removeFirst();
//获取当前值,未完成时值为null,使用isDone方法区分value不存在还是任务未完成
Object o = first.getNow();
if (o != null) {
result.add(o);
} else {
if (!first.isDone()) {
futures.addLast(first);
}
}
}