• 分布式锁组件


    组件编码 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 特性

    二、使用指南

    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。同时也可通过spring:redis:lock:leaseTime统一配置
    
    keys:自定义业务Key,针对参数为对象,可使用此种方式进行申明,如:keys = {"#user.name","#user.id"}
    
    

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

    @LockKey可以标注的参数如下:
    
    value:默认值
    
    

    三、版本更新日志