????????Redisson 是一種基于 Redis 的 Java 駐留集群的分布式對象和服務庫，可以為我們提供豐富的分布式鎖和線程安全集合的實現(xiàn)。在 Spring Boot 應用程序中使用 Redisson 可以方便地實現(xiàn)分布式應用程序的某些方面，例如分布式鎖、分布式集合、分布式事件發(fā)布和訂閱等。本篇是一個使用 Redisson 實現(xiàn)分布式鎖的詳細示例，在這個示例中，我們定義了DistributedLock注解，它可以標注在方法上，配合DistributedLockAspect切面以及IDistributedLock分布式鎖封裝的接口，來實現(xiàn)redisson 分布式鎖的 API 調用。

Spring Boot 集成 Redisson

?1、在 pom.xml 文件中添加 Redisson 的相關依賴

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.1</version>
</dependency>

2、在 application.yml 中配置 Redisson單機模式 的連接信息和相關參數(shù)

spring:
  redis:
    host: localhost
    port: 6379
    password: null
redisson:
  codec: org.redisson.codec.JsonJacksonCodec
  threads: 4
  netty:
    threads: 4
  single-server-config:
    address: "redis://localhost:6379"
    password: null
    database: 0

3、Redission還支持主從、集群、哨兵配置

//主從模式
spring:
  redis:
    sentinel:
      master: my-master
      nodes: localhost:26379,localhost:26389
    password: your_password
redisson:
  master-slave-config:
    master-address: "redis://localhost:6379"
    slave-addresses: "redis://localhost:6380,redis://localhost:6381"
    password: ${spring.redis.password}

// 集群模式
spring:
  redis:
    cluster:
      nodes: localhost:6379,localhost:6380,localhost:6381,localhost:6382,localhost:6383,localhost:6384
    password: your_password
redisson:
  cluster-config:
    node-addresses: "redis://localhost:6379,redis://localhost:6380,redis://localhost:6381,redis://localhost:6382,redis://localhost:6383,redis://localhost:6384"
    password: ${spring.redis.password}

// 哨兵模式
spring:
  redis:
    sentinel:
      master: my-master
      nodes: localhost:26379,localhost:26389
    password: your_password
redisson:
  sentinel-config:
    master-name: my-master
    sentinel-addresses: "redis://localhost:26379,redis://localhost:26380,redis://localhost:26381"
    password: ${spring.redis.password}

?本地封裝Redisson 分布式鎖

1、定義IDistributedLock分布式鎖接口

public interface IDistributedLock {
    /**
     * 獲取鎖，默認30秒失效，失敗一直等待直到獲取鎖
     *
     * @param key 鎖的key
     * @return 鎖對象
     */
    ILock lock(String key);

    /**
     * 獲取鎖,失敗一直等待直到獲取鎖
     *
     * @param key      鎖的key
     * @param lockTime 加鎖的時間，超過這個時間后鎖便自動解鎖； 如果lockTime為-1，則保持鎖定直到顯式解鎖
     * @param unit     {@code lockTime} 參數(shù)的時間單位
     * @param fair     是否公平鎖
     * @return 鎖對象
     */
    ILock lock(String key, long lockTime, TimeUnit unit, boolean fair);

    /**
     * 嘗試獲取鎖，30秒獲取不到超時異常，鎖默認30秒失效
     *
     * @param key     鎖的key
     * @param tryTime 獲取鎖的最大嘗試時間
     * @return
     * @throws Exception
     */
    ILock tryLock(String key, long tryTime) throws Exception;

    /**
     * 嘗試獲取鎖，獲取不到超時異常
     *
     * @param key      鎖的key
     * @param tryTime  獲取鎖的最大嘗試時間
     * @param lockTime 加鎖的時間
     * @param unit     {@code tryTime @code lockTime} 參數(shù)的時間單位
     * @param fair     是否公平鎖
     * @return
     * @throws Exception
     */
    ILock tryLock(String key, long tryTime, long lockTime, TimeUnit unit, boolean fair) throws Exception;

    /**
     * 解鎖
     *
     * @param lock
     * @throws Exception
     */
    void unLock(Object lock);


    /**
     * 釋放鎖
     *
     * @param lock
     * @throws Exception
     */
    default void unLock(ILock lock) {
        if (lock != null) {
            unLock(lock.getLock());
        }
    }


}

2、IDistributedLock實現(xiàn)類

@Slf4j
@Component
public class RedissonDistributedLock implements IDistributedLock {

    @Resource
    private RedissonClient redissonClient;
    /**
     * 統(tǒng)一前綴
     */
    @Value("${redisson.lock.prefix:bi:distributed:lock}")
    private String prefix;

    @Override
    public ILock lock(String key) {
        return this.lock(key, 0L, TimeUnit.SECONDS, false);
    }

    @Override
    public ILock lock(String key, long lockTime, TimeUnit unit, boolean fair) {
        RLock lock = getLock(key, fair);
        // 獲取鎖,失敗一直等待,直到獲取鎖,不支持自動續(xù)期
        if (lockTime > 0L) {
            lock.lock(lockTime, unit);
        } else {
            // 具有Watch Dog 自動延期機制 默認續(xù)30s 每隔30/3=10 秒續(xù)到30s
            lock.lock();
        }
        return new ILock(lock, this);
    }

    @Override
    public ILock tryLock(String key, long tryTime) throws Exception {
        return this.tryLock(key, tryTime, 0L, TimeUnit.SECONDS, false);
    }

    @Override
    public ILock tryLock(String key, long tryTime, long lockTime, TimeUnit unit, boolean fair)
            throws Exception {
        RLock lock = getLock(key, fair);
        boolean lockAcquired;
        // 嘗試獲取鎖，獲取不到超時異常,不支持自動續(xù)期
        if (lockTime > 0L) {
            lockAcquired = lock.tryLock(tryTime, lockTime, unit);
        } else {
            // 具有Watch Dog 自動延期機制 默認續(xù)30s 每隔30/3=10 秒續(xù)到30s
            lockAcquired = lock.tryLock(tryTime, unit);
        }
        if (lockAcquired) {
            return new ILock(lock, this);
        }
        return null;
    }

    /**
     * 獲取鎖
     *
     * @param key
     * @param fair
     * @return
     */
    private RLock getLock(String key, boolean fair) {
        RLock lock;
        String lockKey = prefix + ":" + key;
        if (fair) {
            // 獲取公平鎖
            lock = redissonClient.getFairLock(lockKey);
        } else {
            // 獲取普通鎖
            lock = redissonClient.getLock(lockKey);
        }
        return lock;
    }

    @Override
    public void unLock(Object lock) {
        if (!(lock instanceof RLock)) {
            throw new IllegalArgumentException("Invalid lock object");
        }
        RLock rLock = (RLock) lock;
        if (rLock.isLocked()) {
            try {
                rLock.unlock();
            } catch (IllegalMonitorStateException e) {
                log.error("釋放分布式鎖異常", e);
            }
        }
    }
}

?3、定義ILock鎖對象

import lombok.AllArgsConstructor;
import lombok.Getter;

import java.util.Objects;

/**
 * <p>
 * RedissonLock 包裝的鎖對象 實現(xiàn)AutoCloseable接口，在java7的try(with resource)語法，不用顯示調用close方法
 * </p>

 * @since 2023-06-08 16:57
 */
@AllArgsConstructor
public class ILock implements AutoCloseable {
    /**
     * 持有的鎖對象
     */
    @Getter
    private Object lock;
    /**
     * 分布式鎖接口
     */
    @Getter
    private IDistributedLock distributedLock;

    @Override
    public void close() throws Exception {
        if(Objects.nonNull(lock)){
            distributedLock.unLock(lock);
        }
    }
}

4、注入IDistributedLock接口使用示例

// 定義接口
public interface IProductSkuSupplierMeasureService {
    /**
     * 保存SKU供應商供貨信息
     *
     * @param dto
     * @return
     *
    Boolean saveSupplierInfo(ProductSkuSupplierInfoDTO dto);

    /**
     * 編輯SKU供應商供貨信息
     *
     * @param dto
     * @return
     */
    Boolean editSupplierInfo(ProductSkuSupplierInfoDTO dto);
}    

手動釋放鎖示例?

// 實現(xiàn)類
@Service
public class ProductSkuSupplierMeasureServiceImpl 
        implements IProductSkuSupplierMeasureService {

    @Resource
    private IDistributedLock distributedLock;    
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean saveSupplierInfo(ProductSkuSupplierInfoDTO dto) {
        // 手動釋放鎖
        String sku = dto.getSku();
        ILock lock = null;
        try {
            lock = distributedLock.lock(dto.getSku(),10L, TimeUnit.SECONDS, false);
            if (Objects.isNull(lock)) {
                throw new BusinessException("Duplicate request for method still in process");
            }
            // 業(yè)務代碼
        }catch (BusinessException e) {
            throw new BusinessException(e.getMessage());
        } catch (Exception e) {
            log.error("保存異常", e);
            throw new BusinessException (e.getMessage());
        } finally {
            if (Objects.nonNull(lock)) {
                distributedLock.unLock(lock);
            }
        }
        return Boolean.TRUE;
    }

}

?使用try-with-resources 語法糖自動釋放鎖

// 實現(xiàn)類
@Service
public class ProductSkuSupplierMeasureServiceImpl 
        implements IProductSkuSupplierMeasureService {

    @Resource
    private IDistributedLock distributedLock;    
   

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean editSupplierInfo(ProductSkuSupplierInfoDTO dto) {
       
        String sku = dto.getSku();
        // try-with-resources 語法糖自動釋放鎖
        try(ILock lock = distributedLock.lock(dto.getSku(),10L, TimeUnit.SECONDS, false)) {
            if(Objects.isNull(lock)){
                throw new BusinessException ("Duplicate request for method still in process");
            }
            
            // 業(yè)務代碼
        }catch (BusinessException e) {
            throw new BusinessException (e.getMessage());
        } catch (Exception e) {
            log.error("修改異常", e);
            throw new BusinessException ("修改異常");
        }
        return Boolean.TRUE;
   }
}

5、使用AOP切面實現(xiàn)分布式鎖的綁定

? 定義DistributedLock注解

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DistributedLock {

    /**
     * 保證業(yè)務接口的key的唯一性，否則失去了分布式鎖的意義 鎖key
     * 支持使用spEl表達式
     */
    String key();

    /**
     * 保證業(yè)務接口的key的唯一性，否則失去了分布式鎖的意義 鎖key 前綴
     */
    String keyPrefix() default "";

    /**
     * 是否在等待時間內獲取鎖，如果在等待時間內無法獲取到鎖，則返回失敗
     */
    boolean tryLok() default false;

    /**
     * 獲取鎖的最大嘗試時間 ，會嘗試tryTime時間獲取鎖，在該時間內獲取成功則返回，否則拋出獲取鎖超時異常，tryLok=true時，該值必須大于0。
     *
     */
    long tryTime() default 0;

    /**
     * 加鎖的時間，超過這個時間后鎖便自動解鎖
     */
    long lockTime() default 30;

    /**
     * tryTime 和 lockTime的時間單位
     */
    TimeUnit unit() default TimeUnit.SECONDS;

    /**
     * 是否公平鎖，false:非公平鎖，true:公平鎖
     */
    boolean fair() default false;
}

?定義DistributedLockAspect Lock切面

@Aspect
@Slf4j
public class DistributedLockAspect {

    @Resource
    private IDistributedLock distributedLock;

    /**
     * SpEL表達式解析
     */
    private SpelExpressionParser spelExpressionParser = new SpelExpressionParser();

    /**
     * 用于獲取方法參數(shù)名字
     */
    private DefaultParameterNameDiscoverer nameDiscoverer = new DefaultParameterNameDiscoverer();

    @Pointcut("@annotation(com.yt.bi.common.redis.distributedlok.annotation.DistributedLock)")
    public void distributorLock() {
    }

    @Around("distributorLock()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        // 獲取DistributedLock
        DistributedLock distributedLock = this.getDistributedLock(pjp);
        // 獲取 lockKey
        String lockKey = this.getLockKey(pjp, distributedLock);
        ILock lockObj = null;
        try {
            // 加鎖，tryLok = true,并且tryTime > 0時，嘗試獲取鎖，獲取不到超時異常
            if (distributedLock.tryLok()) {
                if(distributedLock.tryTime() <= 0){
                    throw new IdempotencyException("tryTime must be greater than 0");
                }
                lockObj = this.distributedLock.tryLock(lockKey, distributedLock.tryTime(), distributedLock.lockTime(), distributedLock.unit(), distributedLock.fair());
            } else {
                lockObj = this.distributedLock.lock(lockKey, distributedLock.lockTime(), distributedLock.unit(), distributedLock.fair());
            }

            if (Objects.isNull(lockObj)) {
                throw new IdempotencyException("Duplicate request for method still in process");
            }

            return pjp.proceed();
        } catch (Exception e) {
            throw e;
        } finally {
            // 解鎖
            this.unLock(lockObj);
        }
    }

    /**
     * @param pjp
     * @return
     * @throws NoSuchMethodException
     */
    private DistributedLock getDistributedLock(ProceedingJoinPoint pjp) throws NoSuchMethodException {
        String methodName = pjp.getSignature().getName();
        Class clazz = pjp.getTarget().getClass();
        Class<?>[] par = ((MethodSignature) pjp.getSignature()).getParameterTypes();
        Method lockMethod = clazz.getMethod(methodName, par);
        DistributedLock distributedLock = lockMethod.getAnnotation(DistributedLock.class);
        return distributedLock;
    }

    /**
     * 解鎖
     *
     * @param lockObj
     */
    private void unLock(ILock lockObj) {
        if (Objects.isNull(lockObj)) {
            return;
        }

        try {
            this.distributedLock.unLock(lockObj);
        } catch (Exception e) {
            log.error("分布式鎖解鎖異常", e);
        }
    }

    /**
     * 獲取 lockKey
     *
     * @param pjp
     * @param distributedLock
     * @return
     */
    private String getLockKey(ProceedingJoinPoint pjp, DistributedLock distributedLock) {
        String lockKey = distributedLock.key();
        String keyPrefix = distributedLock.keyPrefix();
        if (StringUtils.isBlank(lockKey)) {
            throw new IdempotencyException("Lok key cannot be empty");
        }
        if (lockKey.contains("#")) {
            this.checkSpEL(lockKey);
            MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
            // 獲取方法參數(shù)值
            Object[] args = pjp.getArgs();
            lockKey = getValBySpEL(lockKey, methodSignature, args);
        }
        lockKey = StringUtils.isBlank(keyPrefix) ? lockKey : keyPrefix + lockKey;
        return lockKey;
    }

    /**
     * 解析spEL表達式
     *
     * @param spEL
     * @param methodSignature
     * @param args
     * @return
     */
    private String getValBySpEL(String spEL, MethodSignature methodSignature, Object[] args) {
        // 獲取方法形參名數(shù)組
        String[] paramNames = nameDiscoverer.getParameterNames(methodSignature.getMethod());
        if (paramNames == null || paramNames.length < 1) {
            throw new IdempotencyException("Lok key cannot be empty");
        }
        Expression expression = spelExpressionParser.parseExpression(spEL);
        // spring的表達式上下文對象
        EvaluationContext context = new StandardEvaluationContext();
        // 給上下文賦值
        for (int i = 0; i < args.length; i++) {
            context.setVariable(paramNames[i], args[i]);
        }
        Object value = expression.getValue(context);
        if (value == null) {
            throw new IdempotencyException("The parameter value cannot be null");
        }
        return value.toString();
    }

    /**
     * SpEL 表達式校驗
     *
     * @param spEL
     * @return
     */
    private void checkSpEL(String spEL) {
        try {
            ExpressionParser parser = new SpelExpressionParser();
            parser.parseExpression(spEL, new TemplateParserContext());
        } catch (Exception e) {
            log.error("spEL表達式解析異常", e);
            throw new IdempotencyException("Invalid SpEL expression [" + spEL + "]");
        }
    }
}

定義分布式鎖注解版啟動元注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({DistributedLockAspect.class})
public @interface EnableDistributedLock {
}

6、AOP切面實現(xiàn)分布式鎖的綁定使用示例

? ?啟動類添加@EnableDistributedLock啟用注解支持

@SpringBootApplication
@EnableDistributedLock
public class BiCenterGoodsApplication {

    public static void main(String[] args) {
        
        SpringApplication.run(BiCenterGoodsApplication.class, args);
        
    }
}

@DistributedLock標注需要使用分布式鎖的方法?

    @ApiOperation("編輯SKU供應商供貨信息")
    
    @PostMapping("/editSupplierInfo")
    //@DistributedLock(key = "#dto.sku + '-' + #dto.skuId", lockTime = 10L, keyPrefix = "sku-")
    @DistributedLock(key = "#dto.sku", lockTime = 10L, keyPrefix = "sku-")
    public R<Boolean> editSupplierInfo(@RequestBody @Validated ProductSkuSupplierInfoDTO dto) {
        return R.ok(productSkuSupplierMeasureService.editSupplierInfo(dto));
    }

#dto.sku是 SpEL表達式。Spring中支持的它都支持的。比如調用靜態(tài)方法，三目表達式。SpEL 可以使用方法中的任何參數(shù)。SpEL表達式參考

從原理到實踐，分析 Redis 分布式鎖的多種實現(xiàn)方案（一）_Ascend JF的博客-CSDN博客




?文章來源地址http://www.zghlxwxcb.cn/news/detail-477917.html

到了這里，關于Spring Boot 集成 Redisson 實現(xiàn)分布式鎖的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！