rabbitMQ基础篇

最新推荐文章于 2024-11-06 19:45:51 发布
最新推荐文章于 2024-11-06 19:45:51 发布
阅读量113 收藏
点赞数
分类专栏： rabbitmq 文章标签： rabbitmq

先介绍所须要包：          

         

<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>4.0.2</version>
</dependency>
<dependency>
         <groupId>org.slf4j</groupId>
        <artifactId>slf4j-nop</artifactId>
         <version>1.7.2</version>
     </dependency>

<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>
0：让我们来创建一个公共的工具类（少写点代码）
public class ConnectionUtils {
    public  static Connection getConnection() throws IOException, TimeoutException {
        ConnectionFactory factory=new ConnectionFactory();
        factory.setHost("212.129.148.99");  //根据自己的ip地址修改
        factory.setPort(5672);
        factory.setVirtualHost("/ncc");  //根据自己设置的配置修改
        factory.setUsername("ncc");      //根据自己设置的配置修改
        factory.setPassword("123456789");//根据自己设置的配置修改
        Connection   connection = factory.newConnection();
        return connection;
    }
   
}

下面所有的模式都是用生产者（发送消息）和消费者（接受并处理消息）的模式进行演示

1：简单队列


//生产者
public class send {
    private static final String Queue_Name="Test_simple_queue";
    public  static void main(String args[]) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(Queue_Name,false,false,false,null);
        String msg="123";
        channel.basicPublish("",Queue_Name,null,msg.getBytes());
        channel.close();
        connection.close();
    }
}

//消费者
//新的api
//o1简单队列
public class newRecv {
    private static final String Queue_Name="Test_simple_queue";
    public  static void main(String args[]) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();//创建连接
        Channel channel = connection.createChannel();           //获取通道

        DefaultConsumer consumer=new DefaultConsumer(channel){ //创建consumer并读取数据
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
             String msg=new String(body,"utf-8");
             System.out.println(msg);
            }
        };

       channel.basicConsume(Queue_Name,true,consumer);    //监听队列


    }}

2：轮询分发

//生产者
public class send {
    private static String QUEUE_Name="work_queue";

    public static void main(String args[]) throws IOException, TimeoutException, IOException, TimeoutException, InterruptedException {
        Connection connection = ConnectionUtils.getConnection();//创建连接
        Channel channel = connection.createChannel();           //获取通道
       
        channel.queueDeclare(QUEUE_Name,false,false,false,null);//声明一个队列
        for(int i=0;i<50;i++){
            String msg="hello"+i;
            channel.basicPublish("",QUEUE_Name,null,msg.getBytes());  //发送消息
            Thread.sleep(i*20);
            System.out.println(msg);
        }
        channel.close();
        connection.close();
    }
}

//消费者1
public class recv1 {
    private static String QUEUE_Name="work_queue";
    public  static void main(String args[]) throws IOException, TimeoutException, IOException {
        Connection connection = ConnectionUtils.getConnection();//创建连接
        Channel channel = connection.createChannel();           //获取通道

        channel.queueDeclare(QUEUE_Name,false,false,false,null);   //声明队列
        Consumer consumer=new DefaultConsumer(channel){                         //创建消费者并接受数据
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg=new String(body,"utf-8");
                System.out.println(msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        };
        channel.basicConsume(QUEUE_Name,true,consumer);                       //监听队列  //true表示自动应答
    }
}


//消费者2

public class recv2 {
    private static String QUEUE_Name="work_queue";

    public  static void main(String args[]) throws IOException, TimeoutException, IOException {
        Connection connection = ConnectionUtils.getConnection();//创建连接
        Channel channel = connection.createChannel();           //获取通道

        channel.queueDeclare(QUEUE_Name,false,false,false,null);   //声明队列
        Consumer consumer=new DefaultConsumer(channel){                         //创建消费者并接受数据
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg=new String(body,"utf-8");
                System.out.println(msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        };
        channel.basicConsume(QUEUE_Name,true,consumer);                       //监听队列
    }
}

3：公平分发

//生产者
/*
公平分发也叫能者多劳
只需修改工作队列的一些代码即可实现
生产者
1，设置每个消费者同一时间内最多能处理几个消息
        int pretechCount=1;
        channel.basicQos(pretechCount);//使得每个Consumer在同一个时间点最多处理1个Message（就是消费者在返回消息给生产者之前，他不会给消费者再次分配消息）
消费者
1，消费者也要设置确认机制channel.basicQos(pretechCount);
2，设置消费者的ack手动回执处理完成消息
  channel.basicAck(envelope.getDeliveryTag(),false);      ///手动回执消息//
3，关闭自动应答模式
 channel.basicConsume(QUEUE_Name,ack,consumer);                       //监听队列  //true表示自动应答
 */
public class send {

    private static String Queue_Name="fair_dispatch";

    public  static void main(String args[]) throws IOException, TimeoutException, IOException, TimeoutException, InterruptedException {
        Connection connection = getConnection();//创建连接
        Channel channel = connection.createChannel();//获取通道

        channel.queueDeclare(Queue_Name,false,false,false,null);

        int pretechCount=1;
        channel.basicQos(pretechCount);//使得每个Consumer在同一个时间点最多处理1个Message

        for(int i=0;i<50;i++){
            String msg="hello"+i;
            channel.basicPublish("",Queue_Name,null,msg.getBytes());  //发送消息
            Thread.sleep(i*20);
            System.out.println(msg);
        }
        channel.close();
        connection.close();
    } }


//消费者1
public class recv1 {
    private static String QUEUE_Name="fair_dispatch";
    public  static void main(String args[]) throws IOException, TimeoutException, IOException {
        Connection connection = ConnectionUtils.getConnection();//创建连接
        Channel channel = connection.createChannel();           //获取通道

        channel.queueDeclare(QUEUE_Name,false,false,false,null);   //声明队列

        channel.basicQos(1);      //保证每次之分发一个//

        Consumer consumer=new DefaultConsumer(channel){                         //创建消费者并接受数据
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg=new String(body,"utf-8");
                System.out.println(msg);
                try {
                    Thread.sleep(1000);
                    channel.basicAck(envelope.getDeliveryTag(),false);      ///手动回执消息//
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        };
        //需要关闭自动应答//
        Boolean ack=false;
        channel.basicConsume(QUEUE_Name,ack,consumer);                       //监听队列  //true表示自动应答
    }
}


//消费者2
public class recv2 {
    private static String QUEUE_Name="fair_dispatch";

    public  static void main(String args[]) throws IOException, TimeoutException, IOException {
        Connection connection = ConnectionUtils.getConnection();//创建连接
        Channel channel = connection.createChannel();           //获取通道

        Boolean durable=false;
        channel.queueDeclare(QUEUE_Name,durable,false,false,null);   //声明队列   在声明队列的时候后面的durable就是持久化工具当设为true是就可以持久化数据
        channel.basicQos(1);      //保证每次之分发一个//
        Consumer consumer=new DefaultConsumer(channel){                         //创建消费者并接受数据
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg=new String(body,"utf-8");
                System.out.println(msg);
                try {
                    Thread.sleep(2000);
                    channel.basicAck(envelope.getDeliveryTag(),false);      ///手动回执消息//
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        };
        //需要关闭自动应答//
        Boolean ack=false;
        channel.basicConsume(QUEUE_Name,ack,consumer);                       //监听队列
    }
}

 
4：路由模式


//生产者
/*
   路由模式：
       1：声明交换机  指定路由键
       2：routingKey;设置路由键
       3：发送消息;在发送消息里设置routingKey
 */
public class send {
    private static String Exchange_Nmae="exchange_direct";

    public  static void main(String args[]) throws IOException, TimeoutException, InterruptedException {
        Connection connection = getConnection();
        Channel channel= connection.createChannel();

       channel.exchangeDeclare(Exchange_Nmae,"direct");
       String routingKey="info";

        for (int i = 0; i < 10; i++)
        {
            String message = "this is user registe message" + i;
            System.out.println("[send]：" + message);
            //发送消息
            channel.basicPublish(Exchange_Nmae, routingKey, null, message.getBytes("utf-8"));
            Thread.sleep(5 * i);
        }

        channel.close();
        connection.close();

    }
}


//消费者1
public class recv1 {
    private static String Queue_Name="queue_1";
    private static String Exchange_Name="exchange_direct";

    //psvm,快捷键
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(Queue_Name, false, false, false, null);
        //
        channel.basicQos(1);
        channel.exchangeDeclare(Exchange_Name, "direct");//交换机声明
        channel.queueBind(Queue_Name, Exchange_Name, "error");//这里确定路由器的路由模式

        Consumer consumer = new DefaultConsumer(channel) {                         //创建消费者并接受数据
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "utf-8");
                System.out.println(msg);
                try {
                    Thread.sleep(2000);
                    channel.basicAck(envelope.getDeliveryTag(), false);      ///手动回执消息//
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        };
        //需要关闭自动应答//
        Boolean ack=false;
        channel.basicConsume(Queue_Name,ack,consumer);                       //监听队列

    }
}

//消费者2

public class recv2 {
    private static String Queue_Name="queue_2";
    private static String Exchange_Name="exchange_direct";

    //psvm,快捷键
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(Queue_Name, false, false, false, null);
        //
        channel.basicQos(1);
        channel.exchangeDeclare(Exchange_Name, "direct");//交换机声明
        channel.queueBind(Queue_Name, Exchange_Name, "info");//这里确定路由器的路由模式

        Consumer consumer = new DefaultConsumer(channel) {                         //创建消费者并接受数据
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "utf-8");
                System.out.println(msg);
                try {
                    Thread.sleep(2000);
                    channel.basicAck(envelope.getDeliveryTag(), false);      ///手动回执消息//
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        };
        //需要关闭自动应答//
        Boolean ack=false;
        channel.basicConsume(Queue_Name,ack,consumer);                       //监听队列

    }
}


5：订阅模式


//生产者
/*
订阅模式中只需要生命交换机

若没有运行消费者，那么数据将会丢失应为没有将交换机绑定给队列

   两步：声明交换机，发送消息
 */
public class send {
    private static String Exchange_Name="exchange_name";

    public  static void main(String args[]) throws IOException, TimeoutException, InterruptedException {
        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 registe message" + i;
            System.out.println("[send]：" + message);
            //发送消息
            channel.basicPublish(Exchange_Name, "", null, message.getBytes("utf-8"));
            Thread.sleep(5 * i);
        }

        channel.close();
        connection.close();


    }
}

//消费者1
public class recv1 {
    private static String Queue_Name="dingyue1";
    private static String Exchange_Name="exchange_name";
    public static void main(String args[]) throws IOException, TimeoutException {
        Connection connection = getConnection();//创建连接
        Channel channel = connection.createChannel();           //获取通道

        //声明交换机
        channel.exchangeDeclare(Exchange_Name,"fanout");
        //声明队列
        channel.queueDeclare(Queue_Name,false,false,false,null);
        //绑定队列
        channel.queueBind(Queue_Name,Exchange_Name,"");

        Consumer consumer=new DefaultConsumer(channel){                         //创建消费者并接受数据
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg=new String(body,"utf-8");
                System.out.println(msg);
                try {
                    Thread.sleep(2000);
                    channel.basicAck(envelope.getDeliveryTag(),false);      ///手动回执消息//
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        };
        //需要关闭自动应答//
        Boolean ack=false;
        channel.basicConsume(Queue_Name,ack,consumer);                       //监听队列
    }
}


//消费者2
public class recv2 {
    private static String Queue_Name="dingyue2";
    private static String Exchange_Name="exchange_name";
    public static void main(String args[]) throws IOException, TimeoutException {
        Connection connection = getConnection();//创建连接
        Channel channel = connection.createChannel();           //获取通道

        channel.exchangeDeclare(Exchange_Name,"fanout");
        //声明队列
        channel.queueDeclare(Queue_Name,false,false,false,null);
        //绑定队列
        channel.queueBind(Queue_Name,Exchange_Name,"");
        Consumer consumer=new DefaultConsumer(channel){                         //创建消费者并接受数据
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg=new String(body,"utf-8");
                System.out.println(msg);
                try {
                    Thread.sleep(2000);
                    channel.basicAck(envelope.getDeliveryTag(),false);      ///手动回执消息//
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        };
        //需要关闭自动应答//
        Boolean ack=false;
        channel.basicConsume(Queue_Name,ack,consumer);                       //监听队列
    }
}

6：主题模式
//生产者
/*
    1:声明交换机：路由键为topic
    2：发送消息:第二个信息为自己填充的通配符"good.add"
 */
public class send {
    private static String Exchange_name="Exchange_Name01";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Connection connection= ConnectionUtils.getConnection();
        Channel channel=connection.createChannel();

        //声明路由器
        channel.exchangeDeclare(Exchange_name,"topic");//
        for (int i = 0; i < 10; i++)
        {
            String message = "this is user registe message" + i;
            System.out.println("[send]：" + message);
            //发送消息
            channel.basicPublish(Exchange_name, "good.add", null, message.getBytes("utf-8"));///
            Thread.sleep(5 * i);
        }

        channel.close();
        connection.close();

    }
}


//消费者1
/*
   使用通配符   good.*
 */
public class recv1 {
    private static String Exchange_Name="Exchange_Name01";
    private static String Queue_Name="queue01";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection= ConnectionUtils.getConnection();
        Channel channel=connection.createChannel();

        //声明交换机
        channel.exchangeDeclare(Exchange_Name,"topic");///
        //声明队列
        channel.queueDeclare(Queue_Name,false,false,false,null);
        //绑定队列
        channel.queueBind(Queue_Name,Exchange_Name,"good.*");//
        channel.basicQos(1);

        Consumer consumer=new DefaultConsumer(channel){                         //创建消费者并接受数据
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg=new String(body,"utf-8");
                System.out.println(msg);
                try {
                    Thread.sleep(2000);
                    channel.basicAck(envelope.getDeliveryTag(),false);      ///手动回执消息//
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        };
        //需要关闭自动应答//
        Boolean ack=false;
        channel.basicConsume(Queue_Name,ack,consumer);                       //监听队列
    }


}

//消费者2
/*
 使用通配符接受数据  *.add
 */
public class recv2 {
    private static String Exchange_Name="Exchange_Name01";
    private static String Queue_Name="queue02";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection= ConnectionUtils.getConnection();
        Channel channel=connection.createChannel();

        //声明交换机
        channel.exchangeDeclare(Exchange_Name,"topic");
        //声明队列
        channel.queueDeclare(Queue_Name,false,false,false,null);
        //绑定队列
        channel.queueBind(Queue_Name,Exchange_Name,"*.add");
        channel.basicQos(1);

        Consumer consumer=new DefaultConsumer(channel){                         //创建消费者并接受数据
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg=new String(body,"utf-8");
                System.out.println(msg);
                try {
                    Thread.sleep(2000);
                    channel.basicAck(envelope.getDeliveryTag(),false);      ///手动回执消息//
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        };
        //需要关闭自动应答//
        Boolean ack=false;
        channel.basicConsume(Queue_Name,ack,consumer);                       //监听队列
    }


}

 

恭喜你入了门

余情淡漠
关注
专栏目录
中间件RabbitMQ之运维篇
02-24
RabbitMQ的rabbitMQ是一个在AMQP协议标准基础上完整的，可服用的企业消息系统。他遵循MozilaPublicLicense开源协议。采用Erlang实现的工业级的消息队列(MQ)服务器。AMQP(高级消息队列协议)是一个异步消息传递所使用...
rabbitmq-server
12-31
在本篇文章中，我们将深入探讨RabbitMQ的核心概念、功能以及如何在不同的操作系统上安装和配置RabbitMQ Server。 标题"rabbitmq-server"指的是RabbitMQ的服务器端，它是整个RabbitMQ系统的核心，负责接收、存储和...
linux中rabbitmq安装包
09-07
本篇文章将详细讲解如何在Linux上安装RabbitMQ，包括必要的依赖软件Erlang和RabbitMQ服务器的安装步骤。 首先，Erlang是RabbitMQ的基础，因为RabbitMQ是用Erlang编程语言编写的。Erlang是一种并发性能出色的编程...
rabbitMQ课件.zip
10-26
**RabbitMQ基础** RabbitMQ是一个开源的消息队列系统，基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中实现可靠的消息传递。它允许应用程序通过发送消息进行异步通信，从而提高系统的可...
RabbitMq学习笔记1
08-03
**RabbitMQ基础概念与安装** RabbitMQ是一款开源的消息队列系统，它遵循Advanced Message Queuing Protocol (AMQP)标准，用Erlang语言开发，适用于分布式系统中的异步任务处理、解耦以及负载均衡。在本篇学习笔记中...
rabbitMQ
最新发布
2302_80490510的博客
11-06 972
d \可以看到在安装命令中有两个映射的端口：- 15672：RabbitMQ提供的管理控制台的端口- 5672：RabbitMQ的消息发送处理接口1 交换机发消息的时候必须绑定相应的队列2 绑定了的队列都能收到交换机发送的消息模拟WorkQueue，实现一个队列绑定多个消费者基本思路如下:1.在RabbitMQ的控制台创建一个队列，名为work.queue2.在publisher服务中定义测试方法，在1秒内产生50条消息，发送到work.queue。
【RabbitMQ】01-RabbitMQ
Infinity的博客
11-03 425
MQ可以有更好的并发性。
RabbitMQ 七种工作模式介绍
chaodddddd的博客
11-02 1691
RabbitMQ 共提供了7种⼯作模式供我们进⾏消息传递,接下来一一介绍它的实现与目的
RabbitMQ 的集群
java1234的博客
11-02 786
RabbitMQ 的集群
win11安装最新rabbitmq
qq_20376949的博客
11-03 288
因为RabbitMQ默认启动的，当键入启动命令时，会出现如下情况，直接关闭RabbitMQ服务，再启动就行。RabbitMQ后台访问地址 http://localhost:15672。身份运行cmd，，执行下面命令启动RabbitMQ。关闭后再重新执行启动命令即可。默认的用户名：guest。默认的密码为：guest。关闭RabbitMQ。
springboot框架使用RabbitMQ举例代码
Json的知识梦工厂
11-01 481
以前分享过一个理论有兴趣的小伙伴可以看下。第一步：引入依赖 可以不指定版本。不多说 还是直接上代码。
【RabbitMQ】03-交换机
Infinity的博客
11-05 442
广播。生产者向exchange发消息消费者监听exchange绑定的队列即可。
【RabbitMQ】02-Spring AMQP
Infinity的博客
11-03 335
【代码】【RabbitMQ】02-Spring AMQP。
rabbitMq怎么保证消息不丢失？消费者没有接收到消息怎么处理
勤修方可得道成仙
11-06 183
保证消息不丢失以及处理消费者未接收到消息的情况可以通过以下几个方法
RabbitMQ 管理平台（控制中心）的介绍
hooheha的博客
11-06 308
Rabbit 管理平台（控制中心）简单介绍和操作
使用 RabbitMQ 有什么好处？
java1234的博客
11-03 921
使用 RabbitMQ 有什么好处？
【MQ】RabbitMQ、RocketMQ、kafka特性对比
不想睡觉的橘子君的博客
11-06 347
本篇文章导入了写在本地的一个md文档，仅对rabbitmq、rocketmq、kafka做一些简单的对比，方便记忆。
RabbitMQ几大应用问题
2301_77053417的博客
10-30 1013
所以幂等性保障，就是可以正确的处理相同重复的消息。当消费者收到消息后，就可以根据唯一ID判断该消息是否已经被消费过，如果已经被消费观过，则可以不做处理，进而可以避免重复消费的问题。消费者消费完成后没有及时对消息进行确认，或者确认丢失，MQ可能认为消息未发送成功进而重试，也会导致消息处理的顺序性问题。当存在多个消费者的时候，消息被哪一个消费者消费是不确定的，也可能并行处理，就会导致消息的顺序性无法保证。消息积压，指的是在消息队列中，待处理的消息数量超过了消费者的处理能力，导致消息在队列中不断堆积的现象。
RabbitMQ自动发送消息工具(自动化测试RabbitMQ)
a342874650的专栏
11-06 682
该软件是一个基于 C# 的 RabbitMQ 消息生产程序。它集成了 RabbitMQ 连接配置、消息自动生成配置以及日志记录功能，能够按照预设的时间间隔和总次数自动发送 RabbitMQ 消息。消息内容支持多种随机生成类型，包括日期、序列号、Mac 地址、整数和浮点数。此外，程序还提供了实时日志查看功能，以便用户能够实时监控消息的生产情况。
RabbitMQ基础教程-中文版
"这篇教程是RabbitMQ开发的中文翻译，主要针对初学者，涵盖了从基础的`HelloWorld`示例到更高级的概念，如工作队列、发布/订阅、路由以及Topics类型交换机和远程过程调用(RPC)。教程以Java语言为例，讲解如何使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值