redis入门到放弃-2

最新推荐文章于 2023-11-22 11:06:18 发布
最新推荐文章于 2023-11-22 11:06:18 发布
阅读量999 收藏
点赞数
分类专栏： redis 文章标签： redis 数据库 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bug_tan90/article/details/122100579
版权

8、springboot整合redis

导入依赖
 <!--redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
<!--            <version>2.1.6.RELEASE</version>-->
        </dependency>
        <!--Spring2.x集成redis所需common-pool2-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
<!--            <version>2.6.2</version>-->
        </dependency>
配置redis信息 （application.properties）
# REDIS (RedisProperties)
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=
# Redis服务器连接端口
spring.redis.port=
# Redis服务器连接密码（默认为空）
spring.redis.password= 
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=5000
#
#redis:
## Redis数据库索引（默认为0）
#database: 0
## Redis服务器地址
#host: 127.0.0.1
## Redis服务器连接端口
#port: 6379
## Redis服务器连接密码（默认为空）
#password:
## 连接池最大连接数（使用负值表示没有限制）
#jedis:
#pool:
#max-active: 8
## 连接池最大阻塞等待时间（使用负值表示没有限制）
#max-idle: 8
## 连接池中的最大空闲连接
#max-wait: -1
## 连接池中的最小空闲连接
#min-idle: 0
## 连接超时时间（毫秒）
#timeout: 0
配置redis工具类
package com.example.springbootredis.util;

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.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.annotation.CachingConfigurerSupport;
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 extends CachingConfigurerSupport {

    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = this.jackson2JsonRedisSerializer();

        //String序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key采用string的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        //hash的key采用string的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //value序列化也采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //hash的value也采用jackson
        template.setHashValueSerializer( jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }

    /**
     * 自定义jackson2JsonRedisSerializer对象
     * @return
     */
    private Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer() {
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer =
                new Jackson2JsonRedisSerializer<>(Object.class);

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.configure(MapperFeature.USE_ANNOTATIONS, false);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        // 此项必须配置，否则会报java.lang.ClassCastException: java.util.LinkedHashMap cannot be cast to XXX
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL
                , JsonTypeInfo.As.PROPERTY);
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        return jackson2JsonRedisSerializer;
    }

}
控制层
package com.example.springbootredis.controller;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author wzh
 * @date 2021/12/22 10:47
 */
@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping
    public String testRedis(){
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //从redis获取值
        String name = (String) redisTemplate.opsForValue().get("name");
        return name;
    }
}

9、Redis的事务操作

Redis的事务定义

Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行，事务在执行的过程中，不会被其他客户端发送来的命令请求打断。

Redis事务的主要作用就是串联多个命令防止别的命令插队

Multi、Exec、discard

从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，知道输入Exec后，Redis会将之前的命令队列中的命令依次执行

组队的过程中可以通过discard来放弃组队

在这里插入图片描述

案例事务的错误处理

组队成功提交成功

在这里插入图片描述

组队阶段报错，提交失败 ： 组队中某个命令出现错误，执行时整个的所有队列都会被取消
在这里插入图片描述

在这里插入图片描述

组队成功，提交失败情况 ：如果执行阶段某个命令报出了错误，则只有报错的命令不会被执行，而其他的命令都会被执行
在这里插入图片描述

在这里插入图片描述

事务冲突问题
悲观锁

每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁，传统的关系型数据库里面就用到了很多这种锁机制，比如行锁，表锁，读锁，写锁，都是在操作之前先上锁

在这里插入图片描述

乐观锁

每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新整个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量。Redis就是利用这种check-and-set机制实现事务的

在这里插入图片描述

WATCH key [key …]

在执行multi之前，先执行watch key1 【key2】， 可以监听一个（或多个）key，如果在事务执行之前这个（或这些）key被其他命令所改动，那么事务将被打断

在这里插入图片描述

在这里插入图片描述

unwatch

取消watch命令对所有key的监视

如果在执行watch命令之后，EXEC命令或DISCARD命令先被执行了的话，那么就不需要再执行UNWATCH了。

Redis事务三特性

  • 单独的隔离操作

    事务中的所有命令都会序列化、按顺序地执行。事务再执行的过程中，不会被其他客户端发送来的命令请求打断。

  • 没有隔离级别的概念

    队列中的命令没有提交之前都不会被实际被执行，因为事务提交之前任何指令都不会实际执行

  • 不保证原子性

    事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚

10、秒杀案例

单机版
package com.example.springbootredis.controller;


import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.Jedis;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.IOException;

/**
 * @author wzh
 * @date 2021/12/22 10:47
 */
@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping
    public String testRedis(){
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //从redis获取值
        String name = (String) redisTemplate.opsForValue().get("name");
        return name;
    }

    //秒杀过程
    public static boolean doSecKill(String uid,String prodid) throws IOException{
        //1 uid 和prodid非空判断
        if (uid == null || prodid == null){
            return false;
        }
        //2 连接redis  各人隐私不给看
        Jedis jedis = new Jedis("*****", &&&&&);
        jedis.auth("****");

        //3 拼接key
            //3.1 库存key
        String kcKey = "sk:"+prodid+":qt";
            //3.2秒杀成功用户key
        String userKey = "sk:" + prodid+":user";
        //4 获取库存，如果库存null，秒杀还没开始
        String kc = jedis.get(kcKey);
        if(kc == null){
            System.out.println("秒杀还没有开始，请求失败");
            jedis.close();
            return false;
        }
        //5 判断用户是否重复秒杀操作
        if (jedis.sismember(userKey,uid)){
            System.out.println("已经秒杀成功，不能重复秒杀");
            jedis.close();
            return false;
        }
        //6 判断如果商品数量，库存数量小于1，秒杀结束
        if (Integer.parseInt(kc)<=0){
            System.out.println("秒杀已经结束了");
            jedis.close();
            return false;
        }
        //7 秒杀过程
        //7.1 库存-1
        jedis.decr(kcKey);
        //7.2 把秒杀成功用户添加清单里面
        jedis.sadd(userKey,uid);
        System.out.println("秒杀成功");
        jedis.close();
        return true;
    }
}

测试

 @Test
    public void test1() throws IOException {
        Random random = new Random();
        int j;
        for (int e = 0; e < 10; e++) {
            String uid = "";
            for (int i = 0; i <10 ; i++) {
                j = random.nextInt(10);
                uid += j;
            }
            RedisTestController.doSecKill(uid,"0101");
        }

    }
秒杀并发解决
安装ab
云服务器上安装
yum install httpd-tools
ab --help
请求帮助可以看到很多使用方法
本机安装去官网下然后配置环境变量

https://www.apachehaus.com/cgi-bin/download.plx

使用ab
ab -c concurrency   并发性
Number of multiple requests to make at a time 一次发出的并发性多个请求的数量

ab -n requests 请求
Number of requests to perform执行的请求数

-p postfile     发布文件
File containing data to POST. Remember also to set -T包含要POST的数据的文件。还请记住设置-T

 -T content-type 
 Content-type header to use for POST/PUT data, eg.
 'application/x-www-form-urlencoded'Default is 'text/plain'用于POST/PUT数据的内容类型头，例如。“application/ x-www-form-urlencoded”默认是“文本/普通”
 
 ab -n 1000 -c 100 -p /home/test/postfile -T application/x-www-form-urlencoded http://172.16.17.225:8080/redisTest/doSecKill

ab -n 1000 -c 100 -p /home/test/postfile -T application/x-www-form-urlencoded localhost:8080/redisTest/doSecKill

连接超时问题处理

再增加ab测试的并发量和请求总数后，因为乐观锁的原因，会出现连接超时问题，先点的没秒到，后点的抢到了。

处理方法
1、创建JedisPoolUtils 工具类

package com.example.springbootredis.util;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisPoolUtils {
    private static volatile JedisPool jedisPool = null;

    private JedisPoolUtils(){

    }

    public static JedisPool getJedisPoolInstance() {
        if(null == jedisPool) {
            synchronized (JedisPoolUtils.class) {
                if(null == jedisPool) {
                    JedisPoolConfig poolConfig = new JedisPoolConfig();
                    poolConfig.setMaxIdle(32);
                    poolConfig.setMaxWaitMillis(100*1000);
                    poolConfig.setTestOnBorrow(true);
                    jedisPool = new JedisPool(poolConfig,"8.130.16.99",7777,60000,"123qwe");
                }
            }
        }
        return jedisPool;
    }

    public static void release(JedisPool jedisPool, Jedis jedis) {
        if(null != jedis) {
            jedisPool.returnResource(jedis);
        }
    }
}

2、使用连接池得到jedis对象

//通过连接池得到jedis对象
        JedisPool jedisPoolInstance = JedisPoolUtils.getJedisPoolInstance();
        Jedis jedis = jedisPoolInstance.getResource();
超卖问题

在这里插入图片描述
查看库存为-190
在这里插入图片描述

在这里插入图片描述
解决方法

1、监视库存
jedis.watch(kcKey);

2、使用事务

//使用事务
        Transaction multi = jedis.multi();

        //组队操作
        multi.decr(kcKey);
        multi.sadd(userKey,uid);
        //执行
        List<Object> results = multi.exec();

        if (results == null || results.size() ==0){
            System.out.println("秒杀失败了....");
            jedis.close();
            return false;
        }

加事务后-乐观锁（解决超卖问题），但出现遗留库存和连接超时

解决库存遗留问题
LUA脚本

Lua是一个小巧的脚本语言，可以被C++代码调用，也可以反过来调用C++函数，Lua并没有提供强大的库，一个完整的Lua解释器不过200k，所以Lua不适合作为独立开发应用程序的语言，而是一个嵌入式脚本语言。
在这里插入图片描述

在这里插入图片描述
通过LUA脚本解决争抢问题，实际上是redis利用其单线程的特性，用任务队列的方式解决多任务并发的问题
在这里插入图片描述

LUA脚本代码
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

类中doSockill函数
在这里插入图片描述

RDB（Redis DataBase）
是什么

在指定的时间间隔内将内存中的数据集快照写入磁盘， 也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里

12.2.3.备份是如何执行的

Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到 一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。 整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能 如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。

12.2.3.备份是如何执行的

Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到 一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。 整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能 如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失

12.2.4.Fork

Fork的作用是复制一个与当前进程一样的进程。新进程的所有数据（变量、环境变量、程序计数器等） 数值都和原进程一致，但是是一个全新的进程，并作为原进程的子进程
在Linux程序中，fork()会产生一个和父进程完全相同的子进程，但子进程在此后多会exec系统调用，出于效率考虑，Linux中引入了“写时复制技术”
一般情况父进程和子进程会共用同一段物理内存，只有进程空间的各段的内容要发生变化时，才会将父进程的内容复制一份给子进程。

12.2.5.RDB持久化流程

在这里插入图片描述

.dump.rdb文件

在redis.conf中配置文件名称，默认为dump.rdb
在这里插入图片描述

配置位置

rdb文件的保存路径，也可以修改。默认为Redis启动时命令行所在的目录下
dir “/myredis/”
在这里插入图片描述

如何触发RDB快照；保持策略
.配置文件中默认的快照配置

在这里插入图片描述

命令save VS bgsave

save ：save时只管保存，其它不管，全部阻塞。手动保存。不建议。
bgsave：Redis会在后台异步进行快照操作， 快照同时还可以响应客户端请求。
可以通过lastsave 命令获取最后一次成功执行快照的时间

flushall命令

执行flushall命令，也会产生dump.rdb文件，但里面是空的，无意义

.###SNAPSHOTTING快照###
Save

格式：save 秒钟 写操作次数
RDB是整个内存的压缩过的Snapshot，RDB的数据结构，可以配置复合的快照触发条件，
默认是1分钟内改了1万次，或5分钟内改了10次，或15分钟内改了1次。
禁用
不设置save指令，或者给save传入空字符串

.stop-writes-on-bgsave-error

在这里插入图片描述

当Redis无法写入磁盘的话，直接关掉Redis的写操作。推荐yes.

rdbcompression 压缩文件

在这里插入图片描述

对于存储到磁盘中的快照，可以设置是否进行压缩存储。如果是的话，redis会采用LZF算法进行压缩。
如果你不想消耗CPU来进行压缩的话，可以设置为关闭此功能。推荐yes.

rdbchecksum 检查完整性

在这里插入图片描述

在存储快照后，还可以让redis使用CRC64算法来进行数据校验，
但是这样做会增加大约10%的性能消耗，如果希望获取到最大的性能提升，可以关闭此功能
推荐yes.

rdb的备份

先通过config get dir 查询rdb文件的目录
将*.rdb的文件拷贝到别的地方
rdb的恢复
关闭Redis
先把备份的文件拷贝到工作目录下 cp dump2.rdb dump.rdb
启动Redis, 备份数据会直接加载

优势

适合大规模的数据恢复
对数据完整性和一致性要求不高更适合使用
节省磁盘空间
恢复速度快
在这里插入图片描述

劣势

Fork的时候，内存中的数据被克隆了一份，大致2倍的膨胀性需要考虑

虽然Redis在fork时使用了写时拷贝技术,但是如果数据庞大时还是比较消耗性能。
在备份周期在一定间隔时间做一次备份，所以如果Redis意外down掉的话，就会丢失最后一次快照后的所有修改。

.如何停止

动态停止RDB：redis-cli config set save “”#save后给空值，表示禁用保存策略

小总结

在这里插入图片描述

bug_tan90
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis 数据类型与持久化
weixin_42248522的博客
01-20 512
list 底层是链表 set底层是HashTable
SpringBoot 之RedisTemplate
const_
07-22 308
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> spring: redis: host: localhost port: 6379 timeout: 1000 配置 RedisTempl
Spring RedisTemplate操作-通道操作（10）
weixin_34029680的博客
06-08 473
2019独角兽企业重金招聘Python工程师标准>>> ...
StringRedisTemplate 的 FlushAll
weixin_63951495的博客
11-22 38
FlushAll
RedisTemplate-redis-优雅玩法
05-21
如何优雅的使用Redis呢？来回实体，能智能序列化，完全不手动添加代码，优雅的一批，demo已经写好，拿出show吧
数据采集从入门到放弃
12-29
本文将深入探讨“数据采集从入门到放弃”的过程，重点关注Python语言在爬虫开发中的应用。 首先，让我们了解什么是爬虫。爬虫是一种自动遍历网络、抓取网页信息的程序。它模拟人类用户的行为，通过HTTP或HTTPS协议...
Redis学习资料的完整笔记
最新发布
03-25
- **查询键的剩余过期时间**：`TTL keyname`返回键的剩余过期时间（秒），已过期则返回-2，永久有效则返回-1。 - **获取所有键**：`KEYS *`显示当前数据库的所有键名，注意此命令在生产环境中可能会导致性能问题。 -...
redis集群方法大全
12-18
### Redis集群方法详解 #### 一、概述 Redis是一款广泛使用的开源内存数据结构存储系统，可用于数据库、缓存和消息中间件等多种场景。随着业务规模的不断扩大，单一Redis实例往往难以满足高性能、高可用性的需求，...
redis常用命令，redis配置文件，redis持久化，redis事务，redis主从复制，jedis的使用
01-21
Redis 入门详解 Redis 是一种开源、基于内存的数据结构存储系统，可以用作数据库、消息队列、缓存层等。下面是对 Redis 的常用命令、配置文件、持久化、事务、主从复制、Jedis 使用的详细讲解。 Redis 常用命令 ...
使用StringRedisTemplate删除当前redis库中所有键值对
热门推荐
北落南山
01-24 1万+
Set&lt;String&gt; keys = redisTemplate.keys("*"); redisTemplate.delete(keys);
redis的flushall命令
后台开发
09-02 5882
redis的flushall命令用来清空redis所有的库，我们平时本地调试redis时都是直接flushall，但到生产环境要注意了，其他的库有可能有生产数据，你要清空redis数据，只能清空你对应的那个库的，默认redis在0号数据库。 使用flushdb清空当前redis所在库数据。 ...
如何在web项目中添加redis缓存
qq_15106407的博客
08-17 6736
redis 是什么？这个应该是你做一下工作的前提，不明白的可以百科一下。如果你大概明白了redis的工作原理。那么请继续往下看： 一。首先你需要明白，为什么要在你的项目中使用redis缓存？ 现在很多应用程序要存储结构简单更新频繁的数据，在我看来，字典表里的数据就是存储结构简单且更新频繁的数据，因此，需要读取字典表里的数据时，可以考虑使用redis了。 这只是其中之一的例子。 二。如何
深入理解Spring Redis的使用 (二)、RedisTemplate事务支持、序列化
goxohu的专栏
10-31 4439
1.RedisTemplate的使用 这个类作为一个模版类，提供了很多快速使用redis的api，而不需要自己来维护连接，事务。 最初的时候，我创建的BaseRedisDao是继承自这个类的。继承的好处是我的每个Dao中，都可以自由的控制序列化器，自由的控制自己是否需要事务，这个先不需要了解，跟着我目前的这种配置方法来即可。   template提供了一系列的operation,比如v
RedisTemplate 概述 与 操作 Redis 5 种数据类型、事务
蚩尤后裔-汪茂雄
01-03 1万+
目录 RedisTemplate 概述 与 redis 配置 RedisTemplate 使用演示 字符串(String) 列表(List) 哈希(Hash) 集合(Set) 有序集合(sorted set) RedisTemplate 概述 与 redis 配置 1、Redis 是一个缓存、消息代理和功能丰富的键值存储。Spring Boot 为 Lettuce 和 Jedis...
Spring的RedisTemplate序列化相关
YangzaiLeHeHe的博客
12-11 256
redis 序列化： StringRedisTemplate默认采用的是String的序列化策略，保存的key和value都是采用此策略序列化保存的。StringRedisSerializer RedisTemplate默认采用的是JDK的序列化策略，保存的key和value都是采用此策略序列化保存的。JdkSerializationRedisSerializer @Resource p...
Springboot整合redis从安装到FLUSHALL
weixin_34121282的博客
10-17 223
语言: java+kotlin windows下安装redis 参考 https://www.cnblogs.com/jaign/articles/7920588.html 安装redis可视化工具 Redis Desktop Manager 参考 https://www.cnblogs.com/zheting/p/7670154.html 依赖 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值