分布式锁+AOP实现缓存
- 1、分布式锁+AOP实现思想
- 2、不使用AOP的情况
- 2.1 没有使用缓存时代码
- 2.2 使用Redis实现分布式锁的代码
- 2.3 使用Redisson实现分布式锁
- 2.4 测试缓存命中
- 2.5 存在问题
- 3、分布式锁+AOP实现
- 3.1 定义注解
- 3.2 定义一个切面类加上注解
- 3.3 使用注解完成缓存
1、分布式锁+AOP实现思想
随着业务中缓存及分布式锁的加入，业务代码变的复杂起来，除了需要考虑业务逻辑本身，还要考虑缓存及分布式锁的问题，增加了程序员的工作量及开发难度。而缓存的玩法套路特别类似于事务，而声明式事务就是用了aop的思想实现的。
-
以 @Transactional 注解为植入点的切点，这样才能知道@Transactional注解标注的方法需要被代理。
-
@Transactional注解的切面逻辑类似于@Around
我们的思想就是模拟事务的实现方式，缓存可以这样实现：
-
自定义缓存注解@GmallCache（类似于事务@Transactional）
-
编写切面类，使用环绕通知实现缓存的逻辑封装
2、不使用AOP的情况
2.1 没有使用缓存时代码
在这里将使用AOP思想和不适用AOP思想做一个对比
假设现在我的业务是根据skuId查询skuInfo对象，未使用分布式锁时的代码如下：
//根据skuId查询skuInfo信息和图片列表
@Override
public SkuInfo getSkuInfo(Long skuId) {
//查询数据库mysql获取数据
return getSkuInfoDB(skuId);
}
//查询数据库获取skuInfo信息
private SkuInfo getSkuInfoDB(Long skuId) {
//查询skuInfo
SkuInfo skuInfo = skuInfoMapper.selectById(skuId);
//根据skuId查询图片列表
LambdaQueryWrapper<SkuImage> wrapper = new LambdaQueryWrapper<>();
wrapper.eq(SkuImage::getSkuId, skuId);
List<SkuImage> skuImages = skuImageMapper.selectList(wrapper);
//设置当前图片列表
if(skuInfo!=null){
skuInfo.setSkuImageList(skuImages);
}
return skuInfo;
}
2.2 使用Redis实现分布式锁的代码
步骤如下：
1、定义获取sku信息的key–skuKey
2、根据skuKey从Redis中获取数据：
有数据就直接返回结果
没有数据执行下一步
3、定义skuLock
4、获取锁：如果没有获取到锁，设置睡眠时间继续自旋获取锁。
如果获取到了锁，执行下一步。
5、查询数据库获取sku数据，如果数据库中有数据，则存储数据到缓存，返回数据。
如果数据库中没有数据，存储null到缓存，返回数据(这样做的目的是防止缓存穿透)
6、释放锁
7、写一个兜底的方式(其实就是查询数据库)，目的是上面的代码发生异常的时候，也能正常返回数据。
//根据skuId查询skuInfo信息和图片列表
@Override
public SkuInfo getSkuInfo(Long skuId) {
//使用redis实现分布式锁缓存数据
return getSkuInfoRedis(skuId);
}
/**
* 获取skuInfo，从缓存中获取数据
* Redis实现分布式锁
* 实现步骤：
* 1、定义存储skuInfo的key
* 2、根据skyKey获取skuInfo的缓存数据
* 3、判断
* 有：直接返回结束
* 没有：定义锁的key,尝试加锁（失败：睡眠，重试自旋；成功：查询数据库，判断是否有值，有的话直接返回，缓存到数据库，没有，创建空值，返回数据）
*/
private SkuInfo getSkuInfoRedis(Long skuId) {
try {
//定义存储skuKey sku:1314:info
String skuKey = RedisConst.SKUKEY_PREFIX + skuId + RedisConst.SKUKEY_SUFFIX;
//尝试获取缓存中的数据
SkuInfo skuInfo = (SkuInfo) redisTemplate.opsForValue().get(skuKey);
//判断是否有值
if (skuInfo == null) {
//说明缓存中没有数据
//定义锁的key
String lockKey = RedisConst.SKUKEY_PREFIX + skuId + RedisConst.SKULOCK_SUFFIX;
//生成uuid标识
String uuid = UUID.randomUUID().toString().replaceAll("-", "");
//获取锁
Boolean flag = redisTemplate.opsForValue().setIfAbsent(lockKey, uuid, RedisConst.SKULOCK_EXPIRE_PX2, TimeUnit.SECONDS);
//判断是否获取到了锁
if (flag) {//获取到了锁
//查询数据库
SkuInfo skuInfoDB = getSkuInfoDB(skuId);
//判断数据库中是否有值
if (skuInfoDB == null) {
SkuInfo skuInfo1 = new SkuInfo();
redisTemplate.opsForValue().set(skuKey, skuInfo1, RedisConst.SKUKEY_TEMPORARY_TIMEOUT, TimeUnit.SECONDS);
return skuInfo1;
}
//数据库查询的数据不为空
//存储到缓存
redisTemplate.opsForValue().set(skuKey, skuInfoDB, RedisConst.SKUKEY_TIMEOUT, TimeUnit.SECONDS);
//释放锁-lua脚本
//定义lua脚本
String script = "if redis.call(\"get\",KEYS[1]) == ARGV[1]\n" +
"then\n" +
" return redis.call(\"del\",KEYS[1])\n" +
"else\n" +
" return 0\n" +
"end";
//创建脚本对象
DefaultRedisScript<Long> defaultRedisScript = new DefaultRedisScript<>();
//设置脚本
defaultRedisScript.setScriptText(script);
//设置返回值类型
defaultRedisScript.setResultType(Long.class);
//执行删除
redisTemplate.execute(defaultRedisScript, Arrays.asList(lockKey), uuid);
//返回数据
return skuInfoDB;
} else {
Thread.sleep(100);
return getSkuInfoRedis(skuId);
}
} else {
return skuInfo;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
//兜底，在上面从缓存中获取的过程中出现异常，这行代码也必须执行
return getSkuInfoDB(skuId);
}
2.3 使用Redisson实现分布式锁
这个步骤和2.2是一样的
//根据skuId查询skuInfo信息和图片列表
@Override
public SkuInfo getSkuInfo(Long skuId) {
//使用Redisson实现分布式锁
return getSkuInfoRedisson(skuId);
}
/**
*使用Redisson改造skuInfo信息
*/
private SkuInfo getSkuInfoRedisson(Long skuId) {
try {
//定义sku数据获取的Key
String skuKey=RedisConst.SKUKEY_PREFIX+skuId+RedisConst.SKUKEY_SUFFIX;
//尝试从缓存中获取数据
SkuInfo skuInfo = (SkuInfo) redisTemplate.opsForValue().get(skuKey);
//判断缓存中是否有数据
if(skuInfo==null){
//定义锁的key
String skuLock=RedisConst.SKUKEY_PREFIX+skuId+RedisConst.SKULOCK_SUFFIX;
//获取锁
RLock lock = redissonClient.getLock(skuLock);
//加锁
boolean res = lock.tryLock(RedisConst.SKULOCK_EXPIRE_PX1, RedisConst.SKULOCK_EXPIRE_PX2, TimeUnit.SECONDS);
//判断
if(res){
try {
//获取到了锁，查询数据库
skuInfo= getSkuInfoDB(skuId);
//判断
if(skuInfo==null){
//存储null，避免缓存穿透
skuInfo=new SkuInfo();
redisTemplate.opsForValue().set(skuKey,skuInfo,RedisConst.SKUKEY_TEMPORARY_TIMEOUT,TimeUnit.SECONDS);
return skuInfo;
}else{
//存储
redisTemplate.opsForValue().set(skuKey,skuInfo,RedisConst.SKUKEY_TIMEOUT,TimeUnit.SECONDS);
// redisTemplate.opsForValue().set(skuKey,skuInfo);
//返回
return skuInfo;
}
} finally {
//释放锁
lock.unlock();
}
}else{
//没有获取到锁
Thread.sleep(100);
return getSkuInfoRedisson(skuId);
}
}else{
//缓存中有数据
return skuInfo;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
//兜底方法,前面代码异常，这里会执行
return getSkuInfoDB(skuId);
}
2.4 测试缓存命中
这里直接在Swagger中测试，该接口格式如下：
第一次点击发送，从响应可以看出请求时成功的
观察该服务的控制台，发现第一次是查询了控制台的。
观察Redis中的数据:
然后清空该服务的控制台之后，再次发送同样的请求再观察控制台的输出
可以看到，此时已经不用查数据库了，而是直接取的Redis中的数据
2.5 存在问题
每次实现分布式锁的时候都需要写一大段重复代码，增加了工作量，代码也不优雅。
解决方案：借助AOP思想，用自定义注解封装下这段重复的代码，这样后面需要分布式锁的时候我们直接加个注解再修改个参数就行。
3、分布式锁+AOP实现
3.1 定义注解
import java.lang.annotation.*;
/**
* 元注解：简单理解就是修饰注解的注解
* @Target:用于描述注解的使用范围，简单理解就是当前注解可以用在什么地方
* @Retention:表示注解的生命周期
* SOURCE:只存在类文件中，在class字节码不存在
* CLASS：存在到字节码文件中
* RUNTIME：运行时
* @Inherited：表示被GmallCache修饰的类的子类会不会继承GmallCache
* @Documented：表明这个注解应该被javadoc工具记录，因此可悲javadoc类的工具文档化
*/
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface GmallCache {
//缓存的前缀
String prefix() default "cache:";
//缓存的后缀
String suffix() default ":info";
}
3.2 定义一个切面类加上注解
参考文档：https://docs.spring.io/spring-framework/docs/5.3.27/reference/html/core.html#aop-ataspectj-example
实现步骤和2.2中的一样，不过我们需要借助反射获取一些参数和方法返回值等。
@Component
@Aspect
public class GmallCacheAspect {
@Autowired
private RedisTemplate redisTemplate;
@Autowired
private RedissonClient redissonClient;
/**
* 使用AOP实现分布式锁和缓存
* Around:环绕通知
* value:切入的位置
* 1、定义获取数据的key
* 例如获取skuInfo key === sku:skuId
* (1)获取添加了@GmallCache注解的方法
* 可以获取注解、注解的属性、方法的参数
* (2)可以尝试获取数据
*/
@Around("@annotation(com.atguigu.gmall.common.cache.GmallCache)")
public Object cacheGmallAspect(ProceedingJoinPoint joinPoint) throws Throwable {
//创建返回对象
Object object=new Object();
//获取添加了注解的方法
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
//获取注解
GmallCache gmallCache = signature.getMethod().getAnnotation(GmallCache.class);
//获取属性前缀
String prefix = gmallCache.prefix();
//获取属性后缀
String suffix = gmallCache.suffix();
//获取方法传入的参数
Object[] args = joinPoint.getArgs();
//组合获取数据的key
String key=prefix+ Arrays.asList(args).toString()+suffix;
//从缓存中获取数据
object=cacheHit(key,signature);
try {
//判断
if(object==null){
//缓存中没有数据，需要从数据库查询
//定义锁的key
String lockKey=prefix+":lock";
//准备上锁 redis/redisson
RLock lock = redissonClient.getLock(lockKey);
//上锁
boolean flag = lock.tryLock(RedisConst.SKULOCK_EXPIRE_PX1, RedisConst.SKULOCK_EXPIRE_PX2, TimeUnit.SECONDS);
//判断是否成功
if(flag){
try {
//获取到了锁
//查询数据库，执行切入的方法体实际上就是查询数据库
object= joinPoint.proceed(args);
//判断是否从mysql查询到了数据
if(object==null){
//反射
Class aClass = signature.getReturnType();
//创建对象
object= aClass.newInstance();
//存储
redisTemplate.opsForValue().set(key,JSON.toJSONString(object),RedisConst.SKUKEY_TEMPORARY_TIMEOUT,TimeUnit.SECONDS);
return object;
}else{
//存储
redisTemplate.opsForValue().set(key,JSON.toJSONString(object),RedisConst.SKUKEY_TEMPORARY_TIMEOUT,TimeUnit.SECONDS);
return object;
}
} finally {
//释放锁
lock.unlock();
}
}else{
//睡眠
Thread.sleep(100);
//自旋
return cacheGmallAspect(joinPoint);
}
}else{
//从缓存中获取了数据
return object;
}
} catch (Throwable throwable) {
throwable.printStackTrace();
}
//兜底的方法--查询数据库，实际上执行方法体就是查询数据库
return joinPoint.proceed(args);
}
//从缓存中获取数据
private Object cacheHit(String key, MethodSignature signature) {
//获取数据--存储的时候，转换成JSON字符串,所以从Redis取出来的时候是个字符串
String strJson = (String) redisTemplate.opsForValue().get(key);
//判断
if(!StringUtils.isEmpty(strJson)){
//获取当前方法的返回值类型
Class returnType = signature.getReturnType();
//将字符串转换成指定的类型
return JSON.parseObject(strJson,returnType);
}
return null;
}
}
3.3 使用注解完成缓存
此时实现类如下：
//根据skuId查询skuInfo信息和图片列表
@Override
@GmallCache(prefix ="sku:") //key: sku:1314:info
public SkuInfo getSkuInfo(Long skuId) {
//查询数据库mysql获取数据
return getSkuInfoDB(skuId);
//使用redis实现分布式锁缓存数据
// return getSkuInfoRedis(skuId);
//使用Redisson实现分布式锁
// return getSkuInfoRedisson(skuId);
}
现在这个方法中写的是调用数据库查询的代码，不过我们在这里加了一个@GmallCache自定义注解，其中参数prefix是缓存中key的前缀，可以自定义。
这样每次在进入到这个方法的时候会执行我们定义的那个切面类，把分布式锁的步骤走一遍，可以看到，这样代码侵入性就比较低了，如果在其他地方也想使用分布式锁，那就直接加上这个注解，再给个前缀参数即可。
