rabbitmq的几种模式以及springboot整合rabbitmq

最新推荐文章于 2024-07-02 21:07:07 发布
最新推荐文章于 2024-07-02 21:07:07 发布
阅读量238 收藏
点赞数
文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TYTvampire/article/details/116407345
版权

1. 正文

1. 工作者模式: 
2. 发布订阅模式
3. 路由模式
4. topic主体模式。
5. Springboot整合rabbitMQ

2. 工作者模式:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UBKVcTy9-1620143869110)(assets\1618900602190.png)]

特点:
    1. 一个生产者
    2. 由多个消费。
    3. 统一个队列。
    4. 这些消费者之间存在竞争关系。

用处:
    比如批量处理上. rabbitMQ里面积压了大量的消息。

生产者

package com.tyt.worker;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Producer {
    public static void main(String[] args) throws Exception{
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
//        设置主机地址
        connectionFactory.setHost("192.168.31.145");
//        创建 连接对象Connection
        Connection connection = connectionFactory.newConnection();

//创建信道
        Channel channel = connection.createChannel();
//        创建队列
        /**
         * String queue, 队列的名称
         * boolean durable,是否该队列持久性，rabbitMQ服务重启后该存放是否存在
         * boolean exclusive,是否该队列独占
         * boolean autoDelete,是否自动删除，如果长时间没有发生消息则自动删除
         * Map<String, Object> arguments 额外参数
         */
        channel.queueDeclare("qy129_worker", true, false, false, null);
        /**发生消息
         * String exchange, 交换机的名称，如果没有则使用“” ，它会自动默认
         * String routingKey, 路由key 如果没有交换机的绑定，使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前不加
         * byte[] body  消息的内容
         *
         */
        for (int i = 0; i <10 ; i++) {
            String msg = "Hello,rabbitmq,fuck,李浩辰"+i;
            channel.basicPublish("","qy129_worker",null,msg.getBytes());
        }
        channel.close();
        connection.close();

    }
}

消费者01：

package com.tyt.worker;

import com.rabbitmq.client.*;

import java.io.IOException;

public class ConsumerTest01 {
    public static void main(String[] args) throws Exception{
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
//        设置主机地址
        connectionFactory.setHost("192.168.31.145");
//        创建 连接对象Connection
        Connection connection = connectionFactory.newConnection();
//创建信道
        Channel channel = connection.createChannel();
        //消费消息（接收消息）
        /**
         * String queue, 队列
         * boolean autoAck, 是否自动确认
         * Consumer callback 回调方法，当队列中存在信息后，会自动触发回调函数
         */
        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("c1消息的内容:"+new String(body));
            }
        };
        channel.basicConsume("qy129_worker",true,callback);
    }
}

消费者02:

package com.tyt.worker;

import com.rabbitmq.client.*;

import java.io.IOException;

public class ConsumerTest02 {
    public static void main(String[] args) throws Exception{
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
//        设置主机地址
        connectionFactory.setHost("192.168.31.145");
//        创建 连接对象Connection
        Connection connection = connectionFactory.newConnection();
//创建信道
        Channel channel = connection.createChannel();
        //消费消息（接收消息）
        /**
         * String queue, 队列
         * boolean autoAck, 是否自动确认
         * Consumer callback 回调方法，当队列中存在信息后，会自动触发回调函数
         */
        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("c2消息的内容:"+new String(body));
            }
        };
        channel.basicConsume("qy129_worker",true,callback);
    }
}

4. 发布订阅模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1P5edUw9-1620143869115)(assets\1618901774090.png)]

1. 特点:
    1.一个生产者
    2.多个消费者
    3.多个队列。
    4.交换机 转发消息。

生产者:

package com.tyt.fanout;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Producer {
    public static void main(String[] args) throws Exception{
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
//        设置主机地址
        connectionFactory.setHost("192.168.31.145");
//        创建 连接对象Connection
        Connection connection = connectionFactory.newConnection();

//创建信道
        Channel channel = connection.createChannel();
//        创建队列
        /**
         * String queue, 队列的名称
         * boolean durable,是否该队列持久性，rabbitMQ服务重启后该存放是否存在
         * boolean exclusive,是否该队列独占
         * boolean autoDelete,是否自动删除，如果长时间没有发生消息则自动删除
         * Map<String, Object> arguments 额外参数
         */
        channel.queueDeclare("qy129_fanout01", true, false, false, null);
        channel.queueDeclare("qy129_fanout02", true, false, false, null);
        /**
         * 创建交换机
         * String exchange, 交换机名称
         * BuiltinExchangeType type,交换机类型
         * boolean durable 是否持久化
         */
        channel.exchangeDeclare("qy129_exchange_fanout", BuiltinExchangeType.FANOUT, true);
        /**
         * 连接交换机和队列
         * String queue,队列名
         * String exchange,交换机名
         * String routingKey 路由器key
         */
        channel.queueBind("qy129_fanout01", "qy129_exchange_fanout", "");
        channel.queueBind("qy129_fanout02", "qy129_exchange_fanout", "");
        /**发生消息
         * String exchange, 交换机的名称，如果没有则使用“” ，它会自动默认
         * String routingKey, 路由key 如果没有交换机的绑定，使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前不加
         * byte[] body  消息的内容
         *
         */
        for (int i = 0; i <10 ; i++) {
            String msg = "Hello,rabbitmq,fuck,李浩辰"+i;
            channel.basicPublish("qy129_exchange_fanout","",null,msg.getBytes());
        }
        channel.close();
        connection.close();

    }
}

消费者:

package com.tyt.fanout;

import com.rabbitmq.client.*;

import java.io.IOException;

public class ConsumerTest01 {
    public static void main(String[] args) throws Exception{
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
//        设置主机地址
        connectionFactory.setHost("192.168.31.145");
//        创建 连接对象Connection
        Connection connection = connectionFactory.newConnection();
//创建信道
        Channel channel = connection.createChannel();
        //消费消息（接收消息）
        /**
         * String queue, 队列
         * boolean autoAck, 是否自动确认
         * Consumer callback 回调方法，当队列中存在信息后，会自动触发回调函数
         */
        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("c1消息的内容:"+new String(body));
            }
        };
        channel.basicConsume("qy129_fanout01",true,callback);
    }
}

5.路由模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UJVvyyji-1620143869121)(assets\1618904756029.png)]

特点:
    1.一个生产者
    2.多个消费者
    3.多个队列。
    4.交换机 转发消息。
    5.routekey:路由key 只要routekey匹配的消息可以到达对应队列。

生产者：

package com.tyt.direct;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Producer {
    public static void main(String[] args) throws Exception{
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
//        设置主机地址
        connectionFactory.setHost("192.168.31.145");
//        创建 连接对象Connection
        Connection connection = connectionFactory.newConnection();

//创建信道
        Channel channel = connection.createChannel();
//        创建队列
        /**
         * String queue, 队列的名称
         * boolean durable,是否该队列持久性，rabbitMQ服务重启后该存放是否存在
         * boolean exclusive,是否该队列独占
         * boolean autoDelete,是否自动删除，如果长时间没有发生消息则自动删除
         * Map<String, Object> arguments 额外参数
         */
        channel.queueDeclare("qy129_direct01", true, false, false, null);
        channel.queueDeclare("qy129_direct02", true, false, false, null);
        /**
         * 创建交换机
         * String exchange, 交换机名称
         * BuiltinExchangeType type,交换机类型
         * boolean durable 是否持久化
         */
        channel.exchangeDeclare("qy129_exchange_direct", BuiltinExchangeType.DIRECT, true);
        /**
         * 连接交换机和队列
         * String queue,队列名
         * String exchange,交换机名
         * String routingKey 路由器key
         */
        channel.queueBind("qy129_direct01", "qy129_exchange_direct", "error");

        channel.queueBind("qy129_direct02", "qy129_exchange_direct", "error");
        channel.queueBind("qy129_direct02", "qy129_exchange_direct", "info");
        channel.queueBind("qy129_direct02", "qy129_exchange_direct", "warning");
        /**发生消息
         * String exchange, 交换机的名称，如果没有则使用“” ，它会自动默认
         * String routingKey, 路由key 如果没有交换机的绑定，使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前不加
         * byte[] body  消息的内容
         *
         */
        for (int i = 0; i <10 ; i++) {
            String msg = "Hello,rabbitmq,fuck,李浩辰"+i;
            channel.basicPublish("qy129_exchange_direct","info",null,msg.getBytes());
        }
        channel.close();
        connection.close();

    }
}

消费者基本没什么变化，只需要把通道换一下即可。

6. topic主体模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LSgxJfYN-1620143869126)(assets\1618905526157.png)]

1. 绑定按照通配符的模式。
     *: 统配一个单词。
     #: 统配n个单词

hello.orange.rabbit

lazy.orange

生产者

package com.tyt.topic;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class Producer {
    public static void main(String[] args) throws Exception{
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
//        设置主机地址
        connectionFactory.setHost("192.168.31.145");
//        创建 连接对象Connection
        Connection connection = connectionFactory.newConnection();

//创建信道
        Channel channel = connection.createChannel();
//        创建队列
        /**
         * String queue, 队列的名称
         * boolean durable,是否该队列持久性，rabbitMQ服务重启后该存放是否存在
         * boolean exclusive,是否该队列独占
         * boolean autoDelete,是否自动删除，如果长时间没有发生消息则自动删除
         * Map<String, Object> arguments 额外参数
         */
        channel.queueDeclare("qy129_topic01", true, false, false, null);
        channel.queueDeclare("qy129_topic02", true, false, false, null);
        /**
         * 创建交换机
         * String exchange, 交换机名称
         * BuiltinExchangeType type,交换机类型
         * boolean durable 是否持久化
         */
        channel.exchangeDeclare("qy129_exchange_topic", BuiltinExchangeType.TOPIC, true);
        /**
         * 连接交换机和队列
         * String queue,队列名
         * String exchange,交换机名
         * String routingKey 路由器key
         */
        channel.queueBind("qy129_topic01", "qy129_exchange_topic", "*.orange.*");

        channel.queueBind("qy129_topic02", "qy129_exchange_topic", "*.*.rabbit");
        channel.queueBind("qy129_topic02", "qy129_exchange_topic", "#.tyt.#");
        channel.queueBind("qy129_topic02", "qy129_exchange_topic", "lazy.#");
        /**发生消息
         * String exchange, 交换机的名称，如果没有则使用“” ，它会自动默认
         * String routingKey, 路由key 如果没有交换机的绑定，使用队列的名称
         * BasicProperties props, 消息的一些额外配置 目前不加
         * byte[] body  消息的内容
         *
         */
        for (int i = 0; i <10 ; i++) {
            String msg = "Hello,rabbitmq,fuck,李浩辰"+i;
            channel.basicPublish("qy129_exchange_topic","tyt",null,msg.getBytes());
        }
        channel.close();
        connection.close();

    }
}

7. rabbitMQ整合springboot

springboot引入了相关的依赖后，提供一个工具类RabbitTemplate.使用这个工具类可以发送消息。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-veqdrUKm-1620143869131)(assets\1618910290294.png)]

(1)父工程引入相关的依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <packaging>pom</packaging>
    <modules>
        <module>product</module>
        <module>consumer</module>
    </modules>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.tyt</groupId>
    <artifactId>springboot-rabbit-parent</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-rabbit-parent</name>
    <description>springboot整合rabbitMQ</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--rabbitMQ的依赖: 启动类加载。读取配置文件：
           springboot自动装配原理: 引用starter启动依赖时，把对应的自动装配类加载进去，该自动装配类可以读取application配置文件中
           内容。 DispatherServlet
        -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.72</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

  
</project>

(2)相应的生产者和消费的配置

server:
  port: 8080

spring:
  rabbitmq:
    host: 192.168.31.145
  datasource:
    druid:
      username: root
      password: 566666
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3308/hello

注意：（1）主机号需要填写你自己的（2）我的mysql的端口号是3308，默认是3306
（3）生产者

package com.tyt.controller;

import com.tyt.service.FruitService;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private FruitService fruitService;
    @GetMapping("hello")
    public String hello() {
        String one = fruitService.getOne(1);
        rabbitTemplate.convertAndSend("qy129_exchange_fanout", "", one);//相当于经过序列化
        return "下单成功";
    }
}

消费者监听消息

package com.tyt.listener;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ConsumerListener {
    @RabbitListener(queues = "qy129_fanout01")
    public void listener(Message msg) {
        System.out.println("出库"+msg);
    }
}
TYTvampire
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RabbitMQ五种模式
07-01
没有1个积分的私聊我哈，我给你免费 消息队列中间件（简称消息中间件）是指利用高效可靠的消息传递机制进行与平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下提供**应用解耦**(降偶)、**弹性伸缩、冗余存储、流量削峰、异步通信、数据同步等等功能**，其作为分布式系统架构中的一个重要组件，有着举足轻重的地位。 **基本模型： 消息发布者 --> 消息中间件 ---> 消息消费者** 同步调用是 A调用B后阻塞等待，此时A的后续操作是不能进行。异步调用的一种实现方式是引入MQ，A将调用信息发到消息中间件，然后B从消息中间件获取到消息内容执行。此时A不再需要等待B。 这个前提下，**就可以实现异步调用**，**冗余存储**（指可以在MQ中多存一些数据，等待B来消费，MQ可以看作是个缓冲区）、**流量削峰**（如果A的调用请求数量大于B的消费能力，则消息中间件可以通过冗余存储来缓冲，B可以按照以比较慢的速度来处理请求）等等功能。
Springboot整合RabbitMQ简单demo
01-22
本文将详细讲解如何在Spring Boot项目中整合RabbitMQ，并通过一个简单的示例来展示其实现过程。 首先，我们需要了解RabbitMQ的基本概念。RabbitMQ是一个开源的消息代理和队列服务器，遵循AMQP（Advanced Message ...
rabbit的工作模式
qq_53678217的博客
04-21 312
1. 正文 1. 工作者模式: 2. 发布订阅模式 3. 路由模式 4. topic主体模式。 5. Springboot整合rabbitMQ 2. 工作者模式: 特点: 1. 一个生产者 2. 由多个消费。 3. 统一个队列。 4. 这些消费者之间存在竞争关系。 用处: 比如批量处理上. rabbitMQ里面积压了大量的消息。 生产者 package com.ykq.work; import com.rabbitmq.client.Channel; i
SpringBoot集成RabbitMQ
最新发布
abc_138的博客
07-02 1638
RabbitMQ官方提供的Java 客户端编码相对复杂，一般生产环境下我们更多会结合Spring 来使用。而Spring 的官方刚好基于RabbitMQ 提供了这样一套消息收发的模板工具SpringAMQP。
rabbitmq 五种模式
Jornici的博客
02-05 2040
1、简单模式 2、工作队列模式 3、发布订阅模式 4、路由模式 5、topic通配符模式
RabbitMQ的五种常见模式
未来的博客
04-21 502
RabbitMQ的五种常见模式 在练习RabbitMQ之前，请确认自己的RabbitMQ已经安装并开启。 1、简单模式 从图上可以看到只有三个角色:   p 【product】: 生产者 发生消息的   红色[queue]: 队列。 存储消息的    C [consumer]: 消费者 消费消息 创建一个maven项目，创建一个消费者和一个生产者。 生产者代码： public class Product { public static void main(String[] args)
RabbitMQ的五种模式:
weixin_54386913的博客
04-22 235
简单模式 生产者 public class Product { public static void main(String[] args) throws Exception { //创建连接工厂--配置连接信息 ConnectionFactory factory =new ConnectionFactory(); factory.setHost("虚拟机id号"); //创建链接对象 Connection conne
springboot-rabbitMQ-websocket:springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
05-27
首先，Spring Boot整合RabbitMQ主要涉及以下几个步骤： 1. **添加依赖**：在项目中，我们需要引入Spring Boot的`spring-boot-starter-amqp`依赖，以启用对RabbitMQ的支持。 2. **配置RabbitMQ**：在`application....
rabbitmq-practice整合springboot的一个小练习demo
07-10
本项目“rabbitmq-practice整合springboot的一个小练习demo”就是针对这种集成进行的一次实践，旨在帮助开发者理解和掌握如何在Spring Boot应用中使用RabbitMQ。 首先，我们需要了解RabbitMQ的基本概念。RabbitMQ是...
rabbitmqdeep:这是springboot整合rabbitmq的几个消费模型
03-11
在IT行业中，消息队列（Message Queue）是一种重要的中间件技术，用于解耦应用程序和处理异步通信。...通过实践这些例子，你将更好地掌握如何利用RabbitMQ进行消息传递和处理，以及如何根据需求选择合适的消费模型。
SpringBoot使用RabbitMQ延时队列(小白必备)
08-25
在 Java 中，可以使用 Spring Boot 的 starter 项目 spring-boot-starter-amqp 来整合 RabbitMQ。 延时队列的使用场景包括： 1. 订单业务：在淘宝或者京东购买东西，用户下单后未付款则 30 分钟后取消订单。 2. ...
RabbitMQ的五种模式源码+纯手工打的代码
03-12
RabbitMQ的五种模式源码+纯手工打的代码
rabbitmq各种模式代码及说明
06-19
rabbitmq各种模式代码及说明，下载解压就能启动，集成springboot
RabbitMQ的 五种工作模型
weixin_37862824的博客
11-10 1501
总结：简单模式和工作队列模式，主要是【队列】和【消费者】的关系，一对一、一对多。订阅模式包含：【交换机】和【队列】的关系，【队列】和【消费者】的关系。队列和消费者是1对多时，那么就是采用平均的方式分给多个消费。队列里面的消息只有一个消费者会拿到。
rabbitmq的五种工作模式
qq_35345436的博客
12-07 2663
Rabbitmq常用的五种工作模式
m0_57232638的博客
07-12 555
RabbitMQ常用的五种工作模式
RabbitMQ五大模式轻松理解
风影浪子
06-13 7374
简要概括RabbitMQ工作模式：1、简单模式 HelloWorld 2、工作队列模式 Work Queue 3、发布订阅模式 Publish/subscribe 4、路由模式 Routing 5、通配符模式 Topic
rabbitmq几种工作模式_10分钟认识RabbitMQ的五种工作模式
weixin_39612720的博客
12-07 821
什么是Rabbit让我来免费帮你免费翻译翻译RabbitMQ是一个消息中间件:它接受和转发消息。你可以把它想象成一个邮局:当你把你想要寄的邮件放到一个邮箱里，你可以确定邮递员先生或女士最终会把邮件送到收件人那里。在这个类比中，RabbitMQ是一个邮箱、一个邮局和一个邮递员。RabbitMQ和邮局之间的主要区别在于它不处理纸张，而是接受、存储和转发二进制blob数据消息。五种工作模式打开...
springboot整合rabbitmq的几种模式
03-30
1. 简单模式（Simple Mode）：这是最基础的模式，生产者发送消息到队列，消费者从队列中接收消息。 2. 工作队列模式（Work Queue Mode）：也被称为任务队列模式，生产者发送任务到队列，多个消费者共同消费队列中的任务。 3. 发布/订阅模式（Publish/Subscribe Mode）：生产者将消息发布到交换机，多个消费者将队列绑定到交换机上并接收消息。 4. 路由模式（Routing Mode）：生产者将消息发布到交换机，并指定消息的路由键，消费者将队列绑定到交换机上，并指定自己关心的路由键，只有和自己关心的路由键匹配的消息才会被接收。 5. 主题模式（Topic Mode）：也被称为通配符模式，生产者将消息发布到交换机，并指定消息的主题，消费者将队列绑定到交换机上，并指定自己关心的主题，只有和自己关心的主题匹配的消息才会被接收。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值