@RedisLock注解实现分布式锁

已于 2022-08-15 16:49:32 修改
阅读量3.8k 收藏 15
点赞数 2
分类专栏： redis 文章标签： java spring 开发语言
于 2022-08-15 16:44:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33816292/article/details/126349155
版权

1.@RedisLock注解

package com.dstcar.common.utils.lock;

import java.lang.annotation.*;

/**
 * @author: liu wei ping
 * @date: 2022/8/15 16:39
 */
@Target({ ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedisLock {

    /** 缓存Key,支持SPEL表达式 **/
    String value() default "";

    String tips() default "重复请求";

    /** 过期时间(毫秒) **/
    long expire() default 3000;

    /** 最大过期时间(毫秒) **/
    long maxExpire() default 300000;

    /** 方法执行完释放 **/
    boolean quitRelease() default true;
}

2.使用切片类RedisDistributedLockAspect监听@RedisLock主解

package com.dstcar.common.utils.lock;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.data.redis.core.RedisTemplate;
import java.lang.reflect.Method;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * 分布式时锁，用于防重提交，注意：业务内部还是要进行重复校验
 配置
 @Bean
 public RedisDistributedLockAspect createRedisDistributedLockAspect(ObjectProvider<RedisTemplate> redisTemplate){
    RedisDistributedLockAspect aspect = new RedisDistributedLockAspect();
    aspect.setRedisTemplate(redisTemplate.getIfAvailable());
    return aspect;
 }
 * @author: liu wei ping
 * @date: 2022/8/15 16:35
 */
@Aspect
public class RedisDistributedLockAspect {
    public static final String KEY_PREFIX = "DUPLICATION_SUBMIT:";

    private RedisTemplate redisTemplate;

    public void setRedisTemplate(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 切点
     * @author: liu wei ping
     * @date: 2022/08/15 16:45
     **/
    @Pointcut("@annotation(com.dstcar.common.utils.lock.RedisLock)")
    public void getPointcut(){}

    /**
     *
     **/
    @Around("getPointcut()")
    public Object doBefore(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        Object result;
        if (null != method && method.isAnnotationPresent(RedisLock.class)){
            RedisLock redisLock = method.getAnnotation(RedisLock.class);
            String lockKey = 
            KEY_PREFIX+SpELAspectSupport.getKeyValue(point,redisLock.value());
            String requestId = UUID.randomUUID().toString();
            long expireTime = redisLock.expire();
            if (redisLock.quitRelease()){
                expireTime = redisLock.maxExpire();
            }
            boolean res = tryGetDistributedLock(lockKey,requestId,expireTime);
            if (!res){
                throw new DistributedLockException(redisLock.tips());
            }
            try {
                result = point.proceed();
            }finally {
                if (redisLock.quitRelease()){
                    releaseDistributedLock(lockKey);
                }
            }
        }else {
            result = point.proceed();
        }
        return result;
    }

    /**
     * 尝试获取分布式锁
     * @param lockKey    锁
     * @param expireTime 超期时间
     * @return 是否获取成功
     */
    public boolean tryGetDistributedLock(String lockKey, String requestId,long 
       expireTime) {
        return  redisTemplate.opsForValue().
        setIfAbsent(lockKey,requestId,expireTime,TimeUnit.MILLISECONDS);
    }

    /**
     * 释放分布式锁
     *
     * @param lockKey   锁
     * @return 是否释放成功
     */
    public boolean releaseDistributedLock(String lockKey) {
        return redisTemplate.delete(lockKey);
    }
}

 3.切面的SPEL表达式工具类SpELAspectSupport

package com.dstcar.common.utils.lock;

import com.dstcar.common.utils.json.JsonUtil;
import com.dstcar.common.utils.string.MD5Helper;
import org.aspectj.lang.JoinPoint;

/**
 * 
 * @author: liu wei ping
 * @date: 2022/8/15 16:48
 */
public class SpELAspectSupport {
    private static final ExpressionEvaluator evaluator = new ExpressionEvaluator();

    public static String getKeyValue(JoinPoint jp,String keyExpression){
        Object[] args = jp.getArgs();
        String keyValue;
        if (null != keyExpression && !"".equals(keyExpression.trim())){
            keyValue = evaluator.getKey(keyExpression,jp);
        }else if (args != null && args.length > 0 && args[0] != null){
            keyValue = MD5Helper.encrypt32(JsonUtil.toJson(args[0]));
        }else {
            throw new IllegalArgumentException("key或方法入参必须存在一个且不可为null");
        }
        return keyValue;
    }

}

4.SPEL表达式翻译类

package com.dstcar.common.utils.lock;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.aop.support.AopUtils;
import org.springframework.context.expression.AnnotatedElementKey;
import org.springframework.context.expression.CachedExpressionEvaluator;
import org.springframework.context.expression.MethodBasedEvaluationContext;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;

import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;


/**
 * 
 * @author: liu wei ping
 * @date: 2022/8/15 16:29
 */
public class ExpressionEvaluator extends CachedExpressionEvaluator {

    private final Map<AnnotatedElementKey, Method> targetMethodCache = new ConcurrentHashMap<>(64);

    private final Map<ExpressionKey, Expression> conditionCache = new ConcurrentHashMap<> 
  (64);

    /**
     * 解析key
     * @author: liu wei ping
     * @date: 2022/8/15 16:29
     **/
    public String getKey(String conditionExpression,JoinPoint jp){
        Object[] args = jp.getArgs();
        Object target = jp.getTarget();
        Class<?> targetClass = target.getClass();
        MethodSignature signature = (MethodSignature) jp.getSignature();
        Method method = signature.getMethod();
        EvaluationContext evalContext = 
        createEvaluationContext(target,targetClass,method,args);
        AnnotatedElementKey elementKey = new AnnotatedElementKey(method,targetClass);
        return getExpression(this.conditionCache, elementKey, 
         conditionExpression).getValue(evalContext,String.class);
    }

    private EvaluationContext createEvaluationContext(Object target, Class<?> 
        targetClass, Method method, Object[] args) {
        Method targetMethod = getTargetMethod(targetClass,method);
        ExpressionRootObject rootObject = new ExpressionRootObject(target,args);
        return new MethodBasedEvaluationContext(
                rootObject, targetMethod, args, getParameterNameDiscoverer());
    }


    /**
     * 获取目标方法
     **/
    private Method getTargetMethod(Class<?> targetClass,Method method){
        AnnotatedElementKey methodKey = new AnnotatedElementKey(method,targetClass);
        Method targetMethod = this.targetMethodCache.get(methodKey);
        if (targetMethod == null){
            targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
            if (targetMethod == null) {
                targetMethod = method;
            }
            this.targetMethodCache.put(methodKey, targetMethod);
        }
        return targetMethod;
    }

}


package com.dstcar.common.utils.lock;

/**
 * 
 * @author: liu wei ping
 * @date: 2022/08/15 18:13
 */
public class ExpressionRootObject {

    private final Object obj;
    private final Object[] args;


    public ExpressionRootObject(Object obj, Object[] args) {
        this.obj = obj;
        this.args = args;
    }


    public Object getObj() {
        return obj;
    }

    public Object[] getArgs() {
        return args;
    }
}

5.Json工具类JsonUtil

package com.dstcar.common.utils.json;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.core.JsonParser.Feature;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.SimpleType;
import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @author liu wei ping
 * @date 创建时间：2022年8月15日 下午6:18:33
 * @version 1.0
 */
@Slf4j
public class JsonUtil {

	public final static ObjectMapper mapper = new ObjectMapper();

	static {
		mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
		// 多余的值不解析
		mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
		// 解析器支持解析单引号
		mapper.configure(Feature.ALLOW_SINGLE_QUOTES, true);
		// 解析器支持解析结束符
		mapper.configure(Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);
		// mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
		mapper.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
		// Include.NON_EMPTY 属性为 空（“”） 或者为 NULL 都不序列化
		// Include.NON_NULL 属性为NULL 不序列化
		mapper.setSerializationInclusion(Include.NON_EMPTY);

	}

	public static String toJson(Object obj) {
		String json = null;
		if (obj == null){
			return json;
		}
		try {
			json = mapper.writeValueAsString(obj);
		} catch (JsonProcessingException e) {
			log.error("转换JSON异常：{}",e);
		}
		return json;
	}

	/**
	 * 异常要抛出来
	 * 
	 * @param jsonStr
	 * @param objClass
	 * @param <T>
	 * @return
	 * @throws IOException
	 */
	public static <T> T json2Bean(String jsonStr, Class<T> objClass) throws IOException {
		if (jsonStr == null) {
			return null;
		}
		return mapper.readValue(jsonStr, objClass);
	}

	public static <T> T toBean(String jsonStr, Class<T> objClass) {
		if (jsonStr == null) {
			return null;
		}
		T t = null;
		try {
			t = mapper.readValue(jsonStr, objClass);
		} catch (Exception e) {
			log.error("objClass转换BEAN异常详情："+jsonStr,e);
		}
		return t;
	}

	public static <T> T toBean(Reader reader, Type type) {
		T t = null;
		try {
			t = mapper.readValue(reader, mapper.constructType(type));
		} catch (Exception e) {
		}finally {
			try {
				if (reader != null){reader.close();}
			}catch (IOException e){}
		}
		return t;
	}

	public static <T> T toBean(InputStream in, Type type) {
		T t = null;
		try {
			t = mapper.readValue(in, mapper.constructType(type));

		} catch (Exception e) {
		} finally {
			try {
				if (in != null){in.close();}
			}catch (IOException e){}
		}
		return t;
	}

	private static <T> T toBean(String jsonStr, JavaType type) {
		if (jsonStr == null) {
			return null;
		}
		T t = null;
		try {
			t = mapper.readValue(jsonStr, type);
		} catch (Exception e) {
			log.error("JavaType转换BEAN异常详情："+jsonStr,e);
		}
		return t;
	}

	public static <T> T toBean(String jsonStr, Class<?> c1, Class<?> c2, Class<?> c3) {
		return toBean(jsonStr, mapper.getTypeFactory().constructParametricType(c1,
				mapper.getTypeFactory().constructParametricType(c2, c3)));
	}

	public static <T> T toBean(String jsonStr, Class<?> collectionClass, Class<?>... elementClasses) {
		return toBean(jsonStr, mapper.getTypeFactory().constructParametricType(collectionClass, elementClasses));
	}

	private static <T> T toCollection(String jsonStr, Class<?> collectionClass, Class<?>... elementClasses) {
		return toBean(jsonStr, mapper.getTypeFactory().constructParametricType(collectionClass, elementClasses));
	}

	public static <T> T toSet(String jsonStr, Class<?>... elementClasses) {
		return toCollection(jsonStr, Set.class, elementClasses);
	}

	public static <T> T toList(String jsonStr, Class<?>... elementClasses) {
		return toCollection(jsonStr, List.class, elementClasses);
	}

	public static <T> List<T> toList(File file, Class<T> elementClasses) {

		try {
			return mapper.readValue(file, mapper.getTypeFactory()
           .constructParametricType(List.class, elementClasses));
		} catch (IOException e) {}
		return null;
	}

	public static <T> T toMap(String jsonStr) {
		return toBean(jsonStr, mapper.getTypeFactory()
        .constructMapType(Map.class, 
       String.class, Object.class));
	}

	public static <T> T toMap(String jsonStr, Class<?> c1, Class<?> c2, Class<?>... c3) {
		JavaType keyType = SimpleType.constructUnsafe(c1);
		JavaType valueType = mapper.getTypeFactory().constructParametricType(c2, c3);
		return toBean(jsonStr, mapper.getTypeFactory().constructMapType(Map.class, 
        keyType, valueType));
	}

	public static <T> T convertValue(Object obj,Class<T> clazz){
		return mapper.convertValue(obj,clazz);
	}

	public static <T> List<T> convertList(Object obj,Class<T> clazz){
		return 
        mapper.convertValue(obj,mapper.getTypeFactory()
        .constructCollectionType(List.class,clazz));
	}

	public static <K,V> Map<K,V> convertMap(Object obj,Class<K> kClazz,Class<V> vClazz){
		return mapper.convertValue(obj,mapper.getTypeFactory()
        .constructMapType(Map.class,kClazz,vClazz));
	}

	public static <T> T convertValue(Object obj,Type type){
		return mapper.convertValue(obj,mapper.constructType(type));
	}

	public static byte[] writeValueAsBytes(Object obj) throws JsonProcessingException {
		return mapper.writeValueAsBytes(obj);
	}

}

 6.防止重复提交异常

package com.dstcar.common.utils.lock;

/**
 * 防止重复提交异常
 * @author: liu wei ping
 * @date: 2022/08/15 20:32
 */
public class DistributedLockException extends RuntimeException {

    public DistributedLockException(String msg) {
        super(msg);
    }
}

7.在方法上加上@RedisLock注解

   	/**
	 * 盘点记录提交
	 * @param stockcountRecordSaveDto
	 * @return
	 */
	@Transactional
	@RedisLock(value = "'StockcountRecordOpenApiController_stockcountSubmit_'
     +#stockcountRecordSaveDto.stockcountRecord.id", quitRelease = false,expire = 30000)
	public boolean stockcountSubmit(StockcountRecordSaveDto stockcountRecordSaveDto, 
        SSOUser ssoUser) {
		log.info("stockcountSubmit.stockcountRecordSaveDto:{},ssoUser: 
        {}",toJson(stockcountRecordSaveDto),toJson(ssoUser));
		StopWatch stopWatch = new StopWatch();
		stopWatch.start("盘点记录提交开始：");
		StockcountRecord stockcountRecord = 
        stockcountRecordSaveDto.getStockcountRecord();
		Assert.notNull(stockcountRecord,"非法参数");
		//修改盘点记录状态
		updateStockcountRecord(stockcountRecordSaveDto,ssoUser);
        //生成盘点记录明细数据
		createStockcountRecordDetail(stockcountRecordSaveDto,ssoUser);
		//生成车辆图片上传
		uploadCarFile(stockcountRecordSaveDto,ssoUser);
        //生成盘点差异明细
		createStockcountRecordDiff(stockcountRecordSaveDto,ssoUser);
		//生成盘点车况信息和修改车辆属性值和记录车辆车况和属性变更日志
		createCarConditionInfo(stockcountRecordSaveDto,ssoUser);
		//修改盘点记录是否有差异
		updateStockcountRecordDiff(stockcountRecord);
		stopWatch.stop();
		log.info(stopWatch.prettyPrint());
		return true;
	}

8.效果如图：

孰能生巧-LWP
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
分布式锁基于【注解】，杜绝业务重复提交。动态key
SharingOfficer的博客
12-20 682
前言 在日常开发中，为了防止高并发，在不依赖过多的中间件的情况下，最常使用的分布式锁之一是Redis锁。使用Redis锁就不得不面临一个问题，就是在业务代码中要控制Redis加锁、释放锁等等，对代码的侵入性较强。本文采用注解的方式为方法体增加分布式锁，唯一标识从方法参数中动态获取。 优点 无侵入。通过注解实现加锁和释放锁，代码中只需关注业务实现，无须关心“锁”问题，避免代码侵入。 无死锁。即使某一线程中断没能释放锁，在到达指定的时间后，程序会自动释放锁。 锁唯一独有。加锁和释放锁必须由同一线...
基于“RedisLockRegistry”利用注解实现分布式锁
JunZhao09的博客
03-06 566
1. 注解层 import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface Distr
自定义注解@RedisLock分布式锁用法及原理
孤独的灵魂的博客
01-08 515
分布式锁应用场景和解决方案。
微服务Redis分布式锁配置成注解使用（AOP）
weixin_47390965的博客
09-13 1174
在分布式系统中，因为每个进程或机器都是独立的，它们之间并不能共享同一个锁，因此需要通过一些方法来实现锁的协调。而 Redis 分布式锁就是一种基于 Redis 实现的分布式锁算法，它可以让多个进程或机器安全地共享同一个锁，从而协调它们的执行顺序和时间。它的主要作用是在多个进程或多台机器之间协调执行某个任务，以保证任务的正确性和一致性。
使用AOP+SPEL实现全局的操作日志记录（可直接使用）
最新发布
qq_42807952的博客
07-21 674
接口中的类为自定义，你需要记录什么就自己定义，我需要操作的实体类modelName，备注remark等，就先进行定义，然后可以在使用注解时候配合SPEL赋值，最终通过解析获取落库。/*** 自定义注解-实现操作日志记录*/@Component/*** 操作类*//*** 备注*//*** 内容*//*** 操作之前的原数据（SpEL）*//*** 操作之后的新数据（SpEL）*/
使用注解实现 Redis 分布式锁，看了秒懂！
m0_71777195的博客
03-29 312
一、业务背景有些业务请求，属于耗时操作，需要加锁，防止后续的并发操作，同时对数据库的数据进行操作，需要避免对之前的业务造成影响。二、分析流程使用Redis作为分布式锁，将锁的状态放到Redis统一维护，解决集群中单机JVM信息不互通的问题，规定操作顺序，保护用户的数据正确。梳理设计流程1、2、3、4、5、
用注解使用 Redis分布式锁
ReStartForTD
12-23 908
用注解使用 Redis分布式锁,分布式锁作为分布式架构体系中重要的一项技术点，在分布式的系统中有广泛的应用。分布式锁最流行的实现方式有两种： 基于Redis实现 基于ZK实现 基于Redis的实现有很多开源的项目，最出名的就是 redisson
@builder注解_使用注解形式实现 Redis 分布式锁
weixin_39882589的博客
11-26 384
一、业务背景有些业务请求，属于耗时操作，需要加锁，防止后续的并发操作，同时对数据库的数据进行操作，需要避免对之前的业务造成影响。二、分析流程使用 Redis 作为分布式锁，将锁的状态放到 Redis 统一维护，解决集群中单机 JVM 信息不互通的问题，规定操作顺序，保护用户的数据正确。梳理设计流程1、 新建注解 @interface，在注解里设定入参标志2、 增加 AOP 切点，扫描特定注解3、 ...
注解方式实现Redis锁
Mr.xie1024的博客
05-09 194
【代码】注解方式实现Redis锁。
分布式锁注解@RedisLock,接口幂等性
CongBird的博客
02-08 1103
分布式锁的运用
使用自定义注解实现Redis分布式锁
热门推荐
一恍过去
06-29 2万+
使用自定义注解实现Redis分布式锁
redislock-基于redis的分布式可重入锁
08-08
redislock - 基于redis的分布式可重入锁
记录redisson实现redis分布式事务锁
04-24
本篇文章将详细探讨如何使用Redisson实现Redis分布式事务锁，以及在Spring Boot环境中如何进行集成。 首先，Redis作为一个内存数据库，其高速读写性能使其成为实现分布式锁的理想选择。分布式锁的主要作用是在多...
Java注解如何基于Redission实现分布式锁
08-25
Redission是一个基于Redis的分布式锁实现库，本文将介绍如何使用Java注解基于Redission实现分布式锁。 一、定义注解类 首先，我们需要定义一个注解类`DistributedLock`，该注解将用于标注需要分布式锁的方法。该...
Redis高可用的分布式锁
08-03
在实际实现中，我们需要自定义一个Aspect（切面），并在其中定义一个通知方法，这个方法会在@Lock注解的方法执行前后被调用。 通知方法内部可以这样设计：在方法执行前，尝试使用Redis的SetNX命令获取锁；如果成功...
自定义注解+切面+Redis实现简单的分布式锁
g54469的博客
09-09 480
分布式锁使用场景 在单机模式下，如果一段代码限制同一时刻只能一个线程去访问，我们会使用并发锁来解决； 但是现在项目一般是微服务集群部署，并发锁的锁作用域只在当前服务器的JVM中，多个服务器的并发锁不起作用。 这就有了分布式锁的概念：保证代码在不同服务器之间只允许一个线程执行。 开干 冲冲冲！！！ 这里做个测试用例，开放一个接口，先进行token校验，再返回请求的数据（假设这个是对某条对应数据的修改操作，不让调用方重复请求之类的操作） 1、定义一个自定义注解，凡使用到这个注解的方法都先进入切面去校验token
redis锁-注解版
activety的博客
06-05 756
Redis实现分布式锁利用 SETNX 和 SETEX 基本命令主要有： SETNX(SET If Not Exists)： 当且仅当 Key 不存在时，则可以设置，否则不做任何动作。 当且仅当 key 不存在，将 key 的值设为 value ，并返回1；若给定的 key 已经存在，则 SETNX 不做任何动作，并返回0。 SETEX： 基于SETNX功能外,还可以设置超时时间，防止死锁。 项目图 代码实现 application.yml # Redis数据库索引（默认为0） spring.redis.
基于Redis的分布式锁（注解形式）
weixin_44974020的博客
11-29 1277
项目中需要使用分布式锁，且不止一处使用，所以提取为公共，具体代码实现如下： 工具类： import java.util.HashMap; import java.util.Map; /** * 当前线程工具类,存放登录数据 */ public class ThreadLocalUtil { private static ThreadLocal tlContext = new ThreadLocal(); /** * 放入缓存 * * @param k
redis通过怎样注解实现分布式锁
07-28
Redis通过自定义注解来实现分布式锁。在代码中，我们可以看到使用了一个名为`@RedisLockAnnotation`的注解\[3\]。这个注解被用于标记需要加锁的方法。在注解的定义中，可以指定锁的类型和锁的过期时间。通过在切面中定义一个`@Pointcut`，来拦截使用了`@RedisLockAnnotation`注解的方法\[2\]。在拦截到这些方法后，会执行分布式锁的逻辑。具体的实现是通过Redisson来获取分布式锁对象，并使用`tryLock`方法来尝试获取锁\[1\]。如果成功获取到锁，就可以执行业务逻辑；如果获取锁失败，则需要等待或执行其他逻辑。这样，通过注解和切面的配合，我们可以方便地在需要的地方实现分布式锁的功能。 #### 引用[.reference_title] - *1* [尚品汇之通过自定义注解实现分布式锁](https://blog.csdn.net/weixin_65627952/article/details/128188867)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [使用注解实现REDIS分布式锁](https://blog.csdn.net/LinkSLA/article/details/130419280)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值