Redis之分布式锁

最新推荐文章于 2023-04-25 19:40:31 发布
最新推荐文章于 2023-04-25 19:40:31 发布
阅读量873 收藏
点赞数
分类专栏： spring boot redis 文章标签： redis spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43654581/article/details/122086141
版权

1.环境

        <!-- RedisTemplate -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

spring:
  redis:
    host: 192.168.8.128
    port: 6379
    password: 1234
    database: 0
    timeout: 10000
    jedis:
      pool:
        max-wait: -1
        max-active: -1
        max-idle: 20
        min-idle: 10

在这里插入图片描述

2.Redis配置

package com.yzm.redis10.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class ObjectMapperConfig {

    public static final ObjectMapper objectMapper;
    private static final String PATTERN = "yyyy-MM-dd HH:mm:ss";

    static {
        JavaTimeModule javaTimeModule = new JavaTimeModule();
        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer());
        javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer());
        objectMapper = new ObjectMapper()
                // 转换为格式化的json(控制台打印时，自动格式化规范)
                //.enable(SerializationFeature.INDENT_OUTPUT)
                // Include.ALWAYS  是序列化对像所有属性(默认)
                // Include.NON_NULL 只有不为null的字段才被序列化,属性为NULL 不序列化
                // Include.NON_EMPTY 如果为null或者 空字符串和空集合都不会被序列化
                // Include.NON_DEFAULT 属性为默认值不序列化
                .setSerializationInclusion(JsonInclude.Include.NON_NULL)
                // 如果是空对象的时候,不抛异常
                .configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false)
                // 反序列化的时候如果多了其他属性,不抛出异常
                .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
                // 取消时间的转化格式,默认是时间戳,可以取消,同时需要设置要表现的时间格式
                .configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false)
                .setDateFormat(new SimpleDateFormat(PATTERN))
                // 对LocalDateTime序列化跟反序列化
                .registerModule(javaTimeModule)

                .setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY)
                // 此项必须配置，否则会报java.lang.ClassCastException: java.util.LinkedHashMap cannot be cast to XXX
                .enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY)
        ;
    }

    static class LocalDateTimeSerializer extends JsonSerializer<LocalDateTime> {
        @Override
        public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
            gen.writeString(value.format(DateTimeFormatter.ofPattern(PATTERN)));
        }
    }

    static class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {
        @Override
        public LocalDateTime deserialize(JsonParser p, DeserializationContext deserializationContext) throws IOException {
            return LocalDateTime.parse(p.getValueAsString(), DateTimeFormatter.ofPattern(PATTERN));
        }
    }
}

package com.yzm.redis10.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    /**
     * redisTemplate配置
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer<Object> jacksonSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        jacksonSerializer.setObjectMapper(ObjectMapperConfig.objectMapper);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // 使用StringRedisSerializer来序列化和反序列化redis的key,value采用json序列化
        template.setKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jacksonSerializer);

        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(stringRedisSerializer);
        template.setHashValueSerializer(jacksonSerializer);
        template.afterPropertiesSet();

        return template;
    }
}

3.模拟商品

package com.yzm.redis10.entity;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

import java.io.Serializable;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Accessors(chain = true)
public class Product implements Serializable {

    private static final long serialVersionUID = 1L;

    private Integer id;

    /**
     * 商品名
     */
    private String name;

    /**
     * 库存
     */
    private Integer leftNum;
}

package com.yzm.redis10.service;

import com.yzm.redis10.entity.Product;

import java.util.List;

public interface ProductService {

    Product getById(Integer id);

    void updateById(Product product);

    List<Product> list();

}

package com.yzm.redis10.service.impl;

import com.yzm.redis10.entity.Product;
import com.yzm.redis10.service.ProductService;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class ProductServiceImpl implements ProductService {

    private static final Map<Integer, Product> productMap;

    static {
        productMap = new HashMap<>();
        productMap.put(productMap.size() + 1, Product.builder().id(productMap.size() + 1).name("苹果").leftNum(10).build());
    }

    @Override
    public Product getById(Integer id) {
        return productMap.get(id);
    }

    @Override
    public void updateById(Product product) {
        Product update = productMap.get(product.getId());
        update.setLeftNum(product.getLeftNum());
        productMap.put(product.getId(), update);
    }

    @Override
    public List<Product> list() {
        return new ArrayList<>(productMap.values());
    }
}

4.锁实现(推荐)

package com.yzm.redis10.redis;

import com.yzm.redis10.entity.Product;
import com.yzm.redis10.service.ProductService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Component;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
@Component
public class RedisLock {

    private final StringRedisTemplate redisTemplate;
    private final ProductService productService;

    public RedisLock(StringRedisTemplate redisTemplate, ProductService productService) {
        this.redisTemplate = redisTemplate;
        this.productService = productService;
    }

    private static final int TIMEOUT = 4000;
    private static final String LOCK_PREFIX = "secKill:";
    private final AtomicInteger i = new AtomicInteger(1);

    public void secKill(int productId) {
        // 查询库存
        Product product = productService.getById(1);
        if (product.getLeftNum() < 1) {
            log.error("库存不足");
            return;
        }

        // 加锁
        String uuid = UUID.randomUUID().toString();
        if (!lock(LOCK_PREFIX + productId, uuid)) {
            log.info("活动太火爆了，请稍后再操作");
            return;
        }

        //秒杀逻辑
        try {
            product.setLeftNum(product.getLeftNum() - 1);
            productService.updateById(product);
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 解锁
        unlock(LOCK_PREFIX + productId, uuid);
        log.info("秒杀成功" + i.getAndIncrement());
    }

    /**
     * 加锁
     */
    public boolean lock(String key, String value) {
        Boolean ifAbsent = redisTemplate.opsForValue().setIfAbsent(key, value, Duration.ofMillis(TIMEOUT));
        if (ifAbsent != null && ifAbsent) {
            log.info("加锁成功");
            return true;
        }
        return false;
    }

    /**
     * 解锁(lua脚本原子性)
     */
    public void unlock(String key, String value) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] " +
                "then return redis.call('del', KEYS[1]) " +
                "else return 0 " +
                "end";

        List<String> keys = new ArrayList<>();
        keys.add(key);
        Long execute = redisTemplate.execute(RedisScript.of(script, Long.class), keys, value);
        log.info("解锁成功 = " + execute);
    }
}

package com.yzm.redis10.controller;

import com.yzm.redis10.entity.Product;
import com.yzm.redis10.redis.RedisLock;
import com.yzm.redis10.redis.RedisLock2;
import com.yzm.redis10.redis.RedisLock3;
import com.yzm.redis10.service.ProductService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class ProductController {

    private final ProductService productService;
    private final RedisLock redisLock1;
    private final RedisLock2 redisLock2;
    private final RedisLock3 redisLock3;

    public ProductController(ProductService productService, RedisLock redisLock1,RedisLock3 redisLock3, RedisLock2 redisLock2) {
        this.productService = productService;
        this.redisLock1 = redisLock1;
        this.redisLock2 = redisLock2;
        this.redisLock3 = redisLock3;
    }

    @GetMapping("/list")
    public List<Product> list() {
        return productService.list();
    }

    @GetMapping("/inr")
    public void inrLeft(Integer id) {
        productService.updateById(Product.builder().id(id).leftNum(10).build());
    }

    @GetMapping("/buy")
    public String buy(long time) {
        for (int i = 0; i < 100; i++) {
            try {
                new Thread(() -> redisLock1.secKill(1)).start();
                Thread.sleep(time);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return "秒杀结束";
    }
}

http://localhost:8080/list
在这里插入图片描述
http://localhost:8080/buy?time=50
在这里插入图片描述

http://localhost:8080/list
在这里插入图片描述

5.锁实现

package com.yzm.redis10.redis;

import com.yzm.redis10.entity.Product;
import com.yzm.redis10.service.ProductService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.time.Duration;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
@Component
public class RedisLock2 {

    private final StringRedisTemplate redisTemplate;
    private final ProductService productService;

    public RedisLock2(StringRedisTemplate redisTemplate, ProductService productService) {
        this.redisTemplate = redisTemplate;
        this.productService = productService;
    }

    private static final int TIMEOUT = 4000;
    private static final String LOCK_PREFIX = "secKill:";
    private final AtomicInteger i = new AtomicInteger(1);
    private static final ThreadLocal<String> local = new ThreadLocal<>();

    public void secKill(int productId) {
        Product product = productService.getById(1);
        if (product.getLeftNum() < 1) {
            log.error("库存不足");
            return;
        }

        //加锁
        String uuid = UUID.randomUUID().toString();
        if (!lock(LOCK_PREFIX + productId, uuid)) {
            log.info("活动太火爆了，请稍后再操作");
            return;
        }

        //秒杀逻辑
        try {
            product.setLeftNum(product.getLeftNum() - 1);
            productService.updateById(product);
            Thread.sleep(80);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //解锁
        unlock(LOCK_PREFIX + productId, uuid);
        log.info("秒杀成功" + i.getAndIncrement());
    }

    /**
     * 加锁
     */
    public boolean lock(String key, String value) {
        Boolean ifAbsent = redisTemplate.opsForValue().setIfAbsent(key, value, Duration.ofMillis(TIMEOUT));
        if (ifAbsent != null && ifAbsent) {
            log.info("加锁成功");
            local.set(value);
            return true;
        }
        return false;
    }

    /**
     * 解锁
     */
    public void unlock(String key, String value) {
        String localValue = local.get();
        if (localValue.equals(value) && localValue.equals(redisTemplate.opsForValue().get(key))) {
            log.info("解锁成功");
            redisTemplate.delete(key);
            local.remove();
        }
    }
}

    @GetMapping("/buy2")
    public String buy2(long time) {
        for (int i = 0; i < 100; i++) {
            try {
                new Thread(() -> redisLock2.secKill(1)).start();
                Thread.sleep(time);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return "秒杀结束";
    }

http://localhost:8080/buy2?time=50
在这里插入图片描述

6.锁实现

package com.yzm.redis10.redis;

import com.yzm.redis10.entity.Product;
import com.yzm.redis10.service.ProductService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
@Component
public class RedisLock3 {

    private final StringRedisTemplate redisTemplate;
    private final ProductService productService;

    public RedisLock3(StringRedisTemplate redisTemplate, ProductService productService) {
        this.redisTemplate = redisTemplate;
        this.productService = productService;
    }

    private static final int TIMEOUT = 4000;
    private static final String LOCK_PREFIX = "secKill:";
    private final AtomicInteger ato = new AtomicInteger(1);

    public void secKill(int productId) {
        Product product = productService.getById(1);
        if (product.getLeftNum() < 1) {
            log.error("库存不足");
            return;
        }

        //加锁
        //value包含拥有者标识，具有唯一性，防止任何人都可以解锁
        String userId = UUID.randomUUID() + ":" + System.currentTimeMillis() + TIMEOUT;
        if (!lock(LOCK_PREFIX + productId, userId)) {
            log.error("活动太火爆了，请稍后再操作");
            return;
        }

        //秒杀逻辑
        try {
            product.setLeftNum(product.getLeftNum() - 1);
            productService.updateById(product);
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //解锁
        unlock(LOCK_PREFIX + productId, userId);
        log.info("秒杀成功" + ato.getAndIncrement());
    }

    /**
     * 加锁
     */
    public boolean lock(String key, String value) {
        //没有锁，持有并加锁
        Boolean ifAbsent = redisTemplate.opsForValue().setIfAbsent(key, value);
        if (ifAbsent != null && ifAbsent) {
            log.info("加锁成功");
            return true;
        }

        //锁已被持有，判断锁过期
        synchronized (RedisLock3.class) {
            String redisValue = redisTemplate.opsForValue().get(key);
            if (StringUtils.hasLength(redisValue) && Long.parseLong(redisValue.split(":")[1]) < System.currentTimeMillis()) {
                String oldValue = redisTemplate.opsForValue().getAndSet(key, value);
                if (StringUtils.hasLength(oldValue) && oldValue.equals(redisValue)) {
                    log.info("锁过期，重新持有锁");
                    return true;
                }
            }
        }

        return false;
    }

    /**
     * 解锁
     */
    public void unlock(String key, String value) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] " +
                "then return redis.call('del', KEYS[1]) " +
                "else return 0 " +
                "end";

        List<String> keys = new ArrayList<>();
        keys.add(key);
        Long execute = redisTemplate.execute(RedisScript.of(script, Long.class), keys, value);
        System.out.println("解锁成功 = " + execute);
    }

}

    @GetMapping("/buy3")
    public String buy3(long time) {
        for (int i = 0; i < 100; i++) {
            try {
                new Thread(() -> redisLock3.secKill(1)).start();
                Thread.sleep(time);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return "秒杀结束";
    }

http://localhost:8080/buy3?time=50
在这里插入图片描述
在这里插入图片描述

相关链接

首页
上一篇：Stream消息队列
下一篇：布隆过滤器

yzm4399
关注
专栏目录
redis之分布式锁
weixin_33645586的博客
01-10 1473
CSDN云计算 核心问题： 1、为什么要使用分布式锁？ 再开始讲分布式锁之前，有必要简单介绍一下，为什么需要分布式锁？ 与分布式锁相对应的是【单机锁】，我们在写多线程程序的时候，避免同时操作一个共享变量产生数据问题，通常会使用一把锁来【互斥】，以保证共享变量的正确性，其使用范围是【同一进程】中。 如果换做是多个线程，需要同时操作一个共享资源，如何互斥呢？ 例如，现在的业务应用通常都是微服务架构，这也意味着一个应用会部署多个进程，那这多个进程如果需要修改MySql中的同一行记录时，为了避免操作乱序倒置数.
C++基于redis的分布式锁redisAPI
12-12
本文将深入探讨如何使用C++结合Redis实现分布式锁，并详细讲解Redis API在C++中的应用，以及如何处理与Boost库的集成。 首先，Redis是一个高性能的键值存储数据库，广泛用于缓存、消息队列、分布式锁等场景。分布式...
[Redis 操作] 今日redis工作操作
汤圆的博客
12-14 1128
前言: 因为同事硬件 不按照规矩来，造成了错误数据，清算不认 没办法，只能重新手动上传一遍 不认的数据， 把他的格式修改正确 因为我们是redis去重，所以我得去把存入的key给删除掉！重新上传一遍 已经上传过的数据了！ Redis简单的指令操作 由于某种原因，只能在linux上面登录 redis 然后使用指令删除 指定key！！！ 第一步: 在你安装的redis bin目录下面执行 这个命令 ./redis-cli -h 127.0.0.1 -p 6379 -a 密...
浅谈在Java中对Redis序列化的配置
最新发布
m0_63445035的博客
04-25 2434
在Java中对Redis序列化的配置
CGB2005-京淘12(Redis入门案例,分布式锁,SpringBoot整合Redis,redis配置类,缓存场景,ObjectMapper 泛型T,商品分类的redis缓存)
aa35434的博客
01-04 294
1. SpringBoot整合Redis 1.1 切换开发环境(这里是切换为windows模式) 1.1.1 数据源配置 1.1.2 修改properties配置文件(切换为windows系统的路径) 说明:修改图片配置路径的文件 image.properties文件. #properties的作用就是封装key=value 业务数据 image.dirPath=D:/JT-SOFT/images #image.dirPath=/usr/local/src/images image.urlPath=htt
Redis配置序列化反序列化Jackson ObjectMapper 中的 enableDefaultTyping 方法从 2.10.0 开始标记为过期
流沙QuickSand
10-05 3766
Redis配置序列化反序列化Jackson ObjectMapper 中的 enableDefaultTyping 方法从 2.10.0 开始标记为过期
Redis实现分布式锁(附源码+讲义)
07-01
在学习Java多线程编程的时候，锁是一个很重要也... 理解redis分布式锁的应用场景  掌握redis分布式锁的实现原理  掌握redis分布式锁在微服务项目中的应用  掌握redis分布式锁常见的面试题 以下是课程部分讲义截图：
redis实现分布式锁,自旋式加锁,lua原子性解锁
07-16
Redis作为一个高性能的键值存储系统，常被用作实现分布式锁的工具。本文将深入探讨如何使用Redis实现分布式锁，以及如何利用自旋式加锁和Lua脚本实现原子性解锁。 首先，我们来理解分布式锁的基本概念。分布式锁是...
Java基于redis实现分布式锁代码实例
08-19
Java基于Redis实现分布式锁代码实例 分布式锁的必要性 在多线程环境中，资源竞争是一个常见的问题。例如，在一个简单的用户操作中，一个线程修改用户状态，首先在内存中读取用户状态，然后在内存中进行修改，然后...
spring boot配置redis
ytsydmx的博客
09-01 1288
springboot 集成redis maven引入redis，以及工具类 <!-- Redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dep
RedisTemplate配置的jackson.ObjectMapper里的一个enableDefaultTyping方法过期解决
panda1103的博客
05-09 8880
1、前言 最近升级SpringBoot，从2.1.6版本升级到2.2.6版本，发现enableDefaultTyping方法过期过期了。 该方法是指定序列化输入的类型，就是将数据库里的数据安装一定类型存储到redis缓存中。 2、为什么要指定序列化输入类型 2.1、没有指定序列化输入类型 如果注释掉enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL)，那存...
Jackson库中objectMapper的使用详解
热门推荐
韩小文的博客
02-24 5万+
ObjectMapper类是Jackson库的主要类。它提供一些功能将转换成Java对象匹配JSON结构，反之亦然。它使用JsonParser和JsonGenerator的实例实现JSON实际的读/写。 构造函数 S.N. 构造函数 &amp; 描述 1 ObjectMapper() 默认的构造函数，这将构建默认JsonFactory必要时使用StdSerializerProvi...
Redis 基本理论知识
bad_boy的博客
06-22 340
1. Redis应用场景 分布式会话缓存 分布式锁 发布/订阅 排行榜/计数器 队列 全页缓存 缓存热点数据 2. 更新正确方法 先更新数据库，再删除缓存 3. 高并发引起的问题 缓存穿透：缓存和数据库都不存在的key，流量过高导致DB挂掉 解决方案：（常用）访问key未在DB查询到的值，也将空值写进缓存，但设置过期时间 采用布隆过滤器，不存在的key直接被过滤掉 缓存击穿：缓存中没有，数据库中有，直接去数据库中取数据，数据库压力过大导致挂掉（并发查询一条数据） 解决方案：设置热点数据永不过期；加互斥
ObjectMapper的使用
呢喃北上的博客
04-05 2360
ObjectMapper类是Jackson库的主要类。它提供一些功能将转换成Java对象匹配JSON结构，反之亦然。它使用JsonParser和JsonGenerator的实例实现JSON实际的读/写。 类声明 以下是org.codehaus.jackson.map.ObjectMapper类的声明： public class ObjectMapper extends ...
redisTemplate序列化中ObjectMapper.DefaultTyping.NON_FINAL漏洞的解决
m0_37708405的博客
03-27 1万+
第一种方法：使用默认的springboot方法 @Bean(name = "redisTemplate") public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) { RedisTemplate<String, Object> redisTemplate ...
ObjectMapper---实用的Object—json工具！结合redis实用
oppoppoppo的专栏
12-16 1126
首先 说一下ObjectMapper的代码 package com.fasterxml.jackson.databind;import java.util.
2 Springboot中使用redis，配置redis的key value生成策略
tianyaleixiaowu的专栏
04-24 3万+
redis在springboot中的应用，springboot整合redis，redis存储集合
使用Redis实现分布式锁详解
"基于Redis方式实现分布式锁" 在分布式系统中，确保同一时刻只有一个客户端能够执行特定操作是非常重要的，这就是分布式锁的作用。本篇文章主要关注基于Redis实现的分布式锁。Redis作为一个内存数据存储系统，因其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值