RabbitMQ 安装和使用Demo

已于 2023-10-13 22:09:26 修改
阅读量212 收藏 2
点赞数
文章标签： rabbitmq 分布式
于 2023-10-13 13:18:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sky_MaoXiaoqi/article/details/133806839
版权

同步是阻塞

MQ：消息队列，基础数据结构中"先进先出"的数据结构。用来解决应用解耦，异步消息，流量消峰等问题。
RabbitMQ、RocketMQ、Kafka
RocketMQ 是阿里的
应用层开发使用RabbitMQ
大数据开发Kafka

MQ是不是微服务都可以用

RabbitMQ

是什么？
RabbitMQ是实现了高级消息协议（AMQP）的开源消息代理软件，是MQ的产品之一，目前最火的MQ中间件之一。用Erlang语言编写的。
依赖

配置

spring:
  rabbitmq:
    host: 121.36.5.100
    port: 5672
    username: guest
    password: guest

docker安装
执行命令，先查看是否有Docker
docker --version
在这里插入图片描述
如果想要删除：yum -y remove docker-ce

如果没有需要安装：

1.执行命令，实现Docker安装

yum install -y yum-utils

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

yum makecache fast

yum -y install docker-ce
在这里插入图片描述
在这里插入图片描述
2.验证

docker --version
在这里插入图片描述
3.启动Docker

启动：systemctl start docker

停止：systemctl stop docker

查看状态：systemctl status docker

重启：systemctl restart docker

0.安装
采⽤Docker安装RabbitMQ
0.执⾏命令
docker run -d --name rabbitmq5672 -p 15672:15672 -p 5672:5672 rabbitmq:management
在这里插入图片描述

1.查看正在运行容器
docker ps
在这里插入图片描述
2.进入容器内部
docker exec -it ae2804d96c53 /bin/bash

3.运行rabbitmq
rabbitmq-plugins enable rabbitmq_management

4.浏览器运行:
http://自己的ip:15672/
在这里插入图片描述

依赖jar包

<!-- RabbitMQ -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

实现配置：

spring:
  rabbitmq:
    host: XXXXX
    port: 5672
    username: guest
    password: guest

1.创建队列：
注意导入的包

package com.yd.rabbitmq01.config;

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration //配置 类似 beans 标签
public class RabbitMQConfig {

    //创建队列
    @Bean // IOC bean标签
    public Queue createQ1() {
        return new Queue("j2310-yd");
    }
}

在这里插入图片描述
template.convertAndSend(“”,“j2310-yd”,msg);
补充：第一个校验器，第二个队列名

2.发消息

@RestController
public class MqSendController {
    @Resource
    private RabbitTemplate template;

    @GetMapping("send1")
    public String send(String msg) {
        //发送消息
        template.convertAndSend("","j2310-yd",msg);
        return "ok";
    }
}

在这里插入图片描述

在这里插入图片描述

3.消费消息
监听器listener，监听队列中的消息变化

接收消息

@Slf4j
@Component // IOC
public class MsgListener {

    @RabbitListener(queues = "j2310-yd")
    public void hander(String msg) {
        log.info("消费者获取消息{}",msg);
    }
}

二、RubbitMq核心：

*一个单词
#任意一个

2.1消息模式-简单消息

特点：一个队列对应一个消费者，一个消息只能被消费1次
在这里插入图片描述
示例：
1.定义队列
2.发送消息—到—队列中
3.监听消息—从—队列中
代码:
package com.yd.rabbitmq01.config;

@Configuration //配置 类似 beans 标签
public class RabbitMQConfig {
    //简单消息
    @Bean // IOC bean标签
    public Queue createQ2() {
        return new Queue("yd-p2p-1");
    }
}

package com.yd.rabbitmq01.controller;

package com.yd.rabbitmq01.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author MaoXiqi
 * @organization: Lucky
 * @create 2023-10-13 12:54:02
 * @description MqSendControllerApi
 */
@RestController
public class MqSendController {
    @Resource
    private RabbitTemplate template;

    //简单消息
    @GetMapping("send2")
    public String send2(String msg) {
        //发送消息
        template.convertAndSend("","yd-p2p-1",msg);
        return "ok";
    }
}

package com.yd.rabbitmq01.listener;

package com.yd.rabbitmq01.listener;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @author MaoXiqi
 * @organization: Lucky
 * @create 2023-10-13 12:56:32
 * @description MsgListenerApi
 */
@Slf4j
@Component // IOC
public class MsgListener {
    //简单消息
    @RabbitListener(queues = "yd-p2p-1")
    public void hander2(String msg) {
        log.info("普通消息,消费者,获取消息,{}",msg);
    }
}

2.2 消息模式-Work消息

Work消息：一个队列可以有多个消费端，1个消息只能消费1次，多个消费者是按照轮询的形式轮流获取消息
可以解决：消息堆积（发的快，消费的慢）

MQ消息单表可扛1万
发送快，消费慢（要处理业务逻辑），导致消息堆积，队列先进先出，会把老的消息弄丢失。
消息堆积，解决方案：
1.加机器（成本高）
2.想办法优化消费的性能（不好搞定）
3.work消息，多来几个消费者，消费者之间什么关系？
Work消息：一个队列可以有多个消费者，1个消息只能消费1次
可以解决：消息堆积（发得快，消费的慢）

注意：对发送端没有影响。

轮训发送

补充：
1.redis解决存储上限的问题?

2.哨兵是解决什么问题？
哨兵是用来监听主库的，主库掉了，从库中选择一个上位
主从复制，主库没了，从库中选择一个
在这里插入图片描述
示例：
1.声明队列

	//Work消息
    @Bean // IOC bean标签
    public Queue createQ3() {
        return new Queue("yd-work-1");
    }

2.发送消息

//Work消息
    @GetMapping("send3")
    public String send3(String msg) {
        //发送消息 交换器,路由
        template.convertAndSend("","yd-work-1",msg);
        return "ok";
    }

在这里插入图片描述

3.监听消息

//Work消息
    @RabbitListener(queues = "yd-work-1")
    public void hander3(String msg) {
        log.info("work消息,work消费者01,获取消息,{}",msg);
    }
    //Work消息
    @RabbitListener(queues = "yd-work-1")
    public void hander4(String msg) {
        log.info("work消息,work消费者02,获取消息,{}",msg);
    }

2.3-消息模式-发布订阅

发布订阅：就是消息发送到Exchange（交换器），交换器再把消息发送到交换器绑定的队列上（绑定一个发送一个队列，绑定十个发送十个队列），1个消息可以给多个消费者（多个队列中）获取
Exchange：交换器，是RabbitMQ一个组成，可以接受消息。然后根据交换器的类型，选择对应的匹配模式，把匹配的消息转发到对应的队列中。
交换器的类型：

1.fanout：直接转发，不对消息做匹配处理
2.direct路由匹配，发送指定Routingkey（精准）匹配，发送的消息会指定，交换器绑定队列的时候也需要指定RountingKey
3.tipic路由匹配，发送消息指定 RoutingKey（模糊，支持 * #），交换器绑定队列的时候，也需要指定RoutingKey， *一个单词 #任意个单词
4.header：消息头匹配模式，发送消息的时候指定消息的请求消息头，交换器绑定队列的时候，也需要指定对应的请求消息头，any任意一个 all所有

在这里插入图片描述

示例：
1.创建队列
2.创建交换器
3.创建交换器和队列的绑定
4.发送消息
5.监听消息

package com.yd.rabbitmq01.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 消息模式-发布订阅
 * @author MaoXiqi
 * @organization: Lucky
 * @create 2023-10-13 15:22:35
 * @description FanoutConfigApi
 */
@Configuration
public class FanoutConfig {

    //1.创建队列
    @Bean
    public Queue createQfang1() {
        return new Queue("q-fanout-01");
    }

    @Bean
    public Queue createQfang2() {
        return new Queue("q-fanout-02");
    }

    //2.创建交换器
    @Bean
    public FanoutExchange createFe() {
        return new FanoutExchange("ex-fanout-yd");
    }

    //3.实现绑定
    @Bean
    public Binding createBf1(FanoutExchange fe) {
        return BindingBuilder.bind(createQfang1()).to(fe);
    }
    @Bean
    public Binding createBf2(FanoutExchange fe) {
        return BindingBuilder.bind(createQfang2()).to(fe);
    }

}

4.发送消息

package com.yd.rabbitmq01.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author MaoXiqi
 * @organization: Lucky
 * @create 2023-10-13 15:31:59
 * @description FanoutControllerApi
 */
@RestController
public class FanoutController {
    @Resource
    private RabbitTemplate template;

    /**
     * 消息模式-发布订阅
     * @param msg
     * @return
     */
    @GetMapping("fanout1")
    public String f1(String msg) {
    	// 第一个交换器,routingKey,msg
        template.convertAndSend("ex-fanout-yd","",msg);
        return "ok";
    }

    @GetMapping("direct1")
    public String d1(String msg, String type) {
        template.convertAndSend("ex-direct-yd",type,msg);
        return "ok";
    }
}

5.监听消息

package com.yd.rabbitmq01.listener;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @author MaoXiqi
 * @organization: Lucky
 * @create 2023-10-13 12:56:32
 * @description MsgListenerApi
 */
@Slf4j
@Component // IOC
public class MsgListener {
    //消息模式-发布订阅
    @RabbitListener(queues = "q-fanout-01")
    public void hander5(String msg) {
        log.info("fanout消息,01队列,消费者,获取消息01,{}",msg);
    }
    //消息模式-发布订阅
    @RabbitListener(queues = "q-fanout-02")
    public void hander6(String msg) {
        log.info("fanout消息,02队列,消费者,获取消息02,{}",msg);
    }
}

D：所代表的意思是持久化
在这里插入图片描述
补充：
交换器怎么设计的：功能单一原则，方便解耦

交换器，路由
在这里插入图片描述

2.4 消息模式-路由匹配

路由消息：消息被发送到交换器，交换器的类型为direct，可以根据消息的路由关键字进行匹配，转发到匹配的所有的队列
RoutingKey:路由关键字，只支持精确的值
在这里插入图片描述
示例：
1、创建队列
2、创建交换器 direct
3、创建交换器和队列的绑定 指定RK
4、发送消息 指定RK
5、监听消息

1、创建队列

package com.yd.rabbitmq01.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 消息模式，路由匹配
 *
 * @author MaoXiqi
 * @organization: Lucky
 * @create 2023-10-13 19:17:19
 * @description DirectConfigApi
 */
@Configuration
public class DirectConfig {
    // 1.创建队列
    @Bean
    public Queue createQdirect1() {
        return new Queue("q-direct-01");
    }
    @Bean
    public Queue createQdirect2() {
        return new Queue("q-direct-02");
    }
    @Bean
    public Queue createQdirect3() {
        return new Queue("q-direct-03");
    }
    //2.创建交换器
    @Bean
    public DirectExchange createDe() {
        return new DirectExchange("ex-direct-yd");
    }
    //3.实现绑定
    @Bean
    public Binding createBd1(DirectExchange fe){
        return BindingBuilder.bind(createQdirect1()).to(fe).with("error");
    }
    @Bean
    public Binding createBd2(DirectExchange fe){
        return BindingBuilder.bind(createQdirect2()).to(fe).with("info");
    }
    @Bean
    public Binding createBd3(DirectExchange fe){
        return BindingBuilder.bind(createQdirect3()).to(fe).with("info");
    }
}

4、发送消息 指定RK

package com.yd.rabbitmq01.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author MaoXiqi
 * @organization: Lucky
 * @create 2023-10-13 15:31:59
 * @description FanoutControllerApi
 */
@RestController
public class FanoutController {
    @Resource
    private RabbitTemplate template;

    /**
     * 消息模式，路由匹配
     * @param msg
     * @param type
     * @return
     */
    @GetMapping("direct1")
    public String d1(String msg, String type) {
        template.convertAndSend("ex-direct-yd",type,msg);
        return "ok";
    }
}

在这里插入图片描述

2.5 消息模式-主题消息

主题消息，就是交换器的类型为Topic，跟路由模式的消息一样，都是通过RoutingKey匹配队列

区别：
主题消息 的RK支持模糊
特殊符号：区分单词是通过 . 区分的
* 一个单词，单词内容任意
# 任意个单词，单词内容任意

在这里插入图片描述
示例：
1.创建队列
2.创建交换器 topic
3.创建交换和队列的绑定 指定RK（支持模糊）
4.发送消息 指定RK
5.监听消息

1.创建队列

package com.yd.rabbitmq01.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 消息模式-主题消息
 * @author MaoXiqi
 * @organization: Lucky
 * @create 2023-10-13 19:58:35
 * @description TopicconfigApi
 */
@Configuration
public class TopicConfig {
    //1.创建队列
    @Bean
    public Queue createQtopic1(){
        return new Queue("q-topic-01");
    }
    @Bean
    public Queue createQtopic2(){
        return new Queue("q-topic-02");
    }
    //2.创建交换器
    @Bean
    public TopicExchange createTe(){
        return new TopicExchange("ex-topic-yd");
    }
    //3.实现绑定
    @Bean
    public Binding createBt1(TopicExchange fe) {
        //*一个单词
        return BindingBuilder.bind(createQtopic1()).to(fe).with("error.*");
    }
    //3.实现绑定
    @Bean
    public Binding createBt2(TopicExchange fe) {
        //# 任意个单词 0-多个
        return BindingBuilder.bind(createQtopic2()).to(fe).with("info.#");
    }
}

4.发送消息 指定RK

package com.yd.rabbitmq01.controller;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * 消息模式-主题消息
 *
 * @author MaoXiqi
 * @organization: Lucky
 * @create 2023-10-13 20:05:20
 * @description TopicControllerApi
 */
@RestController
public class TopicController {
    @Resource
    private RabbitTemplate template;

    /**
     * 消息模式-主题消息
     * @param msg
     * @param rk
     * @return
     */
    @GetMapping("topic1")
    public String f1(String msg,String rk) {
        template.convertAndSend("ex-topic-yd",rk,msg);
        return "ok";
    }
}

在这里插入图片描述
发短信可能会延迟，用异步请求，可以使用MQ，
发邮箱

RabbitMQ基于死信实现延迟

RabbitMQ事务

怎么防止消息的成功？开启RabbitMQ手动应答
RabbitMQ手动应答

RabbitMQ如何保证消息的幂等性

征途漫漫，唯有奋斗
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
.Net使用RabbitMQ即时发消息Demo
10-18
标题中的".Net使用RabbitMQ即时发消息Demo"是指在.NET开发环境中，使用RabbitMQ这一消息中间件来实现实时发送消息的功能。RabbitMQ是基于AMQP（Advanced Message Queuing Protocol）协议的一个开源消息系统，它由...
C#的Demo项目：RabbitMQ封装和使用
05-23
在标题和描述中提到的C# Demo项目，主要展示了RabbitMQ的基础用法，特别是如何封装RabbitMQ.Client库以简化操作，并演示了三种不同的Exchange（交换机）的使用。交换机是RabbitMQ中的核心组件，它决定了消息如何路由...
RabbitMQ安装及基本使用
Tom_kobe的博客
08-26 1199
RabbitMQ是一套开源（MPL）的消息队列服务软件，是由 LShift 提供的一个 Advanced Message Queuing Protocol (AMQP) 的开源实现，由以高性能、健壮以及可伸缩性出名的 Erlang写成。MQ是一个互联网架构中常见的解耦利器。...
RabbitMQ - 安装和使用
Zong_0915的博客
12-10 955
消息传递的时候，并不是直接将信息发送到队列中，而是发送给交换机。交换机相当于一个交通枢纽，决定了将接收到的消息发送到哪个队列中。相当于直连交换机的一种升华模式。直连交换机里面一般是指定一个唯一的。运行之后，效果如下：找不到之后它会自动去拉镜像并且运行。而主题交换机则可以选取带有一定匹配规则的。到这里一个简单的生产消费过程就结束了。，都会接收对应的消息。，添加一个绑定关系。，发送弹幕的时候顺便发了个Q）例如，主题交换机绑定了以下。：交换机的类型，有四种。测试如下：（我这里整合了。
rabbitmq功能总结和demo演示
谷神通
08-02 3091
MQ概念 MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求 ...
RabbitMQ安装及简单使用
qq_42108331的博客
07-19 1009
RabbitMQ安装及简单使用
RabbitMQ Java实现demo
梅林's hat
10-07 638
代码运行需先安装环境依赖 windows环境下: 先安装Erlang 页面:https://www.erlang.org/downloads 下载链接:https://erlang.org/download/otp_win64_24.1.exe 安装完配置环境变量 ERLANG_HOME C:\Program Files\erl-24.1 然后在path变量里添加 %ERLANG_HOME%/bin 然后打开cmd命令框，输入erl Eshell V12.1 (abort with ^G) ..
RabbitMQ入门Demo 简单模式
tiantiantbtb的博客
05-01 1361
1、简单模式 HelloWorld一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）。2、工作队列模式 Work Queue一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）。3、发布订阅模式 Publish/subscribe需要设置类型为 fanout 的交换机 ，并且交换机和队列进行绑定 ，当发送消息到交换机后，交换机会将消息发送到绑定的队列。4、路由模式 Routing。
php rabbitmq 安装与使用
Menwe1的博客
10-14 735
php rabbitmq 安装与使用
RabbitMQ的简单使用Demo
ybb_ymm的专栏
03-06 566
上一篇Windows下RabbitMQ的安装，如有不知道怎么安装的朋友可以查看上一章讲解。 今天讲解一下咱们RabbitMQ怎么的简单使用。 英文api地址：http://localhost:15672/api/index.html 用命令查询一下RabbitMQ的注册用户：rabbitmqctl list_users 如下图： 那么在命令行下创建一个用户，创建用户的命令...
RabbitMq延迟队列小Demo
qq_51769350的博客
12-01 1257
消息队列小练习，实现一个活动开始前十分钟给用户发邮件提醒用户的小demo
RabbitMq安装及java demo
Shuttle的技术博客
12-06 634
1. RabbitMq 安装我使用的是mac操作系统，所以这里只介绍mac系统上安装rabbitmq的过程，后面代码部分都是一样的，话不多说，直接干货。安装home brew 官方推荐使用home brew安装，所以如果你没有安装hom brew，请先下载并安装，地址为：http://brew.sh/ 安装rabbitmq 直接一句话，brew install rabbitmq，是不是很简单。如
RabbitMQ的使用demo
07-02
本资源是SpringBoot整合RabbitMQ的小Demo，通过本demo的学习，您可以学习到RabbitMQ的路由、各类交换机、路由键等相关知识，并且能够使用SPringBoot通过注解的方式配置RabbitMQ。 本资源demo包括 开启手动确认模式、...
rabbitmq 安装文档以及使用demo
07-02
了解并熟练掌握这些基本概念和操作，能够帮助你有效地在.NET环境中利用RabbitMQ实现可靠的消息传递和异步任务处理。在实际项目中，还可以根据需求配置高级特性，如死信队列、延迟队列、优先级队列等，以满足不同场景...
rabbitmq spring demo
06-08
rabbitmq spring rabbitmq spring rabbitmq spring rabbitmq spring http://knight-black-bob.iteye.com/blog/2304089
RabbitMQ保证消息被成功发送和消费
最新发布
weixin_43076660的博客
07-10 715
RabbitMQ保证消息被成功发送和消费
RabbitMQ中常用的三种交换机【Fanout、Direct、Topic】
LYJbao的博客
07-07 808
此时支付服务会把支付结果发送到交换机中，而短信服务就会去监听这个交换机，但是交换机不会把所有的消息都路由给短信服务，而只把支付成功的消息路由给这个短信服务。这种情况下，就需要使用到这个Direct交换机，短信服务下的队列和这个交换机设置一个key（例如：success），支付服务发消息时，支付成功RoutingKey设为success，失败为fail，交换机就会只把key为success的消息路由给短信服务了~上图中，就是，key为blue，消费者1去消费；一个只能接到新闻，一个只能接到和中国相关的消息~
RabbitMQ 迁移
Dablelv 的博客专栏。
07-08 408
如果您只需要导出和导入RabbitMQ的定义（如vhost、exchange、queue等），可以使用RabbitMQ的 HTTP API。
SpringBoot日常：封装rabbitmq starter组件
qq_32590535的博客
07-08 845
本章内容主要介绍编写一个rabbitmq starter，能够通过配置文件进行配置交换机、队列以及绑定关系等等。项目引用该组件后能够自动初始化交换机和队列，并进行简单通信。 如若有其他需求，可自行扩展，例如消息消费的确认等
rabbitmq demo
06-08
好的，这里是一个 RabbitMQ 的 demo，使用 Python 编写： 首先，需要安装 pika 库，可以使用以下命令进行安装： ``` pip install pika ``` 然后，我们需要编写两个脚本，一个用于发送消息，一个用于接收消息。 发送消息的脚本： ```python import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue='hello') channel.basic_publish(exchange='', routing_key='hello', body='Hello World!') print(" [x] Sent 'Hello World!'") connection.close() ``` 接收消息的脚本： ```python import pika connection = pika.BlockingConnection(pika.ConnectionParameters('localhost')) channel = connection.channel() channel.queue_declare(queue='hello') def callback(ch, method, properties, body): print(" [x] Received %r" % body) channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=True) print(' [*] Waiting for messages. To exit press CTRL+C') channel.start_consuming() ``` 运行接收消息的脚本后，再运行发送消息的脚本，就可以在控制台看到接收到的消息了。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值