如何通过redis搭建一个分布式锁

最新推荐文章于 2024-05-03 07:48:42 发布
最新推荐文章于 2024-05-03 07:48:42 发布
阅读量418 收藏
点赞数
分类专栏： 分布式的一些小记 文章标签： dubbo redis 分布式锁 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guocy_lm/article/details/86138402
版权

       前言说明：本文旨在让希望能快速使用redis分布式锁的java后台工程师能快速了解分布式锁的基本原理和代码实现。由于网上讲解redis的锁的文章很多，所以这里不详细说明了，旨在讲一些简单的，让大家能快速使用的方式。

      要求：本文默认读者是对于spring、redis、dubbo有一定了解的，相关的知识请参考其他文章。

       由于业务的发展，公司的一些事务流程越来越复杂，又由于是分布式的，所以不得不采用分布式锁来解决一些问题。在网上查了一些流程，汇总出了自己的一个解决方案。这里作为笔记记录一下。

      分布式锁的实现方式很多，比如用数据库的乐观锁，redis的分布式锁，zookeeper的分布式锁。我们主要采用了redis的分布式锁。  

     实现代码前要确定分布式锁的需求。（摘自另一篇文章：http://www.cnblogs.com/linjiqin/p/8003838.html）

     1. 互斥性。在任意时刻，只有一个客户端能持有锁。

     2. 不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。

     3. 具有容错性。只要大部分的Redis节点正常运行，客户端就可以加锁和解锁。

     4. 解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。

     5. 分布式锁还需要能尽量不改动其他代码的前提下让其他开发者方便使用。这里通过注解方式实现，只需要在原有的服务中增加注解就可以方便使用分布式锁，而不需要改动原先的代码。

 

    redis分布式锁主要是通过redis的NX特性来做的。该特性就是判断一个key是否存在，不存在则set操作。通过这个特性我们可以将一个事物进来以后通过判断key是否存在来进行同步锁设置。不存在则加同步锁，同时进入事务处理，处理完成以后解锁。如果key已经存在，则根据自己的逻辑需要选择循环等待或者直接返回提示信息。  

     流程图如下：

 

分布式锁的流程图
分布式锁流程图

 

   了解了上面的内容，就可以开始构建分布式锁了。下面直接上代码。

   首先是分布式锁的工具类。

import javax.annotation.Resource;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import com.alibaba.druid.util.StringUtils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisCommands;
import java.util.Collections;


/**
 * redis分布式同步锁类
 * 
 * @author kane
 *
 */
public class RedisDistributedLock {
	@Resource
	private RedisTemplate<String, Object> redisTemplate;

	public static final String UNLOCK_LUA;

	// 默认超时时间1分钟
	private static final long EXPIRE = 60;

	static {
		StringBuilder sb = new StringBuilder();
		sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
		sb.append("then ");
		sb.append("    return redis.call(\"del\",KEYS[1]) ");
		sb.append("else ");
		sb.append("    return 0 ");
		sb.append("end ");
		UNLOCK_LUA = sb.toString();
	}

	/**
	 * 设置锁
	 * 
	 * @param key
	 *            key值
	 * @param expire
	 *            超时时间，单位秒，小于等于0则使用默认设置:1分钟超时时间
	 * @return
	 */
	public boolean setLock(String key, long expire,String requestId) {
		
		try {
			RedisCallback<String> callback = (connection) -> {
				JedisCommands commands = (JedisCommands) connection.getNativeConnection();
				 NX是不存在时才set， XX是存在时才set， EX是秒，PX是毫秒
				return commands.set(key, requestId, "NX", "EX", (expire<=0)?EXPIRE:expire);
			};
			String result = redisTemplate.execute(callback);

			System.out.println("result="+result);
			
			return !StringUtils.isEmpty(result);
		} catch (Exception e) {
			LoggerUtil.DebugLogger.error("set redis occured an exception", e);
		}
		return false;
	}

	public String get(String key) {
		try {
			RedisCallback<String> callback = (connection) -> {
				JedisCommands commands = (JedisCommands) connection.getNativeConnection();
				return commands.get(key);
			};
			String result = redisTemplate.execute(callback);
			return result;
		} catch (Exception e) {
			LoggerUtil.DebugLogger.error("get redis occured an exception", e);
		}
		return "";
	}

	//释放锁
	public boolean releaseLock(String key, String requestId) {
		// 释放锁的时候，有可能因为持锁之后方法执行时间大于锁的有效期，此时有可能已经被另外一个线程持有锁，所以不能直接删除
		try {

			// 使用lua脚本删除redis中匹配value的key，可以避免由于方法执行时间过长而redis锁自动过期失效的时候误删其他线程的锁
			// spring自带的执行脚本方法中，集群模式直接抛出不支持执行脚本的异常，所以只能拿到原redis的connection来执行脚本
			RedisCallback<Long> callback = (connection) -> {
				Object nativeConnection = connection.getNativeConnection();
				// 集群模式和单机模式虽然执行脚本的方法一样，但是没有共同的接口，所以只能分开执行
				// 集群模式
				if (nativeConnection instanceof JedisCluster) {
					System.out.println("集群解锁");
					return (Long) ((JedisCluster) nativeConnection).eval(UNLOCK_LUA, Collections.singletonList(key), Collections.singletonList(requestId));
				}

				// 单机模式
				else if (nativeConnection instanceof Jedis) {
					System.out.println("单机解锁");
					return (Long) ((Jedis) nativeConnection).eval(UNLOCK_LUA, Collections.singletonList(key), Collections.singletonList(requestId));
				}
				return 0L;
			};
			Long result = redisTemplate.execute(callback);

			return result != null && result > 0;
		} catch (Exception e) {
			LoggerUtil.DebugLogger.error("release lock occured an exception", e);
		} finally {
			// 清除掉ThreadLocal中的数据，避免内存溢出
//			lockFlag.remove();
		}
		return false;
	}
}

代码说明：

     1. 为了保证redis的操作原子性，采用lua脚本执行删除redis操作。UNLOCK_LUA是lua脚本的内容。

     2. setLock是加锁操作。releaseLock是释放锁操作。其中requestId是请求ID，通过UUID生成。为了保证谁提交的请求就由谁释放。

   

  有了上面的工具类，下面开始讲加锁和解锁操作放到一个dubbo的provider中，方便其他的服务使用。

@Service("redisAPIImpl")
public class RedisAPIImpl implements RedisAPI{

	@Autowired
	RedisDistributedLock redisDistributedLock;
	
	/**
	 * redis分布式锁——加锁操作
	 * @param key			key值
	 * @param expire		超时时间，单位秒，小于等于0则使用默认设置:1分钟超时时间
	 * @param requestId		请求ID，解锁时的依据，防止其他client解锁
	 * @return
	 */
	@Override
	public boolean distributedLock(String key, long expire, String requestId) {
		return redisDistributedLock.setLock(key, expire, requestId);
	}

	/**
	 * redis分布式锁——解锁操作
	 * @param key			key值
	 * @param requestId		请求ID，加锁时用的请求ID
	 * @return
	 */
	@Override
	public boolean releaseDistributedLock(String key, String requestId) {
		return redisDistributedLock.releaseLock(key, requestId);
	}

	/**
	 * redis分布式锁——获取锁值（既：加锁的请求ID的值）操作。
	 * @param key
	 * @return
	 */
	@Override
	public String getLock(String key) {
		return redisDistributedLock.get(key);
	}

代码说明：讲刚才的工具类RedisDistributedLock注入到provider中。 然后编写provider的接口实现。并通过dubbo发布。

  然后在dubbo的xml中暴露接口

<!-- redis相关的接口 -->
	<dubbo:service interface="包名.RedisAPI"
		ref="redisAPIImpl" />

接口写完以后，剩下的就是具体的事务服务使用了。为了保证代码不改动的前提下可以使用，我们这里采用spring的aop来实现。保证需要使用分布式锁的接口只需要添加注解就可以实现。

 

由于公司的项目是老项目了，spring的版本，dubbo的版本都不能改变。所以aop没有采用注解的形式，而是使用的spring提供的MethodInterceptor。

public class RedisLockAround implements MethodBeforeAdvice, AfterReturningAdvice, MethodInterceptor {
    @Autowired
	RedisAPI redisAPI;

@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
    
    Method method = invocation.getMethod();

        //这里的RedisLockAnnoation是注解，通过该注解可以设置分布式锁的一些常用参数。代码后面有
		RedisLockAnnoation redisLockAnnoation =              method.getAnnotation(RedisLockAnnoation.class);
		if (null == redisLockAnnoation)
			return 3;  //拦截器异常

    //判断拦截的方法是否位需要做同步锁的方法
    if (method.getName().equals("createHotelOrder")) {
			// 如果方法是创建酒店订单方法，则对酒店订单做同步锁支持
			HotelOrderBean bean = null;  //这里的bean是要加同步锁的方法参数传入的bean，这里是为了获取bean的关键信息作key使用

			Object[] os = invocation.getArguments(); //通过拦截器获取拦截方法的参数
			for (Object oBean : os) {
                //判断参数中如果有需要的参数，则跳出循环
				if (oBean instanceof HotelOrderBean) {
					bean = (HotelOrderBean) oBean;
					break;
				}
			}

			if (null != bean) {
                //取锁操作
				return runLock(invocation, redisLockAnnoation, bean);
			}
		}
    }

//取锁的操作
private Object runLock(MethodInvocation invocation, RedisLockAnnoation redisLockAnnoation, HotelOrderBean orderBean)
			throws Throwable {

		// 获取分布式锁的key，这里的key是常量（RedisKeyConstant.order_hotel_lock）+参数的信息拼凑的
		String key = RedisKeyConstant.order_hotel_lock + orderBean.getHotelInfoId() + "_" + orderBean.getHotelRoomId()
				+ "_" + orderBean.getHotelProductId();

		// 生成本次请求的ID
		String requestId = UUID.randomUUID().toString();

		LoggerUtil.DebugLogger.info("runLock 准备取锁：key=" + key + ",requestId=" + requestId);

		Map<String, Object> ret = dealLock(invocation, redisLockAnnoation, requestId, key);

		int retState = (int) ret.get("state");
		if (retState == 2) {
			// 如果取锁超时，则设置返回失败
			return 2;
		} else if (retState == 0) {
			// 如果出现异常，则设置返回失败
			return 0;
		} else {
			return ret.get("retBean");
		}
		
	}

    /**
	 * 处理取锁操作
	 * 
	 * @param invocation
	 * @param redisLockAnnoation
	 * @param requestId
	 * @param key
	 * @return
	 * @throws Throwable
	 */
	private Map<String, Object> dealLock(MethodInvocation invocation, RedisLockAnnoation redisLockAnnoation,
			String requestId, String key) throws Throwable {

		Map<String, Object> ret = new HashMap<>();

		if (redisLockAnnoation.isSpin()) {
			// 阻塞锁
			int lockRetryTime = 0; // 尝试取锁次数，默认为0
			try {
				while (!redisAPI.distributedLock(key, redisLockAnnoation.expireTime(), requestId)) {
					if (lockRetryTime++ > redisLockAnnoation.retryTimes()) {
						ret.put("state", 2); // state 1：成功 2：超时 0：异常
						ret.put("desc", "超时");
						ret.put("retBean", null);
						return ret; // 超时操作
					}
					LoggerUtil.DebugLogger.info("取锁失败：key=" + key + ",requestId=" + requestId + ",lockRetryTime="
							+ lockRetryTime + ",retryTimes=" + redisLockAnnoation.retryTimes());
					Thread.sleep(redisLockAnnoation.waitTime()); //如果没有取到锁，休眠一定时间后在获取
				}
				Object retBean = invocation.proceed();
				ret.put("state", 1); // state 1：成功 2：超时 0：异常
				ret.put("desc", "成功");
				ret.put("retBean", retBean);
				return ret; // 超时操作

			} catch (Exception e) {
//				ret.put("state", 0); // state 1：成功 2：超时 0：异常
//				ret.put("desc", e.getMessage());
//				ret.put("retBean", null);
//				return ret;
				throw e;
			} finally {
				// 释放锁
				LoggerUtil.DebugLogger.info("释放锁：key=" + key + ",requestId=" + requestId);
				redisAPI.releaseDistributedLock(key, requestId);
			}
		} else {
			// 非阻塞锁 ——目前无用
			try {
				if (!redisAPI.distributedLock(key, redisLockAnnoation.expireTime(), requestId)) {
					throw new Exception("订单超时，请稍候再试");
				}

				Object retBean = invocation.proceed();
				ret.put("state", 1); // state 1：成功 2：超时 0：异常
				ret.put("desc", "成功");
				ret.put("retBean", retBean);
				return ret;
			} catch (Exception e) {
				ret.put("state", 0); // state 1：成功 2：超时 0：异常
				ret.put("desc", e.getMessage());
				ret.put("retBean", null);
				return ret;
			} finally {
				// 释放锁
				redisAPI.releaseDistributedLock(key, requestId);
			}
		}
	}
}

代码说明：

1. 通过aop的方式拦截，拦截方式是around的方式。通过对MethodInterceptor实现invoke方法，我们可以对要拦截的方法执行前和执行后都作处理。分布式锁主要是对事务方法执行前加锁，然后在方法执行后释放锁。

2. Object retBean = invocation.proceed();就是事务方法执行

 

然后是注解的代码

 

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
@Inherited
public @interface RedisLockAnnoation {

	/**
	 * 是否阻塞锁； 1. true：获取不到锁，阻塞一定时间； 2. false：获取不到锁，立即返回
	 */
	boolean isSpin() default true;

	/**
	 * 超时时间
	 */
	int expireTime() default 30;

	/**
	 * 等待时间
	 */
	int waitTime() default 1000;

	/**
	 * 获取不到锁的等待时间
	 */
	int retryTimes() default 20;
}

代码说明：这段代码很简单。就是自定义一个注解，设置一个同步锁的参数。包括：是否需要阻塞，锁的时间，取锁的等待时间和循环次数等。

 

 最后就是使用了。只需要在需要使用分布式锁的地方加上注解就好了。这里是一个订单使用同步锁的例子

/**
	 * 创建一个酒店订单
	 * @param orderId
	 * @param orderBean
	 * @return	0：失败 1：成功 2：超时 3：未执行取锁操作 4:价格异常 5：产品信息错误 6：产品规则错误 7：参数错误 8:没有库存了
	 */
	@RedisLockAnnoation(isSpin = true, expireTime = 10, retryTimes = 5)
	public int createHotelOrder(String orderId,HotelOrderBean orderBean) throws Exception;

 

 

大妖怪-kane
关注
专栏目录
redis分布式锁
qq_44027353的博客
08-09 1202
解决方法是：value之前是随便写的一个值，现在不随便写了，先生成一个uuid作为锁的值存入redis，删除锁之前先查询判断redis中存储的uuid和自己生成的uuid相同后才去删除锁。问题：可能先从redis中进行查询，得到uuid后，redis中的锁过期了，然后别人又加锁了，我这里进行if判断两个uuid相等，然后又把别人的锁删除了。难点是锁的自动续期，业务方法还没有执行完，锁就过期了，最简单的方法就是把锁的过期时间设置很长，现在的java代码如下。就比较符合我们的实现习惯。...
详解Redis分布式锁（图文并茂，手把手搭建服务，代码详解，建议收藏）
Java框架、并发编程、分布式、微服务、Redis、HarmonyOS、中间件等技术
07-11 1739
本文章涉及很多关联篇，如需要请自取 VMware安装CentOS（保姆级教程，建议收藏） VMware+CentOS 7 静态IP设置方法 —保姆级教程，建议收藏 CentOS 7关闭防火墙 CentOS安装单击Redis Redis一主二从Sentinel监控配置（保姆级教程） 一、简介 分布式知识是考验一个程序员知识面广度和深度很好的度量标准，而分布式锁又是其中非常重要的一个知识点。可以说面试只要谈到分布式，没有不问分布式锁的。 我们知道分布式应用在进行逻辑处理的时候经常涉及到并发.
DistributedLocking:分布式锁定C＃库
04-21
分布式锁定 分布式锁的简单C＃实现，可以在专注于可扩展性的多客户端（流程）环境中使用。 快速开始 该库旨在通过抽象使用，因此，无论选择哪种基础存储库，基本操作均保持不变。 您可以在下面找到基本用法示例。 获取锁 为了获取锁，您需要提供： 资源ID-可以识别您的资源的东西， 所需的锁的TTL（生存时间）-如果您的进程无法正常释放锁，则它必须自动将自身变为非活动状态，以避免无限锁。 为此，您有一个简单的界面： // IDistributedLockProvider provider = ... var resourceId = " Resource ID " ; var ttl = TimeSpan . FromMinutes ( 5 ); var distributedLock = await provider . TryAcquireAsync ( resourceI
Redis构建分布式锁——Redlock
zhaohong_bo的专栏
05-16 309
本文来自：http://ifeve.com/redis-lock/ 简介 在不同进程需要互斥地访问共享资源时，分布式锁是一种非常有用的技术手段。 有很多三方库和文章描述如何用Redis实现一个分布式锁管理器，但是这些库实现的方式差别很大，而且很多简单的实现其实只需采用稍微增加一点复杂的设计就可以获得更好的可靠性。 这篇文章的目的就是尝试提出一种官方权威的用Redis实现分布式锁管理器的算法，我...
微服务架构之：Redis的分布式锁---搭建生产可用的Redis分布式锁
qq_53999369的博客
08-18 2564
单体架构上，乐观锁和悲观锁可以锁住并发情况下的同步代码块，我们多使用synchronized来对方法加锁。但是在配上负载均衡的集群模式下，普通的synchronized是无法锁住从两台服务器同时进入的请求。JVM内部的锁监视器直接作废。所以锁的监视器一定要在JVM的外部，让所有JVM都去找独一无二的锁监视器来获取锁，这样也就只有一个线程获取锁，也就实现了多JVM的线程互斥。分布式锁核心是实现多进程之间的互斥，而满足这一点的方式有很多，常见的有三种：Mysql、Redis。
利用Redis创建分布式锁
PJC的博客
09-21 286
利用Redis创建分布式锁
Redis5.0搭建分布式锁、分布式缓存服务最佳实践（非Cluster集群版本）
热门推荐
邪恶八进制
12-27 18万+
引入依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.6.RELEASE</v...
一个使用scrapy和redis搭建的分布式爬虫搜索引擎
02-23
2. **分布式锁（Distributed Locks）**: 在多节点环境中，防止同一URL被多个爬虫实例同时抓取，可以通过Redis的SetNX命令实现分布式锁。 3. **中间件通信（Middleware Communication）**: Redis可以作为一个消息...
Redis高并发秒杀和分布式锁技术应用及实战解析
06-20
本课程旨在让你快速学习和掌握，基于Redis应用场景很...Redis的安装和环境搭建 高并发秒杀 Redis 实现分布式锁 Redis 实现微信群红包 Redis 实现项目实战讲解和代码演示thinkphp5 中如何使用 Redis常见的坑和问题交流
Redis 3.x 分布式集群搭建.pdf
02-15
在redis看来，响应时间是最苛刻的条件，增加一层带来的开销是redis不能接受的。因此，redis实现了客户端对节点的直接访问，为了去中心化，节点之间通过gossip协议交换互相的状态，以及探测新加入的节点信息。redis...
分布式锁怎么实现？
qfc8930858的博客
02-01 258
用Zookeeper实现分布式锁其实就是创建一个临时节点：如果临时节点之前不存在，则临时节点创建成功，则这把锁属于你了。 此时有其他人去创建同名的临时节点，如果已经存在了，说明别人已经占有了这把锁，你就失败了，这时候就对那个临时节点注册一个监听器。当锁被释放的时候会通知你然后尝试去创建。 其实释放锁就是删除临时节点，若删除临时节点，ZK会通知别人这个节点被删除了，相当于锁释放了。然后就会尝试再...
Redis——构建分布式锁
Alex_cf的博客
12-28 271
分布式锁
详解Redis分布式锁（图文并茂，手把手搭建服务，代码详解，建议收藏）(1)
最新发布
2401_84520271的博客
05-03 722
最后对于程序员来说，要学习的知识内容、技术有太多太多，要想不被环境淘汰就只有不断提升自己，从来都是我们去适应环境，而不是环境来适应我们！这里附上上述的技术体系图相关的几十套腾讯、头条、阿里、美团等公司2021年的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。
厚积薄发打卡Day70 ：【itheima】Zookeeper快速入门（下）＜分布式锁到集群搭建＞
COOLGWAYNE_TECH_BLOG
06-29 123
5. 分布式锁 5.1 概念 在我们进行单机应用开发，涉及并发同步的时候，我们往往采用synchronized或者Lock的方式来解决多线程间的代码同步问题，这时多线程的运行都是在同一个JVM之下，没有任何问题。 但当我们的应用是分布式集群工作的情况下，属于多JVM下的工作环境，跨JVM之间已经无法通过多线程的锁解决同步问题。 那么就需要一种更加高级的锁机制，来处理种跨机器的进程之间的数据同步问题——这就是分布式锁。 常用分布式锁的实现 基于缓存实现： Redis分布式锁的正确实现方式
10分钟搞定分布式锁的三种实现方式
李清的博客
12-06 1616
1、为什么需要分布式锁 目前，几乎所有的大型网站以及应用都是分布式部署的，分布式场景中的数据一致性问题一直是一个比较重要的话题。分布式的CAP理论告诉我们，“任何一个分布式系统都无法同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance），最多只能同时满足其中的两项”。所以，很多系统在设计之初就需要考虑这三者之间的取舍。在互联网领域的绝大多数场景中，都需要牺牲强一致性来换取系统的高可用性，系统往往只需要保证“最终一致性”，只要这个最
基于ETCD实现分布式锁&实战：控制多个应用仅一台执行任务
02-28 1134
  我们知道，分布式锁有好几种方案：基于Redis、基于数据库如MySQL、基于注册中心如Zookeeper等；而 K8S 体系中基于 Go 语言编写的的 ETCD 则对于分布式锁有着更强大的支持。   ETCD 有一个租约机制，客户端跟 ETCD 服务端订立一个“租约”后，需要在租约到期之前进行续约，否则会在到期后被自动解除租约，而租约可以挂载多个 key-value，当租约过期时，挂载在上面的 key-value 也会跟着被删除。既有类似 Redis / Zookeeper 的 key-value 机制
分布式锁的三种实现方式
TJtulong的博客
06-04 2045
分布式系统高并发下的问题 有一个电商抢购的场景：为了避免超卖的问题，在单服务器环境下，可用通过JVM的锁解决。 @RequestMapping("/deduct_stock") public String deductStock() { synchronized (this) { // 从Redis中取出当前库存 int stock = Integer.parseInt(stringRedisTemplate.opsForValue().get("stock"));
RedisTemplate同步大数据量性能实测
java_chc的博客
05-18 704
最近项目上有写入大量数据到 redis 中的需求，使用的是 springboot 集成 redis 客户端，就少不了使用 RedisTemplate 来操作。由于数据量比较多，是需要考虑写入性能问题的，如何才能高效写入到 redis 中呢？通过度娘知道了使用 pipelined 方式性能非常好，但是却没有解释为什么？带着这个疑惑进行了这次的实测。
redis工具类设计之回调函数的使用
weixin_39417722的博客
05-04 1182
前言 我们平时在项目中手写共同工具类的时候, 对于好多异常的处理很是头疼, 对于各种连接, 各种io的开启关闭控制都是一个头大的事情, 放在具体使用阶段进行处理又怕别人使用的时候忘记关闭. 这个时候回调函数的作用就体现出来了. 代码 回调函数需要一个接口, 当然写到类中也是没有问题的: public class RedisTemplate { private Jedis jedis; ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值