private RLock getLock(String lockName, boolean fairLock) {
RLock lock;
if (fairLock) {
lock = redisson.getFairLock(lockName);
} else {
lock = redisson.getLock(lockName);
}
return lock;
}
public void setRedisson(RedissonClient redisson) {
this.redisson = redisson;
}
}
使用SingleDistributedLockTemplate
DistributedLockTemplate lockTemplate = …;
final String lockName = …;
lockTemplate.lock(new DistributedLockCallback() {
@Override
public Object process() {
//do some business
return null;
}
@Override
public String getLockName() {
return lockName;
}
}, false);
但是每次使用分布式锁都要写类似上面的重复代码,有没有什么方法可以只关注核心业务逻辑代码的编写,即上面的"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是不固定的。
-
当param不为空时,可以通过argNum参数来设置具体是参数列表的第几个参数,不设置则默认取第一个。
*/
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
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
架构学习资料
由于篇幅限制小编,pdf文档的详解资料太全面,细节内容实在太多啦,所以只把部分知识点截图出来粗略的介绍,每个小节点里面都有更细化的内容!
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
long
double | 分别计算int、long、double值的函数 |
| IntFunction
LongFunction
DoubleFunction | int
long
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长或者是报班学习,但对于培训机构动则几千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。[外链图片转存中…(img-OnMSazFW-1713375619595)]
[外链图片转存中…(img-u3jqB5wG-1713375619596)]
[外链图片转存中…(img-g0DgHlzS-1713375619596)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
架构学习资料
[外链图片转存中…(img-CStqJL0N-1713375619596)]
[外链图片转存中…(img-5rZehO6W-1713375619597)]
[外链图片转存中…(img-8KIpyn2C-1713375619597)]
[外链图片转存中…(img-4KmpjipV-1713375619597)]
[外链图片转存中…(img-XHiD7Yhm-1713375619598)]
由于篇幅限制小编,pdf文档的详解资料太全面,细节内容实在太多啦,所以只把部分知识点截图出来粗略的介绍,每个小节点里面都有更细化的内容!
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!