今天分享一个很好玩的小玩意 , 搞一个分布式锁小注解, 来替换日常的一些冗余工作 虽然技术性不强, 算是给了我很大的启迪 , 以后可以搞更多的小注解 , 提升开发效率!!!
最近使用reids分布式锁比较频繁,所以搞了个注解, 主要在加锁方法上, 加上注解, 就能锁住方法 , 确实挺方便的 , 老板再也不用担心我忘记释放锁了;
提醒 : 首先搞这个注解之前, 大家务必先搞清楚redis分布式锁的使用过程,得在这个基础上才更容易懂;
其实将 redis 分布式锁, 做成注解原理不难 , 核心点就是使用springAOP面向切面编程, 获取注解,读取参数, 通过反射机制获取方法是否加了注解, 判断是否满足加锁条件 .
另外 , 最好使用redison包,提供现成的方法 , 如果是自己写的分布式锁, 则需要注意一些地方 : 锁的可重入 , 排他性 , 续约问题 , 超时释放锁等问题 , 今天我用的是自己写的一个简单的分布式锁 , 废话不多说 , 开始撸代码;
1.首先是我自己写的锁
/**
* @author xwd
*/
public class SimpleRedisLock implements RedisLock {
private RedisTemplate redisTemplate;
/**
* 设定好锁对应的 key
*/
private String key;
/**
* 锁对应的值，无意义，写为1
*/
private static final String value = "1";
/**
* 为了解决释放锁的问题, 在释放锁的时候,定义一个id, 创建的锁只能由该线程去释放
* 另外,定义了一个lockObj对象,里面存了锁的次数, 防止重复锁的出现,因为同一个线程可能可以重复锁
* 改进后 , 不用这个id了, 直接取线程的名字
*/
private static String lockObjId = "";
public SimpleRedisLock(RedisTemplate redisTemplate, String key) {
this.redisTemplate = redisTemplate;
this.key = key;
}
/**
* 加锁
* @param keyName 设定好锁对应的 key
* @param releaseTime 锁的释放时间 , 单位秒
*/
@Override
public void lock(String keyName, long releaseTime) {
/**
* 为了解决释放锁的问题, 在释放锁的时候,定义一个id, 创建的锁只能由该线程去释放
* 另外,定义了一个lockObj对象,里面存了锁的次数, 防止重复锁的出现,因为同一个线程可能可以重复锁
*/
LockObj lockObj = new LockObj();
lockObj.setCount((lockObj.getCount() + 1));
lockObj.setId(Thread.currentThread().getName());
// 尝试获取锁
boolean boo = true;
while (boo) {
boo = !redisTemplate.opsForValue().setIfAbsent(keyName, JSONUtil.toJsonStr(lockObj), releaseTime, TimeUnit.SECONDS);
System.out.println(Thread.currentThread().getName() + "尝试获取锁");
}
System.out.println(Thread.currentThread().getName() + "获取到锁");
}
/**
* 释放锁
*/
@Override
public void unlock() {
String redisJson = (String) redisTemplate.opsForValue().get(key);
LockObj lockObjRedis = JSONUtil.toBean(redisJson, LockObj.class);
lockObjRedis.setCount((lockObjRedis.getCount() - 1));
//让锁对象的次数和id对应的上才可以解锁
if (lockObjRedis.getCount() <= 0 && lockObjRedis.getId().equals(Thread.currentThread().getName())) {
// 删除key即可释放锁
System.out.println(Thread.currentThread().getName() + "释放了锁");
redisTemplate.delete(key);
}
}
}
别忘了 , 把锁注入到IOC
/**
* 配置分布式锁
*/
@Bean
public SimpleRedisLock redisTemplate(RedisTemplate<String, Object> redisTemplate) {
return new SimpleRedisLock(redisTemplate, "order-server");
}
2.写一个注解
package com.xwd.order.aspect;
import java.lang.annotation.*;
/**
* 分布式锁注解
* @author xwd
* @version 1.0
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface MyRedisLock {
//传入一个key,控制锁的范围,以及排他性
String key() default "";
}
3. 然后是最核心的 , 编写 AOP切面 , 用它来拦截请求, 获取注解, 加锁
package com.xwd.order.aspect;
import com.xwd.lock.SimpleRedisLock;
import com.xwd.order.controller.OrderController;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
import java.util.Map;
/**
* 拦截切面
* @author xwd
* @version 1.0
*/
@Aspect
@Component
public class LogAspect {
@Pointcut("execution(public * com.xwd.order.controller.OrderController.*(..))")
public void webLog() {
}
// 引入redis锁对象
@Autowired
private SimpleRedisLock simpleRedisLock;
@Before("webLog()")
public void deBefore(JoinPoint joinPoint) throws Exception {
//反射获取注解 , 加锁
Class<OrderController> aClass = OrderController.class;
Method showMethod = aClass.getMethod("show", Map.class);
MyRedisLock myRedisLock = showMethod.getDeclaredAnnotation(MyRedisLock.class);
String key = myRedisLock.key();
//拿到注解中的key
Object[] args = joinPoint.getArgs();
//拿到这个key就可以加锁了...
Map<String, Object> paramMap = (Map<String, Object>) args[0];
simpleRedisLock.lock((String) paramMap.get(key), 5);
}
}
- 请求接口controller
package com.xwd.order.controller;
import cn.hutool.core.thread.ThreadUtil;
import com.xwd.lock.SimpleRedisLock;
import com.xwd.order.aspect.MyRedisLock;
import com.xwd.order.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.security.Key;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
* @author xwd
* @version 1.0
*/
@RestController
@RequestMapping("/order")
public class OrderController {
@Autowired
private OrderService orderService;
@Autowired
private SimpleRedisLock simpleRedisLock;
@PostMapping("/show")
@ResponseBody
@MyRedisLock(key = "key") //加上这个注解 , 传递一个锁的key
public ResponseEntity<String> show(@RequestBody Map<String,Object> map) {
String token;
// 开始执行业务代码 , 执行了3秒
ThreadUtil.sleep(3, TimeUnit.SECONDS);
token = orderService.show();
return ResponseEntity.ok(token);
}
}
5. 差点忘了, 还有我项目中的依赖 , 可能用处不大 , 也给各位补上 ;
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>2.1.6.RELEASE</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.6.3</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--nacos 客户端启动器-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
<version>2.1.0.RELEASE</version>
</dependency>
<dependency>
<groupId>com.xwd</groupId>
<artifactId>feign-client-server</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.4</version>
</dependency>
</dependencies>
6. 然后就是发送请求测试.
篇幅有限 , 项目没有完整的展示出来 , 可能大家赋值代码后项目跑步起来 , 还是有点模糊, 在这里在复述一遍 整个流程 :
核心点: 编写注解实现分布式加锁的功能 , 最核心画龙点睛之笔就是在 , spring的AOP , 面向切面编程可以在业务员执行方法之前 , 自动增强功能 , 也就是加锁 , 使用 SimpleRedisLock.lock 起来 , 再执行业务代码 , 最后别忘了释放锁 ;
以上便是 , 分布式锁做成注解的分享 , 虽然技术性不怎么强 , 可是却很灵活, 通过这次, 后续的开发我会尝试写更多的注解, 来替代很多的冗余工作, 更加便捷开发 ;
298
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
