rabbitMq

最新推荐文章于 2023-04-08 16:17:02 发布
最新推荐文章于 2023-04-08 16:17:02 发布
阅读量197 收藏
点赞数
分类专栏： 名称解释
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tansuoliming/article/details/80357964
版权

1.linux下安装

（1）资源：rabbitmq-server-3.6.1-1.noarch.rpm

（2）上传rabbitmq-server-3.4.1-1.noarch.rpm文件到/usr/local/src/rabbitmq/

安装：rpm –ivh rabbitmq-server.3.4.1-1.noarch.rpm

（3）设置配置文件

cd /etc/rabbitmq
cp /usr/share/doc/rabbitmq-server-3.4.1/rabbitmq.config.example /etc/rabbitmq/

(安装目录：/usr/share/doc/rabbitmq-server-3.4.1)

mv rabbitmq.config.example rabbitmq.config

（4）开启用户远程访问控制

vi /etc/rabbitmq/rabbitmq.configP64行

注意：有两处，修改如图处

去掉前面的两个%%，和最后面的逗号，保存。

（5）启动停止服务

servicerabbitmq-server start


servicerabbitmq-server stop

servicerabbitmq-server restart

设置开机启动

chkconfig rabbitmq-server on

（6）开启后台管理插件

执行下面命令，开启web界面管理工具

    rabbitmq-pluginsenable rabbitmq_management

servicerabbitmq-server restart

（7）访问管理平台

firefox    #打开虚拟机上的火狐

    http://localhost:15672/

默认用户名密码都为guest

注意：出于安全的考虑，guest这个默认的用户只能通过http://localhost:15672本地来登录，不能外部服务器登录，也就是不能远程访问，这对于服务器上没有安装桌面的情况是无法管理维护的。必须新创建管理员账号。

（8）打开端口

15672是Web控制台的访问端口；5672是程序连接的端口。

    /sbin/iptables–I INPUT –p tcp --dport 15672 –j ACCEPT

    /sbin/iptables–I INPUT –p tcp --dport 5672 –j ACCEPT

   

    /etc/rc.d/init.d/iptablessave

    /etc/init.d/iptablesstatus

2.环境配置

（1）添加用户

用户名sysdebug，密码123456

添加后

用户角色：

序号

角色名称

说明

1.

超级管理员（administrator）

可登陆管理控制台，可查看所有的信息，并且可以对用户，策略（policy）进行操作。

2.

监控者（monitoring）

可登陆管理控制台，同时可以查看rabbingmq节点的相关信息（进程数，内存使用情况，磁盘使用情况等）

3.

策略制定者（policymaker）

可登陆管理控制台，同时可以对policy进行管理。但无法查看节点的相关信息

4.

普通管理者（management）

仅可登陆管理控制台，无法看到节点信息，也无法对策略进行管理。

5.

其他

无法登录管理控制台，通常就是普通的生产者和消费者。

（2）添加virtualhosts

相当于mysql中的数据库

添加/jt，注意前面的/，不然数据可能造成丢失。

（3）权限控制


选择可以访问的用户

设置好权限

切换到User界面

3.rabbitmq使用，direct简单模式

（1）提供6中消息队列

http://www.rabbitmq.com/getstarted.html

（2）引入依赖包

<!-- 消息队列 -->
<dependency>
	<groupId>com.rabbitmq</groupId>
	<artifactId>amqp-client</artifactId>
	<version>3.5.1</version>
</dependency>
<dependency>
       <groupId>org.springframework.amqp</groupId>
       <artifactId>spring-rabbit</artifactId>
       <version>1.4.0.RELEASE</version>
</dependency>

（3）helloword


P代表生产者，C代表消费者，红色代码消息队列。P将消息发送到消息队列，C对消息进行处理。

    工具类，获取链接

package com.rabbitmq.util;

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

public class ConnectionUtil {

    public static Connection getConnection() throws Exception {
        //定义连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置服务地址
        factory.setHost("localhost");
        //端口，HTTP管理端口默认15672，访问端口默认5672
        factory.setPort(5672);
        //设置账号信息，用户名、密码、vhost
        factory.setVirtualHost("jtmq");		//注意这个值，vh配置如果加了斜杠，这里也必须加
        factory.setUsername("jtmqadmin");
        factory.setPassword("123456");
        // 通过工程获取连接
        Connection connection = factory.newConnection();
        return connection;
    }

}

（4）发消息

package com.rabbitmq.simple;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.util.ConnectionUtil;

public class Send {

    private final static String QUEUE_NAME = "test_queue";

    public static void main(String[] argv) throws Exception {
        // 获取到连接以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        // 从连接中创建通道
        Channel channel = connection.createChannel();

        // 声明（创建）队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        // 消息内容
        String message = "Hello World!";
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
        System.out.println(" [x] Sent '" + message + "'");

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

（5）控制台查看消息


注意，需要用sysdebug登录才能看到。


（6）接收消息

package com.rabbitmq.simple;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.util.ConnectionUtil;

public class Recv {

    private final static String QUEUE_NAME = "test_queue";

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

        // 获取到连接以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

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

        // 定义队列的消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 监听队列
        channel.basicConsume(QUEUE_NAME, true, consumer);

        // 获取消息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [x] Received '" + message + "'");
        }
    }
}

接收消息后，将消息删除。

3.工作模式（work）竞争的

使用场景：抢红包


一个消息产生者，多个消息的消费者。竞争抢消息。

（1）产生多个消息

package com.rabbitmq.work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.util.ConnectionUtil;

public class Send {

    private final static String QUEUE_NAME = "test_queue_work";

    public static void main(String[] argv) throws Exception {
        // 获取到连接以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

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

        for (int i = 0; i < 100; i++) {
            // 消息内容
            String message = "" + i;
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println(" [x] Sent '" + message + "'");

            Thread.sleep(i * 10);	//越往后，停歇的时间越长
        }

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

控制台查看消息

    产生100条消息。

（2）消费者一

package com.rabbitmq.work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.util.ConnectionUtil;

public class Recv {

    private final static String QUEUE_NAME = "test_queue_work";

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

        // 获取到连接以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

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

        // 同一时刻服务器只会发一条消息给消费者，每一次服务器只会向客户端发送一条
        channel.basicQos(1);

        // 定义队列的消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 监听队列，手动返回完成
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 获取消息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [x] Received '" + message + "'");
            //休眠
            Thread.sleep(10);
            // 返回确认状态
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

（3）消费者2

package com.rabbitmq.work;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.util.ConnectionUtil;

public class Recv2 {

    private final static String QUEUE_NAME = "test_queue_work";

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

        // 获取到连接以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

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

        // 同一时刻服务器只会发一条消息给消费者，每一次服务器只会向客户端发送一条
        channel.basicQos(1);

        // 定义队列的消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 监听队列，手动返回完成状态
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 获取消息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [x] Received '" + message + "'");
            // 休眠1秒
            Thread.sleep(1000);

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

先注释掉两个消费者中的channel.basicQos(1);运行产生消息，同时运行消费者1和消费者2。消费者1中延时Thread.sleep(10)~10毫秒，消费者2中延时Thread.sleep(1000)~1秒。模拟两个消费者处理速度是不同的。

    发送消息：

消费者一


消费者二


观察控制台，会发现在产生消息的同时，两个消费者开始同时消费消息。但产生一个现象。消费者1消费偶数消息，消费者2消费奇数消息。平均分配合理吗？

    这明显不合理，干的快的应该处理的多，干的慢的应该处理的少。应该是能者多劳，多劳多得。

（4）消息负载均衡

解决办法：放开之前的注释，也就是加上channel.basicQos(1)。同一时刻服务器只会发一条消息给消费者，每一次服务器只会向客户端发送一条。测试可以看到实现能者多劳，多劳多得。

4.发布订阅（群发）

上面是单消息队列，下面有两个队列。

生产者将消息不是直接发送到队列，而是发送到X交换机，然后由交换机发送给两个队列，两个消费者各自监听一个队列，来消费消息。

这个X交换机就类似QQ群一样。老师发送一个作业题，大家都可以从这里获取。

这种方式实现同一个消息被多个消费者消费。工作模式是同一个消息只能有一个消费者。

（1）fanout exchange


一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。Fanout交换机转发消息是最快的。

（2）发消息

package com.rabbitmq.ps;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.util.ConnectionUtil;

public class Send {

    private final static String EXCHANGE_NAME = "jt_test_exchange_fanout";

    public static void main(String[] argv) throws Exception {
        // 获取到连接以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 声明exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

        // 消息内容
        String message = "Hello World!";
        channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
        System.out.println(" [x] Sent '" + message + "'");

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

    注意：如果没有队列绑定到交换机，那么发送到交换机的消息将丢失。

（3）消费者1

package com.rabbitmq.ps;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.util.ConnectionUtil;

public class Recv {

    private final static String QUEUE_NAME = "test_queue_exchange";

    private final static String EXCHANGE_NAME = "test_exchange_fanout";

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

        // 获取到连接以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

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

        // 绑定队列到交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

        // 同一时刻服务器只会发一条消息给消费者
        channel.basicQos(1);

        // 定义队列的消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 监听队列，手动返回完成
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 获取消息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [x] Received '" + message + "'");
            Thread.sleep(10);
            // 返回消息消费状态
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

（4）消费者2

package com.rabbitmq.ps;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.util.ConnectionUtil;

public class Recv2 {

    private final static String QUEUE_NAME = "test_queue_exchange2";

    private final static String EXCHANGE_NAME = "test_exchange_fanout";

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

        // 获取到连接以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

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

        // 绑定队列到交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");

        // 同一时刻服务器只会发一条消息给消费者
        channel.basicQos(1);

        // 定义队列的消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 监听队列，手动返回完成
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 获取消息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [x] Received '" + message + "'");
            Thread.sleep(10);

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

注意：

1）消费者1、消费者2都必须绑定到交换机上，channel.queueBind。否则无法获取消息。

    2）消息消费标示

在工作模式中消费完消息会返回消息消费状态为true。

channel.basicConsume(QUEUE_NAME, true, consumer);

在发布订阅时，不是立即返回消息消费状态，而是手工设置返回消息消费状态

channel.basicConsume(QUEUE_NAME, false, consumer);

……

channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);

    例如：当获取到消息时，开始处理业务，这时有台计算机突然宕机了，此时这个消息并没有消费完。实际应当等业务逻辑处理完，在个服务端发出一个消息消费完表示。

    这里是在开发时要根据具体的应用场景选择不同的学习方法。

问题：能否选择性的接收消息。

    例如新增消息，对于前台系统就不需要，但对于搜寻系统就需要。那这样的情况下，是否能需要的信息才接收，不需要的不管。答案当然可以有。这就是路由模式。

5.路由模式

应用场景：将log4j的日志按级别分别存放到不同的队列中

（1）direct exchange


需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配，这是一个完整的匹配。如果一个队列绑定到该交换机上要求路由键“cow”，则只有被标记为“cow”的消息才能被转发，不会转发cat，也不会转发mouse，只会转发cow。


对于路由的这种结构，我们就可以将它应用在我们的项目中，前台系统只接收更新的消息，而检索可以接收新增和更新的消息。

（2）发消息

package com.rabbitmq.routing;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.util.ConnectionUtil;

public class Send {

    private final static String EXCHANGE_NAME = "test_exchange_direct";

    public static void main(String[] argv) throws Exception {
        // 获取到连接以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 声明exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");

        // 消息内容
        String message = "Hello World!";
        channel.basicPublish(EXCHANGE_NAME, "key2", null, message.getBytes());
        System.out.println(" [x] Sent '" + message + "'");

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

（3）消费者一

package com.rabbitmq.routing;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.util.ConnectionUtil;

public class Recv {

    private final static String QUEUE_NAME = "test_queue_direct_work";

    private final static String EXCHANGE_NAME = "test_exchange_direct";

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

        // 获取到连接以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

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

        // 绑定队列到交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "key");

        // 同一时刻服务器只会发一条消息给消费者
        channel.basicQos(1);

        // 定义队列的消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 监听队列，手动返回完成
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 获取消息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [x] Received '" + message + "'");
            Thread.sleep(10);

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

（4）消费者二

package com.rabbitmq.routing;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.util.ConnectionUtil;

public class Recv2 {

    private final static String QUEUE_NAME = "test_queue_direct_work2";

    private final static String EXCHANGE_NAME = "test_exchange_direct";

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

        // 获取到连接以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

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

        // 绑定队列到交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "key2");

        // 同一时刻服务器只会发一条消息给消费者
        channel.basicQos(1);

        // 定义队列的消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 监听队列，手动返回完成
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 获取消息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [x] Received '" + message + "'");
            Thread.sleep(10);

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

注意：在绑定时，设置路由KEY。

channel.queueBind(QUEUE_NAME, EXCHANGE_NAME,"key2");

（5）绑定结果

可以看到定义了一个路由KEY。


6.topic模式

（1）topic exchange

将路由键和某模式进行匹配。此时队列需要绑定在一个模式上。符合#匹配一个或多个词，符号*匹配不多不少一个词。

（2）发消息

package com.rabbitmq.topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.util.ConnectionUtil;

public class Send {

    private final static String EXCHANGE_NAME = "test_exchange_topic";

    public static void main(String[] argv) throws Exception {
        // 获取到连接以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

        // 声明exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");

        // 消息内容
        String message = "Hello World! topic";
        channel.basicPublish(EXCHANGE_NAME, "item.update", null, message.getBytes());
        System.out.println(" [x] Sent '" + message + "'");

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

（3）接收消息

package com.rabbitmq.topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.util.ConnectionUtil;

public class Recv {

    private final static String QUEUE_NAME = "test_queue_topic_work";

    private final static String EXCHANGE_NAME = "test_exchange_topic";

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

        // 获取到连接以及mq通道
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();

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

        // 绑定队列到交换机
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "item.#");

        // 同一时刻服务器只会发一条消息给消费者
        channel.basicQos(1);

        // 定义队列的消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 监听队列，手动返回完成
        channel.basicConsume(QUEUE_NAME, false, consumer);

        // 获取消息
        while (true) {
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();
            String message = new String(delivery.getBody());
            System.out.println(" [x] Received '" + message + "'");
            Thread.sleep(10);

            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    }
}

（4）绑定结果


源码：点击打开链接



tansuoliming
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rabbitMQ
AIGUO666666的博客
12-11 295
写在最前面： Kafka（高吞吐：十万级。延迟：毫秒级别） Kafka是LinkedIn开源的分布式发布-订阅消息系统，目前归属于Apache顶级项目。Kafka主要特点是基于Pull的模式来处理消息消费，追求高吞吐量（十万级），一开始的目的就是用于日志收集和传输。0.8版本开始支持复制，不支持事务，对消息的重复、丢失、错误没有严格要求，适合产生大量数据的互联网服务的数据收集业务。 Rabb...
rabbitmq
baishancha的博客
08-04 103
1.RabbitMQ是什么 实现了高级消息队列协议(AMQP)的开源消息代理软件(亦称面向消息的中间件)。RabbitMQ服务器是用erlang语言编写的，企业级消息代理软件。实现了服务之间的解耦 2.为什么要使用RabbitMQ 解耦、异步、削峰 在分布式系统下具备异步,削峰,负载均衡等一系列高级功能; 拥有持久化的机制，进程消息，队列中的信息也可以保存下来。 实现消费者和生产者之间的解耦。 对...
rabbitmq-server-3.4.1-1.noarch.rpm
04-29
rabbitmq-server-3.4.1-1.noarch.rpm安装包
centos7离线安装RabbitMQ
足迹人生的博客
01-06 291
centos7离线安装RabbitMQ
rabbitmq3.4.1安装教程以及配套软件.zip
08-29
rabbitmq3.4.1安装教程以及配套软件.zip
Rabbitmq安装以及遇到的坑
z63as的博客
06-07 1234
1、安装erlang 以root身份执行下面命令 yum install erlang yum install erlang xmlto 2、安装epel源 rpm -ivh http://download.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm wget -O /etc/yum.repos....
RabbitMQ-3.4.1安装手册
qq_34590943的博客
07-23 2209
1. 下载 下载地址：http://www.rabbitmq.com/download.html 2. windows下安装 2.1. 安装Erlang 下载：http://www.erlang.org/download/otp_win64_17.3.exe 安装：   安装完成。 2.2. 安装RabbitMQ   安装完成。
RabbitMQ
02-24
应用解耦、异步、流量削锋、数据分发、错峰流控、日志收集等等...MQ衡量标准服务性能、数据存储、集群架构主流竞品分析当前市面上mq的产品很多，比如RabbitMQ、Kafka、ActiveMQ、ZeroMQ和阿里巴巴捐献给Apache的...
RabbitMQ Server3.13.0
最新发布
04-02
**RabbitMQ Server 3.13.0** RabbitMQ 是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中高效地路由和传递消息。RabbitMQ 3.13.0 版本是其稳定版本之一...
rabbitmqadmin
07-08
RabbitMQ命令行手动创建队列rabbitmqadmin用法 手动创建队列方法：登录http://ip:15672/cli下载 将下载的rabbitmqadmin放到/usr/sbin目录下，并赋予权限：chmod 755 rabbitmqadmin 查看命令帮助信息： python ...
RabbitMQ-3.4.1安装文件.rar
08-02
RabbitMQ-3.4.1安装文件.rar
rabbitmq-server-3.4.1
04-04
rabbitmq-server-3.4.1-1.noarch.rpm rabbitmq-server-3.4.1-1.noarch.rpm
rabbitmq3.4.4版本rpm包
01-02
rabbitmq3.4.4版本rpm包,用于中间件消息通信，有需要的请下载
rabbitmq-server-3.7.2-1.el7.noarch.rpm
01-18
linux环境下消息队列安装包 rabbitmq-server-3.7.2-1.el7.noarch.rpm
rabbitmq-server-3.5.6-1.noarch.rpm
11-27
rabbitmq-server-3.5.6-1.noarch.rpm官网下载
rabbitmq开发规范
07-04
**RabbitMQ开发规范详解** 在使用RabbitMQ进行分布式消息传输时，遵循一定的开发规范至关重要，这不仅可以提高系统的可维护性，也有助于保证数据的一致性和稳定性。本篇文章将详细阐述RabbitMQ的命名规范、消息传输...
rabbitmq3.10.4
06-07
RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中的消息传递。它基于AMQP（Advanced Message Queuing Protocol）协议，为多种编程语言提供API，使得开发人员能够轻松地实现消息的发送和接收。在...
RabbitMQ 3.4.1 安装教程
Tui_GuiGe的专栏
04-08 608
RabbitMQ 详细安装教程
RabbitMQ介绍、以及RabbitMQ的详细安装步骤
weixin_66479402的博客
08-31 348
RabbitMQ介绍、以及RabbitMQ的详细安装步骤
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值