MQ分布式事物

最新推荐文章于 2024-10-07 12:05:31 发布
最新推荐文章于 2024-10-07 12:05:31 发布
阅读量393 收藏
点赞数
分类专栏： MQ分布式事务 文章标签： 分布式 rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c704395972/article/details/119566811
版权

文章目录

前言

分布式事务就是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上。以上是百度百科的解释，简单的说，就是一次大的操作由不同的小操作组成，这些小的操作分布在不同的服务器上，且属于不同的应用，分布式事务需要保证这些小操作要么全部成功，要么全部失败。本质上来说，分布式事务就是为了保证不同数据库的数据一致性。

直接上代码基于MQ实现的分布式事务形成完整闭环

一、前期介绍


订单表
CREATE TABLE `order_test` (
  `id` int(20) NOT NULL AUTO_INCREMENT,
  `user_id` int(20) NOT NULL COMMENT '用户id',
  `goods` varchar(255) NOT NULL COMMENT '商品名称',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=23 DEFAULT CHARSET=utf8mb4 COMMENT='订单表';

订单镜像表
CREATE TABLE `order_mq_backup` (
  `id` int(20) NOT NULL AUTO_INCREMENT,
  `order_id` int(20) NOT NULL COMMENT '订单id',
  `user_id` int(20) NOT NULL COMMENT '用户id',
  `goods` varchar(255) NOT NULL COMMENT '商品名称',
  `type` int(20) NOT NULL DEFAULT '0' COMMENT '状态[0：未确认 1：已确认]',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=22 DEFAULT CHARSET=utf8mb4 COMMENT='订单镜像表';

这里订单表和镜像表是在一个数据库的 配送中心表在其他的库，模拟分布式嘛!!!

-----------------------------------------------------------------------------

配送中心表
CREATE TABLE `delivery` (
  `id` int(20) NOT NULL AUTO_INCREMENT,
  `order_id` int(20) NOT NULL COMMENT '订单id',
  `goods` varchar(255) NOT NULL COMMENT '商品名称',
  `shipper_id` int(20) NOT NULL COMMENT '配送人_id',
  `type` int(20) NOT NULL DEFAULT '0' COMMENT '状态 [0：禁用 1：正常]',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=20 DEFAULT CHARSET=utf8mb4 COMMENT='配送中心表';

二、项目准备

这里是创建队列和交换机以及绑定关系，可以写在消费者模块，我这里两边都写了

package com.example.distributedproducer.config;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;

@Configuration
public class ReliableConfig {


    /**
     * 创建死信队列交换机
     * @return
     */
    @Bean
    public FanoutExchange deadExchange(){
        return new FanoutExchange("dead_order_exchange",true,false);
    }


    /**
     * 创建死信队列
     * @return
     */
    @Bean
    public Queue deadQueue(){
        return new Queue("dead_order_queue",true,false,false);
    }

    /**
     * 死信队列绑定关系
     * @param deadQueue
     * @return
     */
    @Bean
    public Binding deadBinding(@Qualifier(value = "deadQueue")Queue deadQueue){
        return BindingBuilder.bind(deadQueue).to(deadExchange());
    }


    /**
     * 可靠交换机
     *
     * @return
     */
    @Bean
    public DirectExchange reliableExchange() {
        return new DirectExchange("reliable_order_exchange", true, false);
    }

    /**
     * 可靠消息队列
     * @return
     */
    @Bean
    public Queue reliableQueue() {
        //绑定死信队列
        HashMap<String, Object> map = new HashMap<>();
        map.put("x-dead-letter-exchange","dead_order_exchange");
        return new Queue("reliable_order_queue", true, false, false,map);
    }
    
    /**
     * 绑定关系
     * @param reliableQueue
     * @return
     */
    @Bean
    public Binding reliableBinding(@Qualifier(value = "reliableQueue")Queue reliableQueue){
        return BindingBuilder.bind(reliableQueue).to(reliableExchange()).with("");
    }

}

springboot.rabbitmq.publisher-confirm 新版本已被弃用，现在使用 spring.rabbitmq.publisher-confirm-type = correlated 实现相同效果

server:
  port: 8074
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql://ip:3306/distributed-demo?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
  rabbitmq:
    username: admin
    password: admin
    virtual-host: /
    host: ip
    port: 5672
   # 开启发布确认机制，默认NONE是禁用发布确认模式 
   # correlated 发布消息成功到交换器后会触发回调方法
    publisher-confirm-type: correlated

三、可靠生产者


package com.example.distributedproducer.service;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.example.distributedproducer.entity.OrderMqBackup;
import com.example.distributedproducer.entity.OrderTest;
import com.example.distributedproducer.mapper.OrderMapper;
import com.example.distributedproducer.mapper.OrderMqBackupMapper;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

@Service
public class ProducerService {


    @Resource
    private OrderMapper orderMapper;

    @Resource
    private OrderMqBackupMapper orderMqBackupMapper;

    @Resource
    private RabbitTemplate rabbitTemplate;


    /**
     * 可靠消息回调
     * PostConstruct 该注解 用来修饰 一个非静态的 void 方法，修饰的方法在加载 servlet的时候运行
     * 并且只会被服务器执行一次，在构造函数之后执行，init()方法之前执行
     */
    @PostConstruct
    public void reliableCallback(){
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {

            @Override
            public void confirm(CorrelationData correlationData, boolean b, String s) {
                //回执成功 收到回调改镜像表状态
                if (b){
                    Integer orderId = Integer.valueOf(correlationData.getId());
                    OrderMqBackup one = orderMqBackupMapper.selectOne(new LambdaQueryWrapper<OrderMqBackup>()
                            .eq(OrderMqBackup::getOrderId, orderId));
                   if (one != null) orderMqBackupMapper.updateById(one.setType(1));
                    return;
                }
                //TODO 回执失败，执行重发策略
            }
        });

    }


    /**
     * 模拟创建订单
     * 使用的是镜像模式，order表是订单表，order_mq_backup 就相当于备份表，
     * 但是这张表里面比订单表多一个 type状态（0：未确认 1：已确认） 用来保证消息的可靠性
     */
    public void save(){
        OrderTest orderTest = new OrderTest().setUserId(107).setGoods("泡面");
        orderMapper.insert(orderTest);

        OrderMqBackup backup = new OrderMqBackup();
        BeanUtils.copyProperties(orderTest,backup);
        backup.setOrderId(orderTest.getId());
        orderMqBackupMapper.insert(backup);

        String s = JSONObject.toJSONString(orderTest);

        //给MQ发送消息
        rabbitTemplate.convertAndSend("reliable_order_exchange","",
                s,new CorrelationData(orderTest.getId().toString()));
    }

}

重发策略，我这里是task，也可以采取其他的处理方式，根据个人业务情况

package com.example.distributedproducer.task;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.example.distributedproducer.entity.OrderMqBackup;
import com.example.distributedproducer.mapper.OrderMqBackupMapper;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.List;

/**
 * @author ChuYao
 * @version 1.0
 * @date 2021/8/10 10:07
 * @description: TODO MQ订单重发，这里将镜像表没有确认状态的订单重新发给队列
 */
@Component
public class ReliableTask {

    @Resource
    private RabbitTemplate rabbitTemplate;
    @Resource
    private OrderMqBackupMapper orderMqBackupMapper;

	//生产环境不建议开每分钟发一次哦 
    @Scheduled(cron = "0 */1 * * * ?")
    private void resendMessage(){
        try{
            List<OrderMqBackup> backupList = orderMqBackupMapper.selectList(new LambdaQueryWrapper<OrderMqBackup>().eq(OrderMqBackup::getType, 0));
            backupList.forEach(item ->{
                String s = JSONObject.toJSONString(item);
                rabbitTemplate.convertAndSend("reliable_order_exchange","",s,new CorrelationData(item.getOrderId().toString()));
            });
        }catch (Exception e){

        }
    }
}

到这，消息可靠生产者形成闭环

四、可靠生消费者

消费者配置文件，消费者的创建交换机，队列，绑定关系都一致，贴过来就行这里就不写了。

server:
  port: 8074
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql://ip:3306/distributed-demo?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
  rabbitmq:
    username: admin
    password: admin
    virtual-host: /
    host: ip
    port: 5672
    listener:
      simple:
      #开启手动 ack手动管理 MQ消息删除，转移，默认 none 自动应答消息删除
        acknowledge-mode: manual

可靠消费 监听可靠生产者队列

package com.example.distributedconsumer.service;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.example.distributedconsumer.entity.Delivery;
import com.example.distributedconsumer.entity.OrderTest;
import com.example.distributedconsumer.mapper.DeliveryMapper;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.BeanUtils;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.IOException;


@Component
@RabbitListener(queues = "reliable_order_queue")
public class ReliableConsumer {

    @Resource
    private DeliveryMapper deliveryMapper;
    
    /**
     * 解决消息重试方案
     * 1.控制重发次数 + 死信队列
     * 2.try + catch + 手动 ack
     * 3.try + catch + 手动 ack + 死信队列 + 人工预警 [推荐！]
     */
    @RabbitHandler
    public void reliableMessage(String msg, Channel channel, CorrelationData correlationData,
                                @Header(AmqpHeaders.DELIVERY_TAG) long tag){
        try{
            //获取队列中的消息
            OrderTest orderTest = JSONObject.parseObject(msg, OrderTest.class);
            System.out.println("消费信息------->"+msg);
            Delivery one = deliveryMapper.selectOne(new LambdaQueryWrapper<Delivery>().eq(Delivery::getOrderId, orderTest.getId()));

			//TDOD 幂等性 我这里orderId 使用数据库主键解决重复消费问题，也可以上个锁来处理
            if (one != null){
                deliveryMapper.updateById(one.setType(1));
            }else {
                Delivery delivery = new Delivery();
                BeanUtils.copyProperties(orderTest,delivery);
                delivery.setOrderId(orderTest.getId()).setShipperId(999).setType(1);
                deliveryMapper.insert(delivery);
            }

			 //制造异常模拟消费失败
            System.out.println(1/0);
            //消息正常消费
            channel.basicAck(tag,false);
        }catch (Exception e){
            try {
                /**
                 * param1 消息的 tag
                 * param2 多条处理
                 * param3 是否重发
                 * TODO try + catch 模式 param3 不建议开启重发,会造成死循环
                 * 正常情况 Nack 后消息会被移除, 这里使用死信队列来转移消息
                 */
                System.out.println("消费失败");
                channel.basicNack(tag,false,false);
            } catch (IOException ioException) {
                ioException.printStackTrace();
            }

        }
    }
}

可靠队列消费失败，消息转移到死信队列，监听死信队列

** 死信的监听基本和可靠队列消费一致，同时也要处理幂等性问题，唯一的区别就是死信队列也消费失败的话采取的处理机制不同（这里就要预警加其他备份手段）**

package com.example.distributedconsumer.service;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.example.distributedconsumer.entity.Delivery;
import com.example.distributedconsumer.entity.OrderTest;
import com.example.distributedconsumer.mapper.DeliveryMapper;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.beans.BeanUtils;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.IOException;

/**
 * @author ChuYao
 * @version 1.0
 * @date 2021/8/10 9:25
 * @description: TODO
 */
@Component
@RabbitListener(queues = "dead_order_queue")
public class DeadConsumer {

    @Resource
    private DeliveryMapper deliveryMapper;

    @RabbitHandler
    public void readMessage(String msg, Channel channel, CorrelationData correlationData,
                            @Header(AmqpHeaders.DELIVERY_TAG) long tag){

        try {
            //获取消息
            OrderTest orderTest = JSONObject.parseObject(msg, OrderTest.class);
            System.out.println("消费信息------->"+msg);
            Delivery one = deliveryMapper.selectOne(new LambdaQueryWrapper<Delivery>().eq(Delivery::getOrderId, orderTest.getId()));
            //TDOD 幂等性 我这里orderId 使用数据库主键解决重复消费问题，也可以上个锁来处理
            if (one != null){
                deliveryMapper.updateById(one.setType(1));
            }else {
                Delivery delivery = new Delivery();
                BeanUtils.copyProperties(orderTest,delivery);
                delivery.setOrderId(orderTest.getId()).setShipperId(999).setType(1);
                deliveryMapper.insert(delivery);
            }
            System.out.println(1/0);

            //消息正常消费
            channel.basicAck(tag,false);
        }catch (Exception e){
            try {
                /**
                 * 死信队列都无法正常消费
                 * 开启预警 加本地备份
                 */
                System.out.println("发短信给开发人员预警");
                channel.basicNack(tag,false,false);
            } catch (IOException ioException) {
                ioException.printStackTrace();
            }
        }
    }
}

这一套操作搞完，基于MQ的分布式事务形成闭环

总结

提示：基于MQ的分布式事务比较繁琐，需要注意的是如果MQ一旦挂掉那就全崩了！实战都是采用镜像集群模式。大家有兴趣的话可以去搭个集群玩玩，配置文件改成集群配置

红豆冰棒先生
关注
专栏目录
分布式事务——纯MQ实现
xiaoyaGrace的博客
04-13 378
一、MQ实现分布式事务，最简单的原理框架：借助MQ的消息可靠传递，实现业务间解耦、事务强一致1、>> 生产者发送消息做可靠性检查，确保消息真正投递出去；2、>> 消费者做幂等，确保业务没有重复执行；3、>> 消费者做异常重试，反复出错时需要捕捉异常并记录，以便手工干预；二、场景实践：场景以支付宝转账到余额宝为例，在支付宝已经扣款成功的情况下，余额宝一定收到转账&...
Rocket MQ分布式事务解决方式
m0_63551359的博客
10-27 3410
分布式事务 一、分布式事物概念 分布式事务就是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上 简单的来说，就是一次大的操作由不同的小操作组成，这些小的操作那么全部成功，要么全部失败。分布式事务就是为了保证不同的数据库的数据一致性. 二、前言 目前分布式事务是还没有彻底的解决的难题，在考虑到实现方案前。需要考虑到当前项目是不是真的需要追求强的一致性。参考BASE理论，在分布式系统中，允许不同的服务节点在同步过程中存在延时，但可以经过一段时间修复，
基于MQ的分布式事务
weixin_42065915的博客
12-12 220
分布式事务 分布式事务实现的五个步骤 出现异常一般会重试几次由消费者记录重试次数,重试次数过多内容格式错误等情况,通过线上预警机制通知运维人员; 如果消息发送一直不成功就可以让人工进行干预 ...
RabbitMQ事务模块
最新发布
weixin_72953218的博客
10-07 1876
​​​​​​​RabbitMQ是基于AMQP协议实现的,该协议实现了事务机制，要么全部成功，要么全部失败，1.不采用事务:正常来说，这种情况发一个，然后一个出错了，，第一条消息成功，这样就会第二条消息会不成功2.采用事务还需要下面这两个一个创建Manager，还要加上@Transactional,事务，要么都成功，要么都失败。
基于MQ实现分布式事务
ZHUSHANGLIN的博客
07-22 894
基于MQ实现分布式事务
四种基于MQ的分布式事务解决方案
BASK2312的博客
12-09 5167
在微服务的时代，分布式事务是绕不开的话题，尽管在大多数场景下，我们并不需要使用分布式事务，但是 不需要使用 不代表 可以不会使用，万一哪天真需要用到了呢？分布式事务是一个比较大的话题，今天我们来看看基于MQ的分布式事务解决方案。在实际开发中，为了简化分布式事务，我们和其他服务交互，经常会采用MQ的方式，我们先来看下如果采用MQ的方式和其他服务进行交互，应该怎么做。
MQ如何解决分布式事务？
m0_54187478的博客
03-05 830
MQ（消息队列）解决分布式事务的关键在于利用消息的可靠性和最终一致性来保证分布式系统中不同服务间事务的一致性。和。
分布式事物.txt
05-22
微服务分布式事物视频详解，TCC，BASE，MQ，2PC，最终一致
分布式事务+远程调用服务异常事务回滚
ss123mlk的博客
06-22 3551
同一个商品在很多仓库都有库存 库存-锁定是剩余的商品数量 下了一个订单 里面有多件商品 要分别找每个商品是否还有库存没有 在一个订单下的多个商品只要有一个是没有库存的 整个订单就要回滚 写Sql语句的时候 先不用找到具体的字段关系 可以先用数字来代替 然后在数据库哪里好使了就焕 抛异常来判断返回的值是什么 而不是用 if else来判断 分布式事务 异常回滚在同一个服务器中很简单 如果在一个逻辑下包含本服务自身事务异常回滚+远程服务器里的事务异常回滚 就涉及到分布式异常 在分布式事务中 A1 .
某果学院 微服务分布式事物解决方案
07-16
3、常用的分布式事务解决方案介绍 4、消息发送一致性（可靠消息的前提保障） 5、消息发送一致性的异常流程处理 6、常规MQ队列消息的处理流程和特点 7、消息重复发送问题及业务接口的幂等性设计 8、可靠消息最终一致...
MQ事务
kongkong的专栏
10-05 1597
  MQ（事务消息） 举个例子，Bob向Smith转账，那我们到底是先发送消息，还是先执行扣款操作？ 好像都可能会出问题。如果先发消息，扣款操作失败，那么Smith的账户里面会多出一笔钱。反过来，如果先执行扣款操作，后发送消息，那有可能扣款成功了但是消息没发出去，Smith收不到钱。除了上面介绍的通过异常捕获和回滚的方式外，还有没有其他的思路呢？ 下面以阿里巴巴的RocketMQ中间件为例...
分布式事务
2301_76947341的博客
05-22 744
通过数据库事务的特性来控制。依赖于数据库。基于关系型数据库的事务，称为本地事务。单体系统拆分成若干个服务，即微服务的由来。服务与服务之间需要通过网络远程协作。例如增加用户送积分。需要用户服务和积分服务。例如张三给李四转账。张三的账户和李四的账户属于两个银行。
记录基于RabbitMQ消息队列的分布式事务解决方案 - MQ分布式消息中间件实战，seata以外的分布式事务实现方式
qq_50896685的博客
09-27 732
通用性强拓展性强方案成熟基于消息中间件，只适合异步场景消息处理会有延迟，需要业务上能够容忍尽量避免分布式事务;尽量将非核心事务做成异步;保证事务的ACID四大原则；实现分布式事务有很多种方式，看大家习惯用哪一种，使用消息中间件是一种很基本也很可靠的方式。
利用MQ的分布式事务实现思想
oatlmy
11-13 810
本篇我们来学习基于MQ的分布式事务的实现思想
MQ实现分布式事务
大鸡腿的博客
01-04 1320
目录 detail 项目地址： 总结 分布式事务不像单体应用一样使用@transactional进行事务管理即可 分布式事务不能保证强一致性，只能保证最终一致性，我使用mq来实现不同系统之间的通讯，但是mq也会出现错误的时候，还有不方便保存mq消息，所以再做一个消息服务来储存、定时发送消息，失败消费消息时进行重发消息，记录死亡消息等等。 这个项目让a系统减少一，b系统也减少一，acti...
mq消息队列解决分布式事务
高飞
03-31 1199
一、RabbitMQ解决分布式事务思路： 案例： 经典案例，以目前流行点外卖的案例，用户下单后，调用订单服务，让后订单服务调用派单系统通知送外卖人员送单，这时候订单系统与派单系统采用MQ异步通讯。 二、RabbitMQ解决分布式事务原理：采用最终一致性原理。 需要保证以下三要素 1、确认生产者一定要将数据投递到MQ服务器中（采用MQ消息确认机制） 2、MQ消费者消息能够正确消费消息，采用...
RabbitMQ——解决分布式事务问题，RabbitMQ的重要作用之一！！！通过可靠生产和可靠消费来完美解决！
我热爱学习，也乐于分享。无论是科技前沿的洞见，还是生活中的小技巧，我都会在这里与你分享。我相信，知识就是力量，而分享则能让这份力量得到更好的传递。
12-14 1617
分布式事务是指涉及多个独立的计算机系统（也称为节点或参与者）之间的事务处理。在分布式系统中，每个节点可能各自拥有自己的数据存储和事务管理机制。分布式事务的目标是保证在跨多个节点执行的一系列操作可以以一致和可靠的方式执行和提交，即使在面对故障或并发操作时也能保持数据的完整性和一致性。实现分布式事务可以采用两阶段提交（Two-Phase Commit）协议或三阶段提交（Three-Phase Commit）协议等机制。这些协议通过协调参与者之间的状态和决策来实现分布式事务的一致性。
RocketMQ学习笔记：分布式事务
sinat_38393872的博客
03-26 900
这是本人学习的总结，主要学习资料如下马士兵教育。
mq 解决 分布式事务 流程
qq_33454058的博客
09-18 267
基于RabbitMQ消息队列的分布式事务解决方案 ： https://www.imooc.com/article/295377 RocketMQ使用及分布式事务解决思路 https://blog.csdn.net/d729332647/article/details/79324767
微服务架构中MQ分布式事务技术解析
资源摘要信息: "分布式锁与信号量微服务架构中基于MQ的分布式事务解决方案.zip" 在当今的IT行业中，分布式系统和微服务架构变得越来越流行。随着业务需求的不断增长，微服务架构能够支持更高的可扩展性、可维护性和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值