分布式锁组件

组件编码 hzero-starter-lock

一、简介

1.1 概述

hzero-starter-lock 分布式锁组件基于 Redisson 开发，开发中可以通过注解的方式进行分布式锁控制，使项目拥有分布式锁变得非常简单。

1.2 组件坐标

<dependency>
    <groupId>org.hzero.starter</groupId>
    <artifactId>hzero-starter-lock</artifactId>
    <version>${hzero.starter.version}</version>
</dependency>

1.3 特性

• 依赖Redis，支持单节点模式、集群模式、云托管模式、哨兵模式、主从模式
• 通过注解的方式进行使用，控制细节对开发者透明
• 多种锁类型：可重入锁、公平锁、联锁、红锁、读锁、写锁，使用起来更加灵活
• 注解多种常用属性，使控制更加精细化

二、使用指南

2.1 配置

考虑到支持多种redis运行模式，没有使用redis的默认配置方式

// 单节点模式示例
hzero:
  lock:
    pattern: single
    single-server:
      address: 127.0.0.1
      port: 6379

// 集群模式示例
hzero:
  lock:
    pattern: cluster
    cluster-server:
      nodeAddresses: 127.0.0.1:6379,127.0.0.1:6389

// 主从模式示例
hzero:
  lock:
    pattern: master_slave
    master-slave-server:
      master-address: 127.0.0.1:6379
      slave-addresses: 127.0.0.1:6389,127.0.0.1:6399

// 哨兵模式示例
hzero:
  lock:
    pattern: sentinel
    sentinel-server:
      master-name: mymaster
      sentinel-addresses: 127.0.0.1:6389,127.0.0.1:6399

// 云托管模式示例
hzero:
  lock:
    pattern: replicated
    replicated-server:
      node-addresses: 127.0.0.1:6379,127.0.0.1:6389

redis连接配置参数详细说明：

单节点模式

// 节点地址
hzero.lock.singleServer.address
// 节点端口
hzero.lock.singleServer.port
// 发布和订阅连接的最小空闲连接数
hzero.lock.singlServer.subConnMinIdleSize = 1
// 发布和订阅连接池大小
hzero.lock.singleServer.subConnPoolSize = 50
// 最小空闲连接数
hzero.lock.singleServer.connMinIdleSize = 32
// 连接池大小
hzero.lock.singleServer.connPoolSize = 64
// 是否启用DNS监测
hzero.lock.singleServer.dnsMonitoring = false
// DNS监测时间间隔，单位：毫秒，该配置需要dnsMonitoring设为true
hzero.lock.singleServer.dnsMonitoringInterval = 5000
// 连接空闲超时，单位：毫秒
hzero.lock.singleServer.idleConnTimeout = 10000
hzero.lock.singleServer.keepAlive = false
// 连接超时，单位：毫秒
hzero.lock.singleServer.connTimeout = 10000
// 命令等待超时，单位：毫秒
hzero.lock.singleServer.timeout = 3000
// 命令失败重试次数 如果尝试达到 retryAttempts（命令失败重试次数） 仍然不能将命令发送至某个指定的节点时，将抛出错误。如果尝试在此限制之内发送成功，则开始启用timeout（命令等待超时） 计时。
hzero.lock.singleServer.retryAttempts = 3
// 命令重试发送时间间隔，单位：毫秒
hzero.lock.singleServer.retryInterval = 1500
// 数据库编号
hzero.lock.singleServer.database = 0
// 密码
hzero.lock.singleServer.password
// 单个连接最大订阅数量
hzero.lock.singleServer.subPerConn = 5

集群模式

// 集群节点地址
hzero.lock.clusterServer.nodeAddresses
// 集群扫描间隔时间
hzero.lock.clusterServer.scanInterval = 1000
// 读取操作的负载均衡模式
hzero.lock.clusterServer.readMode = SLAVE
// 订阅操作的负载均衡模式
hzero.lock.clusterServer.subMode = SLAVE
// 负载均衡算法类的选择，默认：轮询调度算法
hzero.lock.clusterServer.loadBalancer = RoundRobinLoadBalancer
// 默认权重值，当负载均衡算法是权重轮询调度算法时该属性有效
hzero.lock.clusterServer.defaultWeight = 0
// 权重值设置，格式为 host1:port1,权重值1host2:port2,权重值2 当负载均衡算法是权重轮询调度算法时该属性有效
hzero.lock.clusterServer.weightMaps
// 从节点发布和订阅连接的最小空闲连接数
hzero.lock.clusterServer.subConnMinIdleSize = 1
// 从节点发布和订阅连接池大小
hzero.lock.clusterServer.subConnPoolSize = 50
// 从节点最小空闲连接数
hzero.lock.clusterServer.slaveConnMinIdleSize = 32
// 从节点连接池大小
hzero.lock.clusterServer.slaveConnPoolSize = 64
// 主节点最小空闲连接数
hzero.lock.clusterServer.masterConnMinIdleSize = 32
// 主节点连接池大小
hzero.lock.clusterServer.masterConnPoolSize = 64
// 连接空闲超时，单位：毫秒
hzero.lock.clusterServer.idleConnTimeout = 10000
// 连接超时，单位：毫秒
hzero.lock.clusterServer.connTimeout = 10000
// 命令等待超时，单位：毫秒
hzero.lock.clusterServer.timeout = 3000
// 命令失败重试次数
hzero.lock.clusterServer.retryAttempts = 3
// 命令重试发送时间间隔，单位：毫秒
hzero.lock.clusterServer.retryInterval = 1500
// 密码
hzero.lock.clusterServer.password
// 单个连接最大订阅数量
hzero.lock.clusterServer.subPerConn = 5

主从模式

// DNS监控间隔，单位:毫秒
hzero.lock.masterSlaveServer.dnsMonitoringInterval = 5000
// 主节点地址，可以通过host:port的格式来指定主节点地址。
hzero.lock.masterSlaveServer.masterAddress
// 从节点地址
hzero.lock.masterSlaveServer.slaveAddresses
// 读取操作的负载均衡模式
hzero.lock.masterSlaveServer.readMode = SLAVE
// 订阅操作的负载均衡模式
hzero.lock.masterSlaveServer.subMode = SLAVE
// 负载均衡算法类的选择，默认：轮询调度算法
hzero.lock.masterSlaveServer.loadBalancer = RoundRobinLoadBalancer
// 默认权重值，当负载均衡算法是权重轮询调度算法时该属性有效
hzero.lock.masterSlaveServer.defaultWeight = 0
// 权重值设置，格式为 host1:port1,权重值1host2:port2,权重值2 当负载均衡算法是权重轮询调度算法时该属性有效
hzero.lock.masterSlaveServer.weightMaps
// 从节点发布和订阅连接的最小空闲连接数
hzero.lock.masterSlaveServer.subscriptionConnectionMinimumIdleSize = 1
// 从节点发布和订阅连接池大小
hzero.lock.masterSlaveServer.subscriptionConnectionPoolSize = 50
// 从节点最小空闲连接数
hzero.lock.masterSlaveServer.slaveConnectionMinimumIdleSize = 32
// 从节点连接池大小
hzero.lock.masterSlaveServer.slaveConnectionPoolSize = 64
// 主节点最小空闲连接数
hzero.lock.masterSlaveServer.masterConnectionMinimumIdleSize = 32
// 主节点连接池大小
hzero.lock.masterSlaveServer.masterConnectionPoolSize = 64
// 连接空闲超时，单位：毫秒
hzero.lock.masterSlaveServer.idleConnectionTimeout = 10000
// 连接超时，单位：毫秒
hzero.lock.masterSlaveServer.connectTimeout = 10000
// 命令等待超时，单位：毫秒
hzero.lock.masterSlaveServer.timeout = 3000
// 命令失败重试次数
hzero.lock.masterSlaveServer.retryAttempts = 3
// 命令重试发送时间间隔，单位：毫秒
hzero.lock.masterSlaveServer.retryInterval = 1500
// 重新连接时间间隔，单位：毫秒
hzero.lock.masterSlaveServer.reconnectionTimeout = 3000
// 执行失败最大次数
hzero.lock.masterSlaveServer.failedAttempts = 3
// 数据库编号
hzero.lock.masterSlaveServer.database = 0
// 密码，用于节点身份验证的密码
hzero.lock.masterSlaveServer.password
// 单个连接最大订阅数量
hzero.lock.masterSlaveServer.subscriptionsPerConnection = 5

哨兵模式

// DNS监控间隔，单位：毫秒；用-1来禁用该功能。
hzero.lock.sentinelServer.dnsMonitoringInterval = 5000
// 主服务器的名称
hzero.lock.sentinelServer.masterName
// 哨兵节点地址，多个节点可以一次性批量添加。
hzero.lock.sentinelServer.sentinelAddresses
// 读取操作的负载均衡模式
hzero.lock.sentinelServer.readMode = SLAVE
// 订阅操作的负载均衡模式
hzero.lock.sentinelServer.subMode = SLAVE
// 负载均衡算法类的选择，默认：轮询调度算法
hzero.lock.sentinelServer.loadBalancer = RoundRobinLoadBalancer
// 默认权重值，当负载均衡算法是权重轮询调度算法时该属性有效
hzero.lock.sentinelServer.defaultWeight = 0
// 权重值设置，格式为 host1:port1,权重值1host2:port2,权重值2 当负载均衡算法是权重轮询调度算法时该属性有效
hzero.lock.sentinelServer.weightMaps
// 从节点发布和订阅连接的最小空闲连接数
hzero.lock.sentinelServer.subscriptionConnectionMinimumIdleSize = 1
// 从节点发布和订阅连接池大小
hzero.lock.sentinelServer.subscriptionConnectionPoolSize = 50
// 从节点最小空闲连接数
hzero.lock.sentinelServer.slaveConnectionMinimumIdleSize = 32
// 从节点连接池大小
hzero.lock.sentinelServer.slaveConnectionPoolSize = 64
// 主节点最小空闲连接数
hzero.lock.sentinelServer.masterConnectionMinimumIdleSize = 32
// 主节点连接池大小
hzero.lock.sentinelServer.masterConnectionPoolSize = 64
// 连接空闲超时，单位：毫秒
hzero.lock.sentinelServer.idleConnectionTimeout = 10000
// 连接超时，单位：毫秒
hzero.lock.sentinelServer.connectTimeout = 10000
// 命令等待超时，单位：毫秒
hzero.lock.sentinelServer.timeout = 3000
// 命令失败重试次数
hzero.lock.sentinelServer.retryAttempts = 3
// 命令重试发送时间间隔，单位：毫秒
hzero.lock.sentinelServer.retryInterval = 1500
// 数据库编号
hzero.lock.sentinelServer.database = 0
// 密码，用于节点身份验证的密码
hzero.lock.sentinelServer.password
// 单个连接最大订阅数量
hzero.lock.sentinelServer.subscriptionsPerConnection = 5

云托管模式

// 集群节点地址
hzero.lock.replicatedServer.nodeAddresses
// 主节点变化扫描间隔时间
hzero.lock.replicatedServer.scanInterval = 1000
// DNS监控间隔，单位：毫秒；用-1来禁用该功能。
hzero.lock.replicatedServer.dnsMonitoringInterval = 5000
// 读取操作的负载均衡模式
hzero.lock.replicatedServer.readMode = SLAVE
// 订阅操作的负载均衡模式
hzero.lock.replicatedServer.subscriptionMode = SLAVE
// 负载均衡算法类的选择，默认：轮询调度算法
hzero.lock.replicatedServer.loadBalancer = RoundRobinLoadBalancer
// 默认权重值，当负载均衡算法是权重轮询调度算法时该属性有效
hzero.lock.replicatedServer.defaultWeight = 0
// 权重值设置，格式为 host1:port1,权重值1host2:port2,权重值2 当负载均衡算法是权重轮询调度算法时该属性有效
hzero.lock.replicatedServer.weightMaps
// 从节点发布和订阅连接的最小空闲连接数
hzero.lock.replicatedServer.subscriptionConnectionMinimumIdleSize = 1
// 从节点发布和订阅连接池大小
hzero.lock.replicatedServer.subscriptionConnectionPoolSize = 50
// 从节点最小空闲连接数
hzero.lock.replicatedServer.slaveConnectionMinimumIdleSize = 32
// 从节点连接池大小
hzero.lock.replicatedServer.slaveConnectionPoolSize = 64
// 主节点最小空闲连接数
hzero.lock.replicatedServer.masterConnectionMinimumIdleSize = 32
// 主节点连接池大小
hzero.lock.replicatedServer.masterConnectionPoolSize = 64
// 连接空闲超时，单位：毫秒
hzero.lock.replicatedServer.idleConnectionTimeout = 10000
// 连接超时，单位：毫秒
hzero.lock.replicatedServer.connectTimeout = 10000
// 命令等待超时，单位：毫秒
hzero.lock.replicatedServer.timeout = 3000
// 命令失败重试次数
hzero.lock.replicatedServer.retryAttempts = 3
// 命令重试发送时间间隔，单位：毫秒
hzero.lock.replicatedServer.retryInterval = 1500
// 数据库编号
hzero.lock.replicatedServer.database = 0
// 密码，用于节点身份验证的密码
hzero.lock.replicatedServer.password
// 单个连接最大订阅数量
hzero.lock.replicatedServer.subscriptionsPerConnection = 5

2.2 使用注解

@Service
public class TestService {
    @Lock(keys = {"#user.name","#user.id"},waitTime = Long.MAX_VALUE)
    public String updateUser(User user,@LockKey Long tenantId) throws Exception {
        return "Test Lock";
    }
}

@Lock注解参数说明（此注解使用在需要加锁的方法上）

@Lock可以标注四个参数，作用分别如下

name：lock的name，对应redis的key值。默认为：类名+方法名+指定参数，如指定了名称，则直接使用指定名称

lockType：锁的类型，目前支持（公平锁LockType.FAIR，可重入锁LockType.REENTRANT，读锁LockType.READ，写锁LockType.WRITE，红锁LockType.RED，联锁LockType.MULTI）。默认为：公平锁

waitTime：获取锁最长等待时间。默认为：60s。同时也可通过spring:redis:lock:waitTime统一配置

leaseTime：获得锁后，自动释放锁的时间。默认为：60s。设置值为-1，会根据程序执行时间自动延长过期时间。同时也可通过spring:redis:lock:leaseTime统一配置

keys：自定义业务Key，针对参数为对象，可使用此种方式进行申明，如：keys = {"#user.name","#user.id"}

@LockKey注解参数说明（此注解使用在需要加锁方法的参数上）

@LockKey可以标注的参数如下：

value：默认值

三、版本更新日志

• 0.8.0.RELEASE 快照版 [2019-03-29]