RabbitMQ基础

最新推荐文章于 2023-04-13 09:50:29 发布
最新推荐文章于 2023-04-13 09:50:29 发布
阅读量542 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hello_wang_world/article/details/119619887
版权
本文介绍了为什么需要使用消息中间件，通过一个下单流程对比展示了消息队列能提高系统效率。接着详细讲解了RabbitMQ的安装、工作原理以及三种Exchange类型（direct、fanout、topic）的实例。此外，还涉及了手动应答队列、队列的公平分发、确认队列和TTL设置等进阶特性，帮助读者深入理解RabbitMQ的使用。
摘要由CSDN通过智能技术生成

RabbitMQ基础

为什么要使用消息中间件？

例流程图单线程：
这是一个简单的下单流程如果每次执行的时间都一样的话每个结点的时间都为10s那么此流程就需要40s
这是一个简单的下单流程如果每次执行的时间都一样的话每个结点的时间都为10s那么此流程就需要40s
例流程图多线程：
在这里插入图片描述
这样多线程的话我也假设每个节点10s那么这个流程需要20s
使用消息队列就是在生成订单的时候将消息发送，然后由个个模块监听接收；这个速度远超线程的开启且占用资源小，当用户访问量过大时线程的速度就会变慢。而且消息队列可以当作定时功能例如延时队列，死信队列；想了解继续看。

RabbitMQ

简单介绍

2007年发布是基于AMQP(高级消息队列协议)的基础来开发的。优点：性能好，吞吐量达万级，易用，稳定，跨平台支持多语言；缺点：商业版收费

RabbitMQ入门准备

安装RabbitMQ环境：

		虚拟机：Orcle VM virtualBox  	内存：2048 处理器：2 显存：256  系统：centOS 7 系统内核：3.10以上    
		安装docker：**注意：我为了方便使用的是容器技术你也可以直接安装**		

#查看系统内核
[root@localhost ~]# uname -r
[root@localhost ~]# yum install docker 
#安装好启动docker
[root@localhost ~]# systemctl start docker
#之后就是从docker 中拉取镜像参考docker hub 官网 [docker hub 官网](https://hub.docker.com/)
[root@localhost ~]#  docker pull rabbitmq:版本
#查看 docker 中有哪些 
[root@localhost ~]# docker images

在这里插入图片描述

#启动rabbitmq --name 启动名字 -p暴露端口 5671映射5672 默认5672 一个服务端口，一个是客户端端口
[root@localhost ~]# docker run -d --name myrabbitmq -p 5671:5672 -p 15671:15672 docker.io/rabbitmq

在这里插入图片描述
到这里安装就是完成了还有其他的命令自己查一下这里主要是介绍怎么使用RabbitMQ;
刚启动完成的RabbitMQ客户端的访问地址http://ip:15671，端口根据自己的暴露映射端口来 客户端默认账户密码guest；

RabbitMQ的工作原理

在这里插入图片描述
producer:生产者，一个或者多个生产者发送消息
channel:信道每个生产者都一个对应的信道，通过信道发送给交换机
exchange:交换机通过不同的类型和路由（routingKey）发送给对应队列。交换机的类型,direct(直接类型)，fanout(扇出)，topic(标题)，headers(头类型这个基本不用)
queue:队列（先进先出原则）通过binding绑定交换机。收到消息后通过信道交给消费之取出
consumer:消费者，消费队列消息

简单队列

Exchange type 为direct 类型实例

  1. 使用IDEA创建一个mvn工程导入坐标
  <dependency>
          <groupId>org.springframework.amqp</groupId>
          <artifactId>spring-rabbit</artifactId>
          <version>2.3.10</version>
      </dependency>
      <dependency>
          <groupId>org.apache.commons</groupId>
          <artifactId>commons-io</artifactId>
          <version>1.3.2</version>
      </dependency>

交换机设置图
在这里插入图片描述

  1. 创建一个提供者
//消费者
public class ProducerDircet {
    //定义一个交换机名
    private static final  String DIRCET_EXCHANGE_NAME="dircet_exchange";
    //定义一个队列名
    private static final  String DIRCET_QUEUE_NAME="dircet_queue";
    //定义一个路由
    private static  final  String DIRCET_ROUTING_NAME="DRN";

    public static void main(String[] args) throws Exception {
        //获取信道
        Channel channel= RabbitMQUtil.getChannel();
        /**
         * 创建一个交换机
         * 1.交换机名
         * 2.交换机类型
         * 3.durable:是否持久化
         * 4.autoDelete是否自动删除
         * 5.arguments:其他类型绑定
         */
        channel.exchangeDeclare(DIRCET_EXCHANGE_NAME, BuiltinExchangeType.DIRECT,false,false,null);
        /**
         * 创建一个队列
         * 1.队列名
         * 2.durable:是否持久化
         * 3.excusive:是否共享
         * 4.autoDelete是否自动删除
         * 5.arguments:其他类型绑定
         */
        channel.queueDeclare(DIRCET_QUEUE_NAME, false, false, false, null);

        /**
         * 根据路由绑定
         *
         */
        channel.queueBind(DIRCET_QUEUE_NAME, DIRCET_EXCHANGE_NAME, DIRCET_ROUTING_NAME);
        Scanner scanner=new Scanner(System.in);
        while (scanner.hasNext()){
            String message=scanner.next();
            /**
             * 发送消息到交换机根据路由到队列
             * 1.交换机名
             * 2.路由名
             * 3.发消息的其他配置信息
             * 4.发送的消息内容
             */
            channel.basicPublish(DIRCET_EXCHANGE_NAME, DIRCET_ROUTING_NAME, null, message.getBytes());
            System.out.println("发送消息：" + message);
        }

    }
}
  1. 创建一个消费者
//Dircet消费者
public class ConsumerDircet {
    //定义一个队列名
    private static final  String DIRCET_QUEUE_NAME="dircet_queue";

    public static void main(String[] args) throws  Exception {
        Channel channel= RabbitMQUtil.getChannel();
        //autoAck 是否自动应答
        System.out.println("启动获取队列");
        channel.basicConsume(DIRCET_QUEUE_NAME, true, (consumerTag,message)->{
            System.out.println("队列应答: " + new String(message.getBody(), "UTF-8"));
        },consumerTag -> { } );
    }
}

创建完交换机队列后查看rabbitmq客户端 由于我设置的都是false所以features没有值实例化设置true这里就显示D
在这里插入图片描述

Exchange type为fanout实例

订阅消息exchange 与队列绑定关系
在这里插入图片描述

  1. 订阅消息生产者
//消费者
public class ProducerDircet {
    //定义一个交换机名
    private static final  String DIRCET_EXCHANGE_NAME="fanout_exchange";
    //定义一个队列名
    private static final  String DIRCET_QUEUE_NAME1="fanout_queue1";
    //定义一个队列名
    private static final  String DIRCET_QUEUE_NAME2="fanout_queue2";
    private static final  String DIRCET_QUEUE_NAME3="fanout_queue3";

    public static void main(String[] args) throws Exception {
        //获取信道
        Channel channel= RabbitMQUtil.getChannel();
        /**
         * 创建一个交换机
         * 1.交换机名
         * 2.交换机类型
         * 3.durable:是否持久化
         * 4.autoDelete是否自动删除
         * 5.arguments:其他类型绑定
         */
        channel.exchangeDeclare(DIRCET_EXCHANGE_NAME, BuiltinExchangeType.FANOUT,false,false,null);
        /**
         * 创建一个队列
         * 1.队列名
         * 2.durable:是否持久化
         * 3.excusive:是否共享
         * 4.autoDelete是否自动删除
         * 5.arguments:其他类型绑定
         */
        channel.queueDeclare(DIRCET_QUEUE_NAME1, false, false, false, null);
        channel.queueDeclare(DIRCET_QUEUE_NAME2, false, false, false, null);
        channel.queueDeclare(DIRCET_QUEUE_NAME3, false, false, false, null);
        /**
         * 订阅只要绑定就行不需要路由组件
         * 应为订阅发布时他绑定的所有队列都会获取消息
         *
         */
        channel.queueBind(DIRCET_QUEUE_NAME1, DIRCET_EXCHANGE_NAME,"QF");
        channel.queueBind(DIRCET_QUEUE_NAME2, DIRCET_EXCHANGE_NAME,"QF");
        channel.queueBind(DIRCET_QUEUE_NAME3, DIRCET_EXCHANGE_NAME,"QF");
        Scanner scanner=new Scanner(System.in);
        while (scanner.hasNext()){
            String message=scanner.next();
            /**
             * 发送消息到交换机根据路由到队列
             * 1.交换机名
             * 2.路由名
             * 3.发消息的其他配置信息
             * 4.发送的消息内容
             */
            channel.basicPublish(DIRCET_EXCHANGE_NAME, "", null, message.getBytes());
            System.out.println("发送消息：" + message);
        }

    }
}

在这里插入图片描述
2. 订阅消费者

public class ConsumerDircet {
    //定义一个队列名
    //定义一个队列名
    private static final  String DIRCET_QUEUE_NAME1="fanout_queue1";
    //定义一个队列名
    private static final  String DIRCET_QUEUE_NAME2="fanout_queue2";
    private static final  String DIRCET_QUEUE_NAME3="fanout_queue3";
    public static void main(String[] args) throws  Exception {
        Channel channel= RabbitMQUtil.getChannel();
        //autoAck 是否自动应答
        System.out.println("启动获取队列");
        channel.basicConsume(DIRCET_QUEUE_NAME1, true, (consumerTag,message)->{
            System.out.println("队列应答1: " + new String(message.getBody(), "UTF-8"));
        },consumerTag -> { } );
        channel.basicConsume(DIRCET_QUEUE_NAME2, true, (consumerTag,message)->{
            System.out.println("队列应答2: " + new String(message.getBody(), "UTF-8"));
        },consumerTag -> { } );
        channel.basicConsume(DIRCET_QUEUE_NAME3, true, (consumerTag,message)->{
            System.out.println("队列应答3: " + new String(message.getBody(), "UTF-8"));
        },consumerTag -> { } );
    }
}

Exchange type为topic实例

在这里插入图片描述
路由中有.#或者#. 的意思就是在后面有多个或者0个单词例如：.# 相当于.de, .da.da;#. 相当于da. , da.da.
路由中*.或者.* 的意思就是在后面有1个单词例如:*. 相当于 da.

  1. topic的消息提供者
public class ProducerTopic {

    //定义一个交换机名
    private static final String DIRCET_EXCHANGE_NAME = "topic_exchange";
    //定义一个队列名
    private static final String DIRCET_QUEUE_NAME1 = "queue1";
    //定义一个队列名
    private static final String DIRCET_QUEUE_NAME2 = "queue2";
    private static final String DIRCET_QUEUE_NAME3 = "queue3";

    public static void main(String[] args) throws Exception {
        //获取信道
        Channel channel = RabbitMQUtil.getChannel();
        /**
         * 创建一个交换机
         * 1.交换机名
         * 2.交换机类型
         * 3.durable:是否持久化
         * 4.autoDelete是否自动删除
         * 5.arguments:其他类型绑定
         */
        channel.exchangeDeclare(DIRCET_EXCHANGE_NAME, BuiltinExchangeType.TOPIC, false, false, null);
        /**
         * 创建一个队列
         * 1.队列名
         * 2.durable:是否持久化
         * 3.excusive:是否共享
         * 4.autoDelete是否自动删除
         * 5.arguments:其他类型绑定
         */
        channel.queueDeclare(DIRCET_QUEUE_NAME1, false, false, false, null);
        channel.queueDeclare(DIRCET_QUEUE_NAME2, false, false, false, null);
        channel.queueDeclare(DIRCET_QUEUE_NAME3, false, false, false, null);


        channel.queueBind(DIRCET_QUEUE_NAME1, DIRCET_EXCHANGE_NAME, "QD.#");
        channel.queueBind(DIRCET_QUEUE_NAME2, DIRCET_EXCHANGE_NAME, "#.QD.*");
        channel.queueBind(DIRCET_QUEUE_NAME3, DIRCET_EXCHANGE_NAME, "*.QD.*");
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String message = scanner.next();
            /**
             * 发送消息到交换机根据路由到队列
             * 1.交换机名
             * 2.路由名
             * 3.发消息的其他配置信息
             * 4.发送的消息内容
             * 第一个队列发三条
             * 第二队列发三条
             * 第三列发一条
             */
            channel.basicPublish(DIRCET_EXCHANGE_NAME, "QD", null, message.getBytes());
            channel.basicPublish(DIRCET_EXCHANGE_NAME, "QD.qd.dd", null, message.getBytes());
            channel.basicPublish(DIRCET_EXCHANGE_NAME, "QD.qa", null, message.getBytes());
            channel.basicPublish(DIRCET_EXCHANGE_NAME, "1.QD", null, message.getBytes());
            channel.basicPublish(DIRCET_EXCHANGE_NAME, "1.1.QD.2", null, message.getBytes());
            channel.basicPublish(DIRCET_EXCHANGE_NAME, "1.QD.2", null, message.getBytes());
            System.out.println("发送消息：" + message);
        }

    }

}

在这里插入图片描述
消费者略;

手动应答队列

上面的案例中我是用的都是自动应答，通过设置消费者 basicConsume这个方法的ack为false 时需要手动应答，使用

		//前面的值是当前消息的小标，当后multiple值为true是就是当前下表以前的全部应答,为false时就是只当前下标应答
	   channel.basicAck(message.getEnvelope().getDeliveryTag(), true);

队列的轮询

当同一个队列被两个消费者同时消费，会出现消费者1消费一次，消费这二消费一次，这样公平分发下去直到消费者，消费完队列里所有消息，这里我就不书写代码了可以使用上面的实例开启两个消费者来操作

不公平分发

设置预取值设置basicQos，通过预取值来设置当前的消费者的预取值。
例如：如果一个队列里有10个数据时，这时候有一个消费者1和消费者2。但是消费者2比消费者一慢30s,假设设置了两个消费者的预取值都是1，这个时候的意思就是当消费一个队列里的一个数据时，如果没有应答即不会给此消费者分配新数据；
其实预取值还有一个用法但是这个方法不够严谨；再在测试中发现当我设置预取值时当我设置了消费者1绝对慢于消费者2，在设置消费者2预取值为1，消费者1预取值为4。这时候你会发现消费者1消费了预设值4个消息。但是不绝对当消费者一的处理速度跟消费者二处理速度相差不多时；就会打破这个规则出现谁快谁消费的多，这就是不公平分发以可以说是流量的控制

确认队列

消息发送确认：在发送的时候确认发送成功给生产者一个应答这样也是为了防止消息丢失。当我们应答失败时我们可以设置机制比如从新入队发送，这样就不会出现消息在发送时丢失
这种确认方式有三种第一种和第二种方式都比较简单就是利用在

逐步确认
  Channel channel= RabbitMQUtil.getChannel();
        //开启发送确认
         channel.confirmSelect();
         channel.exchangeDeclare(CON_EXCHANGE_NAME, BuiltinExchangeType.DIRECT, true, false, null);
         channel.queueDeclare(CON_QUEUE_NAME, true, false, false, null);
         channel.queueBind(CON_QUEUE_NAME, CON_EXCHANGE_NAME, CON_ROUTING_NAME);

         //获取异步处理的集合
        SortedSet set= Collections.synchronizedSortedSet(new TreeSet<>());
        long start= System.currentTimeMillis();
         for (int i=0;i<10000;i++){
             String message="第"+i+"条消息";
             //获取每次发送的编号
             long nextPublishSeqNo = channel.getNextPublishSeqNo();
             channel.basicPublish(CON_EXCHANGE_NAME, CON_ROUTING_NAME,null,message.getBytes());
             boolean b = channel.waitForConfirms();
             if(b){
                 System.out.println("成功");
             }

第二种跟第一种类似

异步操作
package com.rabbitmq.confrim;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmListener;

import com.rabbitmq.utils.RabbitMQUtil;

import java.io.IOException;

import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;


public class ConfrimProduer {
    static  final  String CON_EXCHANGE_NAME="con_exchange";
    static  final  String CON_QUEUE_NAME="con_queue";
    static final String CON_ROUTING_NAME="CRN";
    public static void main(String[] args) throws IOException {
        Channel channel= RabbitMQUtil.getChannel();
        //开启发送确认
         channel.confirmSelect();
         channel.exchangeDeclare(CON_EXCHANGE_NAME, BuiltinExchangeType.DIRECT, true, false, null);
         channel.queueDeclare(CON_QUEUE_NAME, true, false, false, null);
         channel.queueBind(CON_QUEUE_NAME, CON_EXCHANGE_NAME, CON_ROUTING_NAME);

         //获取异步处理的map
        ConcurrentSkipListMap<Object,Object> skipListMap=new ConcurrentSkipListMap<>();
        long start= System.currentTimeMillis();
         for (int i=0;i<300;i++){
             String message="第"+i+"条消息";
             //获取每次发送的编号
             long nextPublishSeqNo = channel.getNextPublishSeqNo();
             channel.basicPublish(CON_EXCHANGE_NAME, CON_ROUTING_NAME,null,message.getBytes());

             skipListMap.put(nextPublishSeqNo,message);
         }

         channel.addConfirmListener(new ConfirmListener() {
             @Override
             public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                 System.out.println(deliveryTag+""+multiple);
                 if(multiple){
                     ConcurrentNavigableMap<Object, Object> map = skipListMap.headMap(deliveryTag);
                       map.clear();
                 }else{
                     skipListMap.remove(deliveryTag);
                      }
             }

             @Override
             public void handleNack(long deliveryTag, boolean multiple) throws IOException {

               String message= (String) skipListMap.get(deliveryTag);
               //未成功的消息
                 System.out.println("message" + message);
             }
         });
        long end= System.currentTimeMillis();
        System.out.println("执行时间：" + (end - start) + "ms");
    }
}

代码解析异步操作；当消息发送入队后写入磁盘由于是异步操作所以他啊返回的ack调用可能是多个当是多个是multiple=true 清空所有，但只有一个时multiple=false清空当前
当发生异常时就会请求nack这是会从新入队清空集合

TLL设置过期时间——死信

由于业务的需要当业务量太大时容易造成队列处理的慢这时候我们可以加入一个队列帮助处理同一批数据怎么处理呢？
这时候就用到了TTL设置过期其实时间放入死信队列中来处理这样怎加了一个消费者处理

案例
解释图

在这里插入图片描述

public class prodcuer {

    private  static final String EXCHANGE="exchange";
    private static final String TTL_QUEUE="ttl_queue";
    private static  final String DTL_EXCHANGE="dtl_exchange";
    private static  final String DTL_QUEUE="dtl_queue";

    public static void main(String []args)throws Exception{
        Channel channel= RabbitMQUtil.getChannel();
        //正常
        channel.exchangeDeclare(EXCHANGE, BuiltinExchangeType.DIRECT, false, false, null);
         //死信交换机
        channel.exchangeDeclare(DTL_EXCHANGE, BuiltinExchangeType.DIRECT, false, false, null);
        channel.queueDeclare(DTL_QUEUE, false, false, false, null);
        channel.queueBind(DTL_QUEUE, DTL_EXCHANGE, "qq");
        HashMap<String,Object> map =new HashMap<>();
        //绑定这里的key在mq的客户端可以看到
        map.put("x-dead-letter-exchange", DTL_EXCHANGE);
        map.put("x-dead-letter-routing-key","qq");
        channel.queueDeclare(TTL_QUEUE, false, false, false, map);
        channel.queueBind(TTL_QUEUE, EXCHANGE, "cc");
        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
        channel.basicPublish(EXCHANGE, "cc",properties, "死信队列".getBytes());
    }
}

在这里插入图片描述
到这里rabbitmq的基础入门就结束了。

hello_wang_world
关注
rabbitmq连接js页面
10-18
rabbitMq连接js页面，非常方便的dome，只有是webscoket都可连接上，你们可以多尝试一下。
JavaScript 连接消息（RabbitMQ）
Lifelong learning
01-22 5426
STOMP是一个简单的面向文本的消息传递协议。它定义了一种可互操作的有线格式 ，以便任何可用的 STOMP 客户端都可以与任何 STOMP 消息代理进行通信，从而在语言和平台之间提供简单而广泛的消息互操作性（STOMP 网站有一个STOMP 客户端和服务器实现列表。 官方介绍 使用： 环境准备 RabbitMQ开通STOMP通道： rebbitmq安装目录sbin文件夹下执行命令 rabbitmq-plugins enable rabbitmq_web_stomp rabbitmq-plugins enab
JS（javascript）连接rabbitMq通过stomp实现消息实时推送
热门推荐
zoboy的博客
10-24 2万+
  消息的实时推送一般有3种方式： Ajax 短轮询 长轮询 WebSocket 双向通信      短轮询的实现是定时异步刷新任务来实现数据的加载，但这种方式实时效果较差，而且对服务端的压力也较大。长轮询的实现是通过 Ajax 机制，但区别于传统的 Ajax 应用，长轮询的服务器端会在没有数据时阻塞请求直到有新的数据产生或者请求超时才返回，之后客户端再重新建立连接获取数据。但长轮询服务端会...
消息队列Rabbitmq，在Node.js中的应用
程序员成长指北
11-26 7241
为什么写这篇文章 现在的面试要求越来越高了，打开看了看几个 BOSS 招聘 Node.js 全栈开发的，其中都有一条“了解 消息队列，并在项目中应用过”，呜呜呜 后端开发者应该都知道消息队列，但是一些前端开发者可能知道的并不多，但是你们可能好奇抢票,商品秒杀等功能是如何实现的，其实没有多么高大上，看了消息队列就知道了。 文章导图(你能学到) 什么是消息队列 “消息队列...
nodejs rabbitmq使用
ann123_2016的博客
05-20 749
var amqp = require('amqp') 1.一个发送者，多个消费者。exchange发送3条消息,每个队列接收3条消息相同 connection.on('ready', function () { var exchange = connection.exchange('exchange_name', {type: 'fanout',autoDelete:false})...
rabbitmq基础入门
04-01
RabbitMQ基础入门主要涵盖了MQ的基本概念、使用MQ的原因、MQ的分类以及RabbitMQ的详细知识。MQ，即Message Queue，是一种基于FIFO（先进先出）原则的消息队列服务，用于不同进程间的通信，尤其在互联网架构中，它起...
rabbitmq基础+springboot集成rabbitmq
10-14
**RabbitMQ基础** RabbitMQ是一个开源的消息代理和队列服务器，用于在分布式系统中进行消息传递。它是基于AMQP（Advanced Message Queuing Protocol）协议实现的，提供了高可用性、可扩展性和稳定性。RabbitMQ的...
RabbitMq 基础知识.docx
05-25
以下是对RabbitMQ基础知识的详细解释： 1. **消息持久化** - 消息持久化是确保即使RabbitMQ服务重启，消息也不会丢失的关键特性。这包括交换机(exchange)、队列(queue)和消息(message)的持久化。 - 在声明交换机...
RabbitMQ基础教程
04-19
### RabbitMQ基础教程知识点详解 #### 一、RabbitMQ简介 RabbitMQ是一种开源的消息代理和队列服务器，基于AMQP（Advanced Message Queuing Protocol）标准开发，它提供了多种编程语言的API接口，能够方便地与其他...
RabbitMQ基础.pptx
01-10
RabbitMQ是一款广泛使用的开源消息队列系统，基于Erlang语言开发，支持多种协议，如AMQP、XMPP、SMTP和STOMP等。由于其稳定性和丰富的功能，RabbitMQ在很多场景下被选作消息中间件。 **常见MQ产品比较** 除了...
JavaScript连接消息（RabbitMQ）
01-22
JavaScript连接消息（RabbitMQ）
javascript 中使用 ActiveMQ
最新发布
ice_bear221的博客
04-13 1091
javascript 中使用 ActiveMQ
前端连接activemq demo
qq_25073261的博客
01-20 1773
前端连接activemq demo 代码如下 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>mqtt-websocket测试</title> // 替换成你的本地地址或者cdn地址 <script...
【js学习】js连接RabbitMQ达到实时消息推送
weixin_34367845的博客
04-04 687
js连接RabbitMQ达到实时消息推送 最近在自己捯饬一个网站，有一个功能是需要后端处理完数据把数据发布到MQ中，前端再从MQ中接收数据。但是前端连接MQ又成了一个问题，在网上搜了下资料，点进去一篇IBM DW后发现竟然是超哥写的，真是巧哈~因为超哥写的很好所以很多我就直接摘抄过来了，他应该不会介意的（逃。 参考 基于 RabbitMQ 的实时消息推送 rabbitMQ官网 实现服务器端推送...
js调用activeMQ
dengjuekai7173的博客
08-17 410
1:引入脚本的顺序. 2:兼容tomcat7+ <servlet> <servlet-name>AjaxServlet</servlet-name> <servlet-class>org.apache.activemq.web.AjaxServlet</servlet-class> &lt...
Node.js中使用消息队列RabbitMQ
ScarlettZhao0602的博客
08-16 1252
RabbitMQ
mqtt 发送消息过多_物联网宠儿mqtt.js那些事儿
weixin_39661881的博客
01-04 824
常见的mq有Kafka，RocketMQ和RabbitMQ，大家也很常见。 前者很常见，MQTT是什么呢？MQTT属于IoT也就是物联网的概念。常见的mq有Kafka，RocketMQ和RabbitMQ，大家也很常见。MQTT是什么呢？Kafka，RocketMQ和RabbitMQ属于微服务间的mq，而MQTT则属于IoT也就是物联网的概念。mqtt.js是MQTT在nodejs端的实现。vue技...
关于rabbitmq安全漏洞的问题
程序员涂小哥的技术博客
02-17 1万+
在我们的很多个项目中都用到了消息中间件，虽然现在有些已经改用了kafka，但是还有相当一部分依然用的是rabbitmq。 而最近呢，我们收到了一份关于安全漏洞扫描的文档，说我们的rabbitmq存在着一些安全漏洞问题，既然是有问题，自然是需要整改的，但是看完文档以后，发现这种安全漏洞问题似乎并不是很好解决。 文档中指出的问题主要有这样三个： 一、更改密码没有验证旧密码 说的具体点
RabbitMQ基础使用与实践教程
资源摘要信息: "RabbitMQ入门教程" RabbitMQ是一个开源的消息代理软件（亦称面向消息的中间件），它是基于高级消息队列协议（AMQP）的实现，最初由LShift公司开发，后来被Pivotal收购。RabbitMQ被广泛使用在各种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值