基于Redisson以及匿名函数实现简单的分布式锁事务工具

创建事务管理的Bean： 

如果需要比较高的自定义情况，例如锁的持有时间和等待时间，等待锁或者非阻塞锁，可以通过类似的方式实现；

import cn.hutool.extra.spring.SpringUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Objects;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

/**
 * @author akihito
 * @date 2024/9/3
 */
@Service
@Slf4j
@RequiredArgsConstructor
public class RedisLockTool {

    private static final RedissonClient CLIENT = SpringUtil.getBean(RedissonClient.class);

    /**
     * 执行无返回值事物方法
     */
    public void executeTransWithLock(String lockKey, Runnable task) {
        RLock lock = CLIENT.getLock(lockKey);
        boolean isLocked = false;
        try {
            //较长时间，而非一直等待，免除死锁
            isLocked = lock.tryLock(15L, TimeUnit.MINUTES.toSeconds(90), TimeUnit.SECONDS);

            if (!isLocked) {
                log.warn("未能获取到锁，lock key={}", lockKey);
                throw new RuntimeException("您提交的太快了，请稍后再试!");
            }

            RedisLockTool bean = SpringUtil.getBean(RedisLockTool.class);
            bean.runTask(task);
        } catch (RuntimeException e) {
            log.info(e.getMessage());
            throw e;
        } catch (Exception e) {
            log.info("executeWithLock 时发生错误：", e);
            throw new RuntimeException(e.getMessage());
        } finally {
            if (isLocked && lock.isHeldByCurrentThread()) {
                try {
                    lock.unlock();
                } catch (Exception e) {
                    log.error("释放锁时发生错误，lock key={}", lockKey, e);
                }
            }
        }
    }

    /**
     * 执行无返回值事物方法
     */
    public void executeTransWithLock(String lockKey, Long expireTimeSec, Runnable task) {
        RLock lock = CLIENT.getLock(lockKey);
        boolean isLocked = false;
        try {
            isLocked = lock.tryLock(15L, Objects.nonNull(expireTimeSec) ? expireTimeSec : 60L, TimeUnit.SECONDS);

            if (!isLocked) {
                log.warn("未能获取到锁，lock key={}", lockKey);
                throw new RuntimeException("您提交的太快了，请稍后再试!");
            }

            RedisLockTool bean = SpringUtil.getBean(RedisLockTool.class);
            bean.runTask(task);
        } catch (RuntimeException e) {
            log.info(e.getMessage());
            throw e;
        } catch (Exception e) {
            log.info("executeWithLock 时发生错误：", e);
            throw new RuntimeException(e.getMessage());
        } finally {
            if (isLocked && lock.isHeldByCurrentThread()) {
                try {
                    lock.unlock();
                } catch (Exception e) {
                    log.error("释放锁时发生错误，lock key={}", lockKey, e);
                }
            }
        }
    }

    /**
     * 执行有返回值事物方法
     */
    public <T> T supplyTransWithLock(String lockKey, Callable<T> task) {
        RLock lock = CLIENT.getLock(lockKey);
        boolean isLocked = false;
        try {
            //较长时间，而非一直等待，免除死锁
            isLocked = lock.tryLock(15L, TimeUnit.MINUTES.toSeconds(90), TimeUnit.SECONDS);

            if (!isLocked) {
                log.warn("未能获取到锁，lock key={}", lockKey);
                throw new RuntimeException("您提交的太快了，请稍后再试!");
            }

            RedisLockTool bean = SpringUtil.getBean(RedisLockTool.class);
            return bean.supplyTask(task);
        } catch (RuntimeException e) {
            log.info(e.getMessage());
            throw e;
        } catch (Exception e) {
            log.info("executeWithLock 时发生错误：", e);
            throw new RuntimeException(e.getMessage());
        } finally {
            if (isLocked && lock.isHeldByCurrentThread()) {
                try {
                    lock.unlock();
                } catch (Exception e) {
                    log.error("释放锁时发生错误，lock key={}", lockKey, e);
                }
            }
        }
    }

    /**
     * 执行有返回值事物方法
     */
    public <T> T supplyTransWithLock(String lockKey, Long expireTimeSec, Callable<T> task) {
        RLock lock = CLIENT.getLock(lockKey);
        boolean isLocked = false;
        try {
            isLocked = lock.tryLock(15L, Objects.nonNull(expireTimeSec) ? expireTimeSec : 60L, TimeUnit.SECONDS);

            if (!isLocked) {
                log.warn("未能获取到锁，lock key={}", lockKey);
                throw new RuntimeException("您提交的太快了，请稍后再试!");
            }

            RedisLockTool bean = SpringUtil.getBean(RedisLockTool.class);
            return bean.supplyTask(task);
        } catch (RuntimeException e) {
            log.info(e.getMessage());
            throw e;
        } catch (Exception e) {
            log.info("executeWithLock 时发生错误：", e);
            throw new RuntimeException(e.getMessage());
        } finally {
            if (isLocked && lock.isHeldByCurrentThread()) {
                try {
                    lock.unlock();
                } catch (Exception e) {
                    log.error("释放锁时发生错误，lock key={}", lockKey, e);
                }
            }
        }
    }


    /**
     * 执行非事物
     *
     * @param lockKey  锁key
     * @param runnable run方法
     */
    public void runWithLock(String lockKey, Runnable runnable) {
        RLock lock = CLIENT.getLock(lockKey);
        boolean isLocked = false;
        try {
            //较长时间，而非一直等待，免除死锁
            isLocked = lock.tryLock(15L, TimeUnit.MINUTES.toSeconds(90), TimeUnit.SECONDS);

            if (!isLocked) {
                log.warn("未能获取到锁，lock key={}", lockKey);
                throw new RuntimeException("您提交的太快了，请稍后再试!");
            }
            runnable.run();
        } catch (RuntimeException e) {
            log.info(e.getMessage());
            throw e;
        } catch (Exception e) {
            log.info("executeWithLock 时发生错误：", e);
            throw new RuntimeException(e.getMessage());
        } finally {
            if (isLocked && lock.isHeldByCurrentThread()) {
                try {
                    lock.unlock();
                } catch (Exception e) {
                    log.error("释放锁时发生错误，lock key={}", lockKey, e);
                }
            }
        }
    }

    /**
     * 执行非事物
     *
     * @param lockKey  锁key
     * @param runnable run方法
     */
    public void runWithLock(String lockKey, Long expireTimeSec, Runnable runnable) {
        RLock lock = CLIENT.getLock(lockKey);
        boolean isLocked = false;
        try {
            isLocked = lock.tryLock(15L, Objects.nonNull(expireTimeSec) ? expireTimeSec : 60L, TimeUnit.SECONDS);

            if (!isLocked) {
                log.warn("未能获取到锁，lock key={}", lockKey);
                throw new RuntimeException("您提交的太快了，请稍后再试!");
            }
            runnable.run();
        } catch (RuntimeException e) {
            log.info(e.getMessage());
            throw e;
        } catch (Exception e) {
            log.info("executeWithLock 时发生错误：", e);
            throw new RuntimeException(e.getMessage());
        } finally {
            if (isLocked && lock.isHeldByCurrentThread()) {
                try {
                    lock.unlock();
                } catch (Exception e) {
                    log.error("释放锁时发生错误，lock key={}", lockKey, e);
                }
            }
        }
    }

    /**
     * 执行有返回值方法
     *
     * @param lockKey  锁key
     * @param callable call方法
     * @return 返回值
     */
    public <T> T supplyWithLock(String lockKey, Callable<T> callable) {

        RLock lock = CLIENT.getLock(lockKey);
        boolean isLocked = false;
        try {
            //较长时间，而非一直等待，免除死锁
            isLocked = lock.tryLock(15L, TimeUnit.MINUTES.toSeconds(90), TimeUnit.SECONDS);

            if (!isLocked) {
                log.warn("未能获取到锁，lock key={}", lockKey);
                throw new RuntimeException("您提交的太快了，请稍后再试!");
            }
            return callable.call();
        } catch (RuntimeException e) {
            log.info(e.getMessage());
            throw e;
        } catch (Exception e) {
            log.info("runWithLock 时发生错误：", e);
            throw new RuntimeException(e.getMessage());
        } finally {
            if (isLocked && lock.isHeldByCurrentThread()) {
                try {
                    lock.unlock();
                } catch (Exception e) {
                    log.error("释放锁时发生错误，lock key={}", lockKey, e);
                }
            }
        }
    }

    /**
     * 执行有返回值方法
     *
     * @param lockKey  锁key
     * @param callable call方法
     * @return 返回值
     */
    public <T> T supplyWithLock(String lockKey, Long expireTimeSec, Callable<T> callable) {

        RLock lock = CLIENT.getLock(lockKey);
        boolean isLocked = false;
        try {
            isLocked = lock.tryLock(15L, Objects.nonNull(expireTimeSec) ? expireTimeSec : 60L, TimeUnit.SECONDS);

            if (!isLocked) {
                log.warn("未能获取到锁，lock key={}", lockKey);
                throw new RuntimeException("您提交的太快了，请稍后再试!");
            }
            return callable.call();
        } catch (RuntimeException e) {
            log.info(e.getMessage());
            throw e;
        } catch (Exception e) {
            log.info("runWithLock 时发生错误：", e);
            throw new RuntimeException(e.getMessage());
        } finally {
            if (isLocked && lock.isHeldByCurrentThread()) {
                try {
                    lock.unlock();
                } catch (Exception e) {
                    log.error("释放锁时发生错误，lock key={}", lockKey, e);
                }
            }
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void runTask(Runnable task) {
        task.run();
    }


    @Transactional(rollbackFor = Exception.class)
    public <T> T supplyTask(Callable<T> task) {
        try {
            return task.call();
        } catch (Exception e) {
            log.error("执行callable方法错误：", e);
            throw new RuntimeException(e.getMessage());
        }
    }
}

调用方式： 

    //注入bean
    private final TransactionService transactionService;    

public void doSomeThing(SomeRequest request) {
      transactionService.executeWithLock("lockKey", () -> {
        //处理逻辑
        });
    }

验证事务日志打印：验证事务提交以及分布式锁释放的先后逻辑 

    /**
     * 执行无返回值事物方法
     */
    public void executeTransWithLock(String lockKey, Runnable task) {
        RLock lock = CLIENT.getLock(lockKey);
        boolean isLocked = false;
        try {
            //较长时间，而非一直等待，免除死锁
            isLocked = lock.tryLock(15L, TimeUnit.MINUTES.toSeconds(90), TimeUnit.SECONDS);

            if (!isLocked) {
                log.warn("未能获取到锁，lock key={}", lockKey);
                throw new ServiceException("您提交的太快了，请稍后再试!");
            }

            // 使用编程式事务
            TransactionTemplate transactionTemplate = SpringUtils.getBean(TransactionTemplate.class);
            transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
            transactionTemplate.execute(status -> {

                // 注册 afterCommit 回调打印日志
                TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
                    @Override
                    public void afterCommit() {
                        log.info("测试事务已提交");
                    }

                    @Override
                    public int getOrder() {
                        return 0;
                    }
                });
                task.run();
                return null;
            });
        } catch (ServiceException e) {
            log.info(e.getMessage());
            throw e;
        } catch (Exception e) {
            log.info("executeWithLock 时发生错误：", e);
            throw new ServiceException(e.getMessage());
        } finally {
            if (isLocked && lock.isHeldByCurrentThread()) {
                try {
                    log.info("打印事物提交{}",lockKey);
                    lock.unlock();
                } catch (Exception e) {
                    log.error("释放锁时发生错误，lock key={}", lockKey, e);
                }
            }
        }
    }