RabbitMQ —— 工作模式

最新推荐文章于 2024-01-24 11:16:35 发布
最新推荐文章于 2024-01-24 11:16:35 发布
阅读量4.6k 收藏 2
点赞数
分类专栏： # RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Woo_home/article/details/106355966
版权

前文

消息中间件 —— 简介

RabbitMQ —— 介绍

RabbitMQ —— 下载、安装

文章目录

发布订阅

在这里插入图片描述
1、一个生产者将消息发送给交换机
2、与交换机绑定的有多个队列，每个消费者监听自己的队列
3、生产者将消息发送给交换机，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接受到消息
4、如果消息发给没有绑定队列的交换机上消息将丢失

消息生产者

package com.java.rabbitmq.public_subject;

import com.java.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.*;

/**
 * @author Woo_home
 * @create 2020/5/26 14:45
 */

public class Producer_Public {

    private final static String EXCHANGE_NAME = "test_exchange_fanout";

    public static void main(String[] args)
    {
        try
        {
            // 获取连接
            Connection connection = ConnectionUtils.getConnection();
            // 创建通道
            Channel channel = connection.createChannel();
            // 声明交换机（分发:发布/订阅模式）
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
            // 发送消息
            for (int i = 0; i < 10; i++)
            {
                String message = "this is user message" + i;
                System.out.println("[send]：" + message);
                //发送消息
                channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("utf-8"));
                Thread.sleep(5 * i);
            }
            channel.close();
            connection.close();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

消息消费者

package com.java.rabbitmq.public_subject;

import com.java.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.*;
import java.io.IOException;

/**
 * @author Woo_home
 * @create 2020/5/26 15:12
 */

public class Consumer_subscribe_email {

    //交换机名称
    private final static String EXCHANGE_NAME = "test_exchange_fanout";

    //队列名称
    private static final String QUEUE_NAME    = "test_queue_email";

    public static void main(String[] args) throws Exception {
        try
        {

            // 获取连接
            Connection connection = ConnectionUtils.getConnection();
            // 创建通道
            final Channel channel = connection.createChannel();
            // 声明交换机（分发:发布/订阅模式）
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
            // 声明队列
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            // 将队列绑定到交换机
            channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
            // 保证一次只分发一个
            int prefetchCount = 1;
            channel.basicQos(prefetchCount);
            
			System.out.println("监听消息-----------------------------");

            // 定义消费者
            DefaultConsumer consumer = new DefaultConsumer(channel) {

                // 当消息到达时执行回调方法
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    String message = new String(body, "utf-8");
                    System.out.println("[email] Receive message：" + message);
                    try {
                        // 消费者休息2s处理业务
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        System.out.println("[1] done");
                        // 手动应答
                        channel.basicAck(envelope.getDeliveryTag(), false);
                    }
                }
            };
            // 设置手动应答
            boolean autoAck = false;
            // 监听队列
            channel.basicConsume(QUEUE_NAME, autoAck, consumer);
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

package com.java.rabbitmq.public_subject;

import com.java.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.*;
import java.io.IOException;

/**
 * @author Woo_home
 * @create 2020/5/26 15:12
 */

public class Consumer_subscribe_sms {

    //交换机名称
    private final static String EXCHANGE_NAME = "test_exchange_fanout";

    //队列名称
    private static final String QUEUE_NAME    = "test_queue_phone";

    public static void main(String[] args) throws Exception {
        try
        {

            // 获取连接
            Connection connection = ConnectionUtils.getConnection();
            // 创建通道
            final Channel channel = connection.createChannel();
            // 声明交换机（分发:发布/订阅模式）
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
            // 声明队列
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            // 将队列绑定到交换机
            channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
            // 保证一次只分发一个
            int prefetchCount = 1;
            channel.basicQos(prefetchCount);
		
		    System.out.println("监听消息-----------------------------");


            // 定义消费者
            DefaultConsumer consumer = new DefaultConsumer(channel) {

                // 当消息到达时执行回调方法
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    String message = new String(body, "utf-8");
                    System.out.println("[phone] Receive message：" + message);
                    try
                    {
                        // 消费者休息2s处理业务
                        Thread.sleep(1000);
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                    finally
                    {
                        System.out.println("[2] done");
                        // 手动应答
                        channel.basicAck(envelope.getDeliveryTag(), false);
                    }
                }
            };
            // 设置手动应答
            boolean autoAck = false;
            // 监听队列
            channel.basicConsume(QUEUE_NAME, autoAck, consumer);
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

测试

先启动两个消费端
在这里插入图片描述
然后启动生产者端
在这里插入图片描述
这样两个消费端都可以接收到消息了
在这里插入图片描述
在这里插入图片描述

Routing 模式

在这里插入图片描述
路由模式：

1、一个交换机绑定多个队列，每个队列设置 routingKey，并且一个队列可以设置多个 routingKey
2、每个消费者监听自己的队列
3、生产者将消息发给交换机，发送消息时需要指定 routingKey 的值，交换机来判断该 routingKey 的值和哪个队列的 routingKey 相等，如果相等则将消息转发给该队列

简单来说就是只发给指定的队列，其它的队列都收不到

Routing 模式和发布订阅模式的区别？

只不过是使用的交换机不同

  • 发布 / 订阅模式 Publish / Subscribe 使用交换机类型为 fanout
  • 路由模式 Routing 使用交换机类型为 direct
  • 通配符模式 Topics 使用交换机类型为 topic

消息生产者

package com.java.rabbitmq.direct;

import com.java.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

/**
 * @author Woo_home
 * @create 2020/5/27 11:01
 */

public class TestProducer {

    private static final String QUEUE_NAME = "direct_queue";

    public static void main(String[] args) throws Exception {

        // 创建连接
        Connection connection = ConnectionUtils.getConnection();

        // 创建通道
        Channel channel = connection.createChannel();

        for (int i = 0; i < 100; i++) {
            String message = "direct 消息 " + i;
            // 发送消息到队列中
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes("utf-8"));
            System.out.println("发送消息：" + message);
        }
        // 关闭通道
        channel.close();
        connection.close();
    }
}

消息消费者

这里有两个消费者

package com.java.rabbitmq.direct;

import com.java.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author Woo_home
 * @create 2020/5/27 11:02
 */

public class TestConsumer1 {

    private static final String QUEUE_NAME = "direct_queue";

    public static void main(String[] args) throws Exception {

        // 创建连接
        Connection connection = ConnectionUtils.getConnection();

        // 创建通道
        Channel channel = connection.createChannel();

        // 声明要关注的队列
        channel.queueDeclare(QUEUE_NAME, false, false, true, null);

        System.out.println("[1]队列正在监听消息：");

        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println("[1] 接收到消息：" + message);
            }
        };

        // 自动回复队列应答，RabbitMQ 中的消息确认机制
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

其实两个消费者的代码是基本一样的

package com.java.rabbitmq.direct;

import com.java.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author Woo_home
 * @create 2020/5/27 11:02
 */

public class TestConsumer2 {

    private static final String QUEUE_NAME = "direct_queue";

    public static void main(String[] args) throws Exception {

        // 创建连接
        Connection connection = ConnectionUtils.getConnection();

        // 创建通道
        Channel channel = connection.createChannel();

        // 声明要关注的队列
        channel.queueDeclare(QUEUE_NAME, false, false, true, null);

        System.out.println("[2]队列正在监听消息：");

        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println("[2] 接收到消息：" + message);
            }
        };

        // 自动回复队列应答，RabbitMQ 中的消息确认机制
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

测试

先启动两个消费者
在这里插入图片描述
在这里插入图片描述
然后再启动生产者（图有点长，只截取一部分图）
在这里插入图片描述
然后在观察两个消费者的输出
在这里插入图片描述
在这里插入图片描述

Topic 模式

在这里插入图片描述

Topic 与 Routing 的区别？

Topic 和 Routing 的基本原理相同，即：生产者将消息发送给交换机，交换机根据 routingKey 将消息转发给与 routingKey 匹配的队列

不同之处是：routingKey 的匹配方式，Routing 模式是相等匹配，而 Topic 模式是统配符匹配

符号#：匹配一个或者多个词，比如 inform.# 可以匹配 inform.sms、inform.email、inform.email.sms

符号：只能匹配一个词，比如 inform.* 可以匹配 inform.sms、inform.email

消息生产者

package com.java.rabbitmq.topic;

import com.java.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

/**
 * @author Woo_home
 * @create 2020/5/27 13:07
 */

public class TopicProducer {

    // 队列名称
    public static final String EXCHANGE_NAME = "topics_exchange";

    public static void main(String[] args) throws Exception {

        // 创建连接
        Connection connection = ConnectionUtils.getConnection();

        // 创建通道
        Channel channel = connection.createChannel();

        // 声明交换机以及类型
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);

        String[] routing_keys = new String[]{"abc.news", "abc.weather", "efg.news", "efg.weather"};
        String[] messages = new String[]{"abc新闻", "abc天气", "efg新闻", "efg天气"};

        for (int i = 0; i < routing_keys.length; i++) {
            String routingKey = routing_keys[i];
            String message = messages[i];
            channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes());
            System.out.printf("发送到路由的消息是 ：%s，内容是：%s%n ", routingKey, message);
        }

        // 关闭通道
        channel.close();
        connection.close();
    }
}

消息消费者

模拟两个消费者，代码基本是一样的，只是接收的消息有所不同

package com.java.rabbitmq.topic;

import com.java.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @author Woo_home
 * @create 2020/5/27 13:33
 */

public class TestConsumerABC {

    // 队列名称
    public static final String EXCHANGE_NAME = "topics_exchange";

    public static void main(String[] args) throws Exception {

        // 创建连接
        Connection connection = ConnectionUtils.getConnection();

        // 创建通道
        Channel channel = connection.createChannel();

        // 声明交换机以及类型
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);

        // 获取一个临时队列
        String queueName = channel.queueDeclare().getQueue();

        // 接收 abc 消息
        channel.queueBind(queueName, EXCHANGE_NAME, "abc.*");

        System.out.println("[1]队列等待接收消息...");

        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println("[1]队列接收到消息 " + message);
            }
        };
        // 自动应答机制
        channel.basicConsume(queueName, true, consumer);
    }
}

package com.java.rabbitmq.topic;

import com.java.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.*;
import java.io.IOException;

/**
 * @author Woo_home
 * @create 2020/5/27 13:37
 */

public class TestConsumerEFG {

    // 队列名称
    public static final String EXCHANGE_NAME = "topics_exchange";

    public static void main(String[] args) throws Exception {

        // 创建连接
        Connection connection = ConnectionUtils.getConnection();

        // 创建通道
        Channel channel = connection.createChannel();

        // 声明交换机以及类型
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);

        // 获取一个临时队列
        String queueName = channel.queueDeclare().getQueue();

        // 接收 efg 信息
        channel.queueBind(queueName, EXCHANGE_NAME, "*.news");

        System.out.println("[2]队列等待接收消息...");

        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println("[2]接收到消息 " + message);
            }
        };

        // 自动应答机制
        channel.basicConsume(queueName, true, consumer);
    }
}

测试

先启动两个消费者
在这里插入图片描述
在这里插入图片描述
然后再启动消息生产者，可以发现，生产者已经将信息发送出去
在这里插入图片描述
消息消费者 1 接受到的信息
在这里插入图片描述
消息消费者 2 接受到的信息
在这里插入图片描述

相关 MQ 文章阅读

ActiveMQ 下载、安装

ActiveMQ —— Java 连接 ActiveMQ（点对点）

ActiveMQ —— Java 连接 ActiveMQ（发布订阅 Topic）

ActiveMQ —— Broker

ActiveMQ —— Spring 整合 ActiveMQ

SpringBoot 整合 ActiveMQ

Woo_home
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
RabbitMQ——01
xiaowanziddd的博客
08-20 619
AMQP，即(高级消息队列协议)，是一个网络协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。2006年，AMQP规范发布。类比HTTP。2007年，Rabbit 技术公司基于AMQP标准开发的RabbitMQ 1.0发布。RabbitMQ采用Erlang 语言开发。Erlang 语言由Ericson设计，专门为开发高并发和分布式系统的一种语言，在电信领域使用广泛。
RabbitMQ基本概念和使用
01-30
一个Consumer进行消息的正常处理，另一个Consumer复制对消息进行日志记录，只要在程序中指定两个Consumer所监听的queue以相同的方式绑定到同一个exchange即可，剩下的消息分发工作由RabbitMQ完成。首先通过一个非常...
Condition 的简单使用
Woo_home的博客
03-20 1840
文章目录什么是 Condition？Condition 的定义Condition 中的方法await()await(long time,TimeUnit unit)awaitNanos(long nanosTimeout)awaitUninterruptibly()awaitUntil(Date deadline)signal()signalAll()举例：（Condition 的使用） 什么是 ...
NIO —— 三大组件
Woo_home的博客
05-16 7529
文章目录NIO 三大核心原理示意图缓冲区（Buffer）基本 介绍Buffer 类及其子类Buffer 的读写切换通道（Channel）基本介绍选择器（Selector）基本介绍特点注意事项write(ByteBuffer src)举例（写入数据）：read(ByteBuffer dst)举例（读取数据）举例（拷贝文件）ByteBuffertransferFrom关于 Buffer 和 Chann...
RabbitMq——工作队列工作模式
weixin_50616848的博客
03-10 638
在默认路由下，当有多个工作线程时，可以共同完成这个工作队列，他们的模式有两种：轮训分发和不公平分发。 1.轮训分发：依次按照顺序一条一条分发到每个工作线程处理，一个工作线处理完，下一个工作线程才能进行。 案例：一个生产者发消息，两个消费者消费消息，采用轮训分发模式 （1）开启linux上rabbitmq的服务和关闭linux防火墙 /sbin/service rabbitmq-server start systemctl stop firewalld (2)写一个连接工厂，创建信道的工具类
RabbitMQ——轮询工作队列
qq_53344479的博客
02-28 1980
生产者投放生产消息，由多个消费者消费消息。 既然是轮询，那就是消费者轮着获取消息，生产者生产多条消息，消费者依次去获取消息，每次获取一条。 代码与简单队列差距不大，区别在于消费者由一个变为多个，生产者一次性生产多条消息。 通过结果不难看出，确实是每个消费者依次获取消息，这也是默认的工作队列。 存在的问题，这种工作队列太过于理想化，并不适合实际的开发，我们难以保证每个消费者消费信息的速度相同，难免有的快有的慢，因此我们可以去人为的设置一些参数，尽量达到公平。于是也就有了公平工作...
RabbitMQ——六种工作模式实战（.net core）
Star_Inori的博客
12-08 292
RabbitMQ六种工作模式实战(.net core)
RabbitMQ——六种工作模式、SpringBoot整合RabbitMQ
Guizy
01-23 1432
目录 一、RabbitMQ入门程序 二、Work queues 工作模式 三、Publish / Subscribe 发布/订阅模式 四、Routing 路由模式 五、Topics 六、Header 七、RPC 八、Spring Data Elasticsearch 一、RabbitMQ入门程序 <dependencies> <dependency> <groupId>org.springframework.boot</grou
RabbitMQ——工作队列、消息应答
风间琉璃の博客
03-05 338
Work Queues 工作队列（任务队列）主要思想是避免立即执行资源密集型任务，而不得不等待它完成，相反我们安排任务在之后执行。我们把任务封装为消息并将其发送到队列。在后台运行的工作进程将弹出任务并最终执行作业。当有多个工作线程时，这些工作线程将一起处理这些任务。 其实就是生产者发送大量的消息，发送到队列之后，由多个消费者(工作线程)来处理消息，并且每个消息只能被处理一次。 1. 轮询分发消息 多个工作线程按照次序每来一个消息执行一次。 1.2 抽取工具类 直接通过信息获取信道 /** * @
RabbitMQ——交换机
weixin_73730094的博客
01-24 1083
在 RabbitMQ 中，交换机主要用来将生产者生产出来的消息，传送到对应的频道中，即交换机是一个消息传送的媒介，其英文被称为 exchange。交换机在 RabbitMQ 中起着承上启下的作用。在实际应用中我们只需要定义好 Exchange 的路由策略，而生产者则不需要关心消息会发送到哪个 Queue 或被哪些 Consumer 消费。
RabbitMQ —— 介绍
热门推荐
Woo_home的博客
06-04 1万+
文章目录介绍什么是 AMQP？JMS 是什么？应用场景市场上还有哪些 MQ？为什么使用 RabbitMQ？快速入门RabbitMQ 的工作原理消息发布接收流程发送消息接收消息 介绍     MQ 全称为 Message Queue，即消息队列，RabbitMQ 是由 Erlang 语言开发，基于 AMQP（Advanced Message Queue Protocol ，高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛，RabbitMQ 官方地址
RabbitMQ —— Round-robin 轮询分发
Woo_home的博客
06-04 5174
前文 消息中间件 —— 简介 RabbitMQ —— 介绍 RabbitMQ —— 下载、安装 RabbitMQ —— 工作模式 RabbitMQ —— 简单队列 文章目录前文简单队列的不足WorkerQueue（工作队列）连接配置生产者消费者测试总结 简单队列的不足 耦合性高，生产者一一对应消费者（如果想有多个消费者消费队列中的消息就不 OK 了） 队列名变更的话，这时候得同时变更（耦合性高） WorkerQueue（工作队列） 什么是工作队列的呢？就是一个生产者对应多个消费者 P ： 表示生产者 中
RabbitMQ —— 下载、安装
Woo_home的博客
06-04 4782
文章目录下载RabbitMQErlang安装ErlangRabbitMQ运行添加 Adminvirtual hosts 管理测试 下载 RabbitMQ 这里下载的是 Windows 版本的 RabbitMQ ，下载地址 https://www.rabbitmq.com/install-windows.html Erlang 在使用 RabbitMQ 之前需要先安装 RabbitMQ 的运行环境 Erlang，就好比使用 ActiveMQ 的时候需要依赖 Java 环境，Erlang 下载地址 下载对应
SpringBoot 整合 RabbitMQ
Woo_home的博客
06-04 4765
文章目录direct 模式消息生产者创建 Maven 工程添加 Maven 依赖application.properties自定义 Exchange（交换机）Controller主启动类消息消费者创建 Maven 工程添加 Maven 依赖application.properties自定义配置类Service测试topic （通配符模式）消息生产者配置 BeanController消息消费者配置 Bean业务类测试 direct 模式 消息生产者 创建 Maven 工程 关于怎么创建 Maven 工程这里
RabbitMQ —— 简单队列
Woo_home的博客
06-04 4595
前文 消息中间件 —— 简介 RabbitMQ —— 介绍 RabbitMQ —— 下载、安装 RabbitMQ —— 工作模式 文章目录前文创建 Maven 工程添加 Maven 依赖连接配置生产者测试消费者新的 API（DefaultConsumer） 创建 Maven 工程 添加 Maven 依赖 <dependencies> <dependency> <groupId>com.rabbitmq</groupId> <art
1719378276792.jpg
06-26
1719378276792.jpg
054ssm-jsp-mysql旅游景点线路网站.zip（可运行源码+数据库文件+文档）
最新发布
06-26
本系统采用了jsp技术，将所有业务模块采用以浏览器交互的模式，选择MySQL作为系统的数据库，开发工具选择eclipse来进行系统的设计。基本实现了旅游网站应有的主要功能模块，本系统有管理员、和会员，管理员权限如下：个人中心、会员管理、景点分类管理、旅游景点管理、旅游线路管理、系统管理；会员权限如下：个人中心、旅游景点管理、旅游线路管理、我的收藏管理等操作。 对系统进行测试后，改善了程序逻辑和代码。同时确保系统中所有的程序都能正常运行，所有的功能都能操作，并且该系统有很好的操作体验，实现了对于景点和会员双赢。 关键词：旅游网站；jsp;Mysql；
rabbitmq 通配符工作模式
09-02
RabbitMQ的通配符工作模式是指使用Topic Exchange来实现路由选择的一种模式。在这种模式下，队列可以绑定到一个模式上，使用符号"#"匹配一个或多个词，而符号"*"匹配不多不少一个词。例如，"audit.#"能够匹配到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值