Redisson之——使用Redisson通过自定义注解实现分布式锁，使用Spring AOP简化分布式锁_redisson注解实现分布式锁

但是每次使用分布式锁都要写类似上面的重复代码，有没有什么方法可以只关注核心业务逻辑代码的编写，即上面的"do some business"。下面介绍如何使用Spring AOP来实现这一目标。

使用Spring AOP简化分布式锁

定义注解@DistributedLock

@Target({ElementType.METHOD})

@Retention(RetentionPolicy.RUNTIME)

@Documented

public @interface DistributedLock {

/**

• 锁的名称。

• 如果lockName可以确定，直接设置该属性。

*/

String lockName() default “”;

/**

• lockName后缀

*/

String lockNamePre() default “”;

/**

• lockName后缀

*/

String lockNamePost() default “lock”;

/**

• 获得锁名时拼接前后缀用到的分隔符

• @return

*/

String separator() default “.”;

/**

• 获取注解的方法参数列表的某个参数对象的某个属性值来作为lockName。因为有时候lockName是不固定的。
  1

• 当param不为空时，可以通过argNum参数来设置具体是参数列表的第几个参数，不设置则默认取第一个。
  1

*/

String param() default “”;

/**

• 将方法第argNum个参数作为锁

*/

int argNum() default 0;

/**

• 是否使用公平锁。

• 公平锁即先来先得。

*/

boolean fairLock() default false;

/**

• 是否使用尝试锁。

*/

boolean tryLock() default false;

/**

• 最长等待时间。

• 该字段只有当tryLock()返回true才有效。

*/

long waitTime() default 30L;

/**

• 锁超时时间。

• 超时时间过后，锁自动释放。

• 建议：

• 尽量缩简需要加锁的逻辑。

*/

long leaseTime() default 5L;

/**

• 时间单位。默认为秒。

*/

TimeUnit timeUnit() default TimeUnit.SECONDS;

}

定义切面代码

@Aspect

@Component

public class DistributedLockAspect {

@Autowired

private DistributedLockTemplate lockTemplate;

@Pointcut(“@annotation(cn.sprinkle.study.distributedlock.common.annotation.DistributedLock)”)

public void DistributedLockAspect() {}

@Around(value = “DistributedLockAspect()”)

public Object doAround(ProceedingJoinPoint pjp) throws Throwable {

//切点所在的类

Class targetClass = pjp.getTarget().getClass();

//使用了注解的方法

String methodName = pjp.getSignature().getName();

Class[] parameterTypes = ((MethodSignature)pjp.getSignature()).getMethod().getParameterTypes();

Method method = targetClass.getMethod(methodName, parameterTypes);

Object[] arguments = pjp.getArgs();

final String lockName = getLockName(method, arguments);

return lock(pjp, method, lockName);

}

@AfterThrowing(value = “DistributedLockAspect()”, throwing=“ex”)

public void afterThrowing(Throwable ex) {

throw new RuntimeException(ex);

}

public String getLockName(Method method, Object[] args) {

Objects.requireNonNull(method);

DistributedLock annotation = method.getAnnotation(DistributedLock.class);

String lockName = annotation.lockName(),

param = annotation.param();

if (isEmpty(lockName)) {

if (args.length > 0) {

if (isNotEmpty(param)) {

Object arg;

if (annotation.argNum() > 0) {

arg = args[annotation.argNum() - 1];

} else {

arg = args[0];

}

lockName = String.valueOf(getParam(arg, param));

} else if (annotation.argNum() > 0) {

lockName = args[annotation.argNum() - 1].toString();

}

}

}

if (isNotEmpty(lockName)) {

String preLockName = annotation.lockNamePre(),

postLockName = annotation.lockNamePost(),

separator = annotation.separator();

StringBuilder lName = new StringBuilder();

if (isNotEmpty(preLockName)) {

lName.append(preLockName).append(separator);

}

lName.append(lockName);

if (isNotEmpty(postLockName)) {

lName.append(separator).append(postLockName);

}

lockName = lName.toString();

return lockName;

}

throw new IllegalArgumentException(“Can’t get or generate lockName accurately!”);

}

/**

• 从方法参数获取数据

• @param param

• @param arg 方法的参数数组

• @return

*/

public Object getParam(Object arg, String param) {

if (isNotEmpty(param) && arg != null) {

try {

Object result = PropertyUtils.getProperty(arg, param);

return result;

} catch (NoSuchMethodException e) {

throw new IllegalArgumentException(arg + “没有属性” + param + “或未实现get方法。”, e);

} catch (Exception e) {

throw new RuntimeException(“”, e);

}

}

return null;

}

public Object lock(ProceedingJoinPoint pjp, Method method, final String lockName) {

DistributedLock annotation = method.getAnnotation(DistributedLock.class);

boolean fairLock = annotation.fairLock();

boolean tryLock = annotation.tryLock();

if (tryLock) {

return tryLock(pjp, annotation, lockName, fairLock);

} else {

return lock(pjp,lockName, fairLock);

}

}

public Object lock(ProceedingJoinPoint pjp, final String lockName, boolean fairLock) {

return lockTemplate.lock(new DistributedLockCallback() {

@Override

public Object process() {

return proceed(pjp);

}

@Override

public String getLockName() {

return lockName;

}

}, fairLock);

}

public Object tryLock(ProceedingJoinPoint pjp, DistributedLock annotation, final String lockName, boolean fairLock) {

long waitTime = annotation.waitTime(),

leaseTime = annotation.leaseTime();

TimeUnit timeUnit = annotation.timeUnit();

return lockTemplate.tryLock(new DistributedLockCallback() {

@Override

public Object process() {

return proceed(pjp);

}

@Override

public String getLockName() {

return lockName;

}

}, waitTime, leaseTime, timeUnit, fairLock);

}

public Object proceed(ProceedingJoinPoint pjp) {

try {

return pjp.proceed();

} catch (Throwable throwable) {

throw new RuntimeException(throwable);

}

}

private boolean isEmpty(Object str) {

return str == null || “”.equals(str);

}

private boolean isNotEmpty(Object str) {

return !isEmpty(str);

}

}

使用注解@DistributedLock实现分布式锁

有了上面两段代码，以后需要用到分布式锁，只需在核心业务逻辑方法添加注解@DistributedLock，并设置LockName、fairLock等即可。下面的DistributionService演示了多种使用情景。

@Service

public class DistributionService {

@Autowired

private RedissonClient redissonClient;

@DistributedLock(param = “id”, lockNamePost = “.lock”)

public Integer aspect(Person person) {

RMap<String, Integer> map = redissonClient.getMap(“distributionTest”);

Integer count = map.get(“count”);

if (count > 0) {

count = count - 1;

map.put(“count”, count);

}

return count;

}

@DistributedLock(argNum = 1, lockNamePost = “.lock”)

public Integer aspect(String i) {

RMap<String, Integer> map = redissonClient.getMap(“distributionTest”);

Integer count = map.get(“count”);

if (count > 0) {

count = count - 1;

map.put(“count”, count);

}

return count;

}

@DistributedLock(lockName = “lock”, lockNamePost = “.lock”)

public int aspect(Action action) {

return action.action();

}

}

测试

定义一个Worker类：

public class Worker implements Runnable {

private final CountDownLatch startSignal;

private final CountDownLatch doneSignal;

private final DistributionService service;

private RedissonClient redissonClient;

public Worker(CountDownLatch startSignal, CountDownLatch doneSignal, DistributionService service, RedissonClient redissonClient) {

this.startSignal = startSignal;

this.doneSignal = doneSignal;

this.service = service;

this.redissonClient = redissonClient;

}

@Override

public void run() {

try {

startSignal.await();

System.out.println(Thread.currentThread().getName() + " start");

// Integer count = service.aspect(new Person(1, “张三”));

// Integer count = service.aspect(“1”);

Integer count = service.aspect(() -> {

RMap<String, Integer> map = redissonClient.getMap(“distributionTest”);

Integer count1 = map.get(“count”);

if (count1 > 0) {

count1 = count1 - 1;

map.put(“count”, count1);

}

return count1;

});

System.out.println(Thread.currentThread().getName() + ": count = " + count);

doneSignal.countDown();

} catch (InterruptedException ex) {

System.out.println(ex);

}

}

}

定义Controller类：

@RestController

@RequestMapping(“/distributedLockTest”)

public class DistributedLockTestController {

private int count = 10;

@Autowired

private RedissonClient redissonClient;

@Autowired

private DistributionService service;

@RequestMapping(method = RequestMethod.GET)

public String distributedLockTest() throws Exception {

RMap<String, Integer> map = redissonClient.getMap(“distributionTest”);

map.put(“count”, 8);

CountDownLatch startSignal = new CountDownLatch(1);

CountDownLatch doneSignal = new CountDownLatch(count);

for (int i = 0; i < count; ++i) { // create and start threads

new Thread(new Worker(startSignal, doneSignal, service)).start();

}

startSignal.countDown(); // let all threads proceed

doneSignal.await();

System.out.println(“All processors done. Shutdown connection”);

return “finish”;

}

}

Redisson基本配置：

singleServerConfig:

idleConnectionTimeout: 10000

pingTimeout: 1000

connectTimeout: 10000

timeout: 3000

retryAttempts: 3

retryInterval: 1500

reconnectionTimeout: 3000

failedAttempts: 3

password:

subscriptionsPerConnection: 5

clientName: null

address: “redis://127.0.0.1:6379”

subscriptionConnectionMinimumIdleSize: 1

subscriptionConnectionPoolSize: 50

connectionMinimumIdleSize: 10

connectionPoolSize: 64

database: 0

dnsMonitoring: false

dnsMonitoringInterval: 5000

threads: 0

nettyThreads: 0

codec: !<org.redisson.codec.JsonJacksonCodec> {}

useLinuxNativeEpoll: false

工程中需要注入的对象：

@Value(“classpath:/redisson-conf.yml”)

Resource configFile;

@Bean(destroyMethod = “shutdown”)

RedissonClient redisson()

throws IOException {

Config config = Config.fromYAML(configFile.getInputStream());

return Redisson.create(config);

}

@Bean

DistributedLockTemplate distributedLockTemplate(RedissonClient redissonClient) {

return new SingleDistributedLockTemplate(redissonClient);

}

需要引入的依赖：

org.springframework.boot

spring-boot-starter-aop

org.springframework.boot

spring-boot-starter-web

org.redisson

redisson

3.5.3

commons-beanutils

commons-beanutils

1.8.3

最后启动工程，然后访问localhost:8080/distributedLockTest，可以看到如下结果：

观察结果，可以看出，10个线程中只有8个线程能执行count减1操作，而且多个线程是依次执行的。也就是说分布式锁起作用了。

使用lambda

该注解还可以配合lambda使用。在介绍之前，先科普一下使用spring注解时需要注意的地方，有两点。

第一，在使用spring提供的方法注解时，比较常用的是@Transactional注解。若是Service层不带注解的方法A调用同一个Service类带@Transactional注解的方法B，那么方法B的事务注解将不起作用。比如：

…

public void methodA() {

methodB();

}

@Transactional

public void methodB() {

// 操作表A

// 操作表B

}

…

上面的代码中，假设有一次调用方法A，方法A又调用方法B，但是此次调用在操作表B时出错了。我们的意愿是这样的：之前对表A的操作回滚。但实际上却不会回滚，因为此时的@Transactional注解并不会生效。原因是调用方法B是同一个Service的方法A，而若是在其他类中调用方法B注解才生效。这也就不难解释为什么注解加在private方法上是不起作用的了。因为private方法只能在同一个方法中调用。

上面所说的调用同一个类的带注解的方法，该注解将不生效，感兴趣的可以自己找找原因，这里就不细说了。

第二，注解（包括spring提供的、自定义的）加在普通类的方法上，spring是扫描不到的。普通类指类签名上没有诸如@Service等Spring提供的注解（因为此分布式锁集成使用的是spring aop，所以介绍的都是与spring相关的）。比如，如果把上面贴出的DistributionService中的各个方法放到Worker中，那么这些注解将不起作用，因为Worker类签名并没有加任何注解，所以spring在扫描的时候直接跳过该类，因此定义在Worker中的带@DistributedLock注解的方法（如果有的话）也就无法被扫描到。

在上面贴出的代码中，Worker中需要使用分布式锁的业务逻辑比较简单，所以都写到DistributionService中，但在实际开发中，我们通常有把业务逻辑直接写在Worker中的需求，毕竟是与Worker相关的，放到哪一个Service都感觉很别扭。所以，我们可以定义一个分布式锁管理器，如DistributedLockManager，然后在初始化Worker时引入即可。接下来改造Worker和定义DistributedLockManager：

Worker1:

public class Worker1 implements Runnable {

private final CountDownLatch startSignal;

private final CountDownLatch doneSignal;

private final DistributedLockManager distributedLockManager;

private RedissonClient redissonClient;

public Worker1(CountDownLatch startSignal, CountDownLatch doneSignal, DistributedLockManager distributedLockManager, RedissonClient redissonClient) {

this.startSignal = startSignal;

this.doneSignal = doneSignal;

this.distributedLockManager = distributedLockManager;

this.redissonClient = redissonClient;

}

@Override

public void run() {

try {

System.out.println(Thread.currentThread().getName() + " start");

startSignal.await();

Integer count = aspect(“lock”);

System.out.println(Thread.currentThread().getName() + ": count = " + count);

doneSignal.countDown();

} catch (Exception e) {

e.printStackTrace();

}

}

public int aspect(String lockName) {

return distributedLockManager.aspect(lockName, this);

}

public int aspectBusiness(String lockName) {

RMap<String, Integer> map = redissonClient.getMap(“distributionTest”);

Integer count = map.get(“count”);

if (count > 0) {

count = count - 1;

map.put(“count”, count);

}

return count;

}

}

DistributedLockManager:

@Component

public class DistributedLockManager {

@DistributedLock(argNum = 1, lockNamePost = “.lock”)

public Integer aspect(String lockName, Worker1 worker1) {

return worker1.aspectBusiness(lockName);

}

}

这样做，虽然可以将业务从Service层抽离出来，放到分布式锁管理器DistributedLockManager统一管理，但每次都需要将Worker一起传过去，同样感觉很别扭。那么有没有更好的办法呢？有，使用lambda。（上面铺垫了那么多，终于进入正题了！o(╥﹏╥)o）

lambda是java 8的新特性之一，若未了解过的建议先去恶补一番。因为java 8支持lambda，所以也新加了很多函数式接口，这里简单列几个：

| 函数式接口 | 参数类型 | 返回类型 | 描述 |

| — | — | — | — |

| Supplier | 无 | T | 提供一个T类型的值 |

| Consumer | T | void | 处理一个T类型的值 |

| BiConsumer<T, U> | T, U | void | 处理T类型和U类型的值 |

| Predicate | T | boolean | 一个 计算Boolean值的函数 |

| Function<T, R> | T | R | 一个参数类型为T的函数 |

| ToIntFunction

ToLongFunction

ToDoubleFunction | T | int

long

double | 分别计算int、long、double值的函数 |

| IntFunction

LongFunction

DoubleFunction | int

long

double | R | 参数分别为int、long、double类型的函数 |

| BiFunction<T, U, R> | T, U | R | 一个参数类型为T和U的函数 |

| UnaryOperator | T | T | 对类型T进行的一元操作 |

| BinaryOperator | T, T | T | 对类型T进行的二元操作 |

观察Worker1中方法aspect(Person)的逻辑，最后需要返回一个int值，所以我们可以使用Supplier<T>来作为参数的类型，在分布式锁管理器中添加一个方法，如下：

@DistributedLock(lockName = “lock”, lockNamePost = “.lock”)

public int aspect(Supplier supplier) {

return supplier.get();

}

然后，在Worker1中也定义一个方法：

private int aspect() {

RMap<String, Integer> map = redissonClient.getMap(“distributionTest”);

Integer count1 = map.get(“count”);

if (count1 > 0) {

count1 = count1 - 1;

map.put(“count”, count1);

}

return count1;

}

最后在Worker1的run方法中使用，把Integer count = aspect("lock");替换成如下：

Integer count = distributedLockManager.aspect(() -> {

return aspect();

});

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

这份面试题几乎包含了他在一年内遇到的所有面试题以及答案，甚至包括面试中的细节对话以及语录，可谓是细节到极致，甚至简历优化和怎么投简历更容易得到面试机会也包括在内！也包括教你怎么去获得一些大厂，比如阿里，腾讯的内推名额！

某位名人说过成功是靠99%的汗水和1%的机遇得到的，而你想获得那1%的机遇你首先就得付出99%的汗水！你只有朝着你的目标一步一步坚持不懈的走下去你才能有机会获得成功！

成功只会留给那些有准备的人！

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

最后在Worker1的run方法中使用，把Integer count = aspect("lock");替换成如下：

Integer count = distributedLockManager.aspect(() -> {

return aspect();

});

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-BbCSGh9v-1713375654133)]

[外链图片转存中…(img-PoTuYUbU-1713375654134)]

[外链图片转存中…(img-X1B5jNph-1713375654134)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

总结

这份面试题几乎包含了他在一年内遇到的所有面试题以及答案，甚至包括面试中的细节对话以及语录，可谓是细节到极致，甚至简历优化和怎么投简历更容易得到面试机会也包括在内！也包括教你怎么去获得一些大厂，比如阿里，腾讯的内推名额！

某位名人说过成功是靠99%的汗水和1%的机遇得到的，而你想获得那1%的机遇你首先就得付出99%的汗水！你只有朝着你的目标一步一步坚持不懈的走下去你才能有机会获得成功！

成功只会留给那些有准备的人！

[外链图片转存中…(img-RKsXPwzv-1713375654134)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！