rabbitMq

最新推荐文章于 2022-07-07 16:21:43 发布
最新推荐文章于 2022-07-07 16:21:43 发布
阅读量256 收藏
点赞数
分类专栏： 名称解释

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）绑定结果


源码：点击打开链接



rabbitmq-server-3.4.1-1.noarch.rpm
04-29
rabbitmq-server-3.4.1-1.noarch.rpm安装包
rabbitmq-server-3.4.1
04-04
rabbitmq-server-3.4.1-1.noarch.rpm rabbitmq-server-3.4.1-1.noarch.rpm
rabbitmq-server-3.7.4-1.el7.noarch.rpm
04-26
rabbitmq-server-3.7.4-1.el7.noarch.rpm 免积分下载
RabbitMQ-3.4.1安装文件.rar
08-02
RabbitMQ-3.4.1安装文件.rar
rabbitmq-server-3.8.0-1.el7.noarch.rpm
12-24
rabbitmq-server-3.8.0-1.el7.noarch.rpm 企业高可用消息队列服务安装包。
RabbitMQ自动发送消息软件(自动化测试RabbitMQ)
11-06
它集成了 RabbitMQ 连接配置、消息自动生成配置以及日志记录功能，能够按照预设的时间间隔和总次数自动发送 RabbitMQ 消息。消息内容支持多种随机生成类型，包括日期、序列号、Mac 地址、整数和浮点数。此外，程序还...
RabbitMQ Server3.13.0
04-02
**RabbitMQ Server 3.13.0** RabbitMQ 是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中高效地路由和传递消息。RabbitMQ 3.13.0 版本是其稳定版本之一...
Erlang和RabbitMQ安装包
02-22
Erlang和RabbitMQ是两个在分布式系统和消息队列领域中至关重要的技术。Erlang是一种函数式编程语言，以其并发性、容错性和热代码升级能力而闻名，而RabbitMQ则是基于Erlang构建的一个开源消息代理，用于实现应用程序...
kettle rabbitmq 插件开发
10-26
标题 "kettle rabbitmq 插件开发" 涉及的是如何在 Pentaho Kettle（也称为 Spoon）中创建和使用 RabbitMQ 插件。Kettle 是一个开源的数据集成工具，它允许用户进行数据抽取、转换和加载（ETL）操作。RabbitMQ 是一个...
rabbitMQ实战java版-rabbitMQ-demo.zip
11-07
《RabbitMQ实战Java版——基于rabbitMQ-demo.zip的详解》 在当今的分布式系统中，消息队列作为异步处理、解耦组件的关键技术，得到了广泛应用。RabbitMQ作为一款开源的消息代理和队列服务器，以其稳定性和易用性...
rabbitmq-server-3.7.7-1.el6.noarch.rpm
04-08
对应的erlang版本为otp_src_21.0.tar.gz 。RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。
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.1.noarch.rpm
08-20
rabbitmq is a very nice message queue.
rabbitmq-server-3.5.6-1.noarch.rpm
11-27
rabbitmq-server-3.5.6-1.noarch.rpm官网下载
rabbitmq-server-3.6.5-1.noarch.rpm
09-06
rabbitmq-server-3.6.5-1.noarch.rpm
Centos7 安装 RabbitMQ-3.4.1
书启鸿蒙知秋枫
07-07 608
② 输入命令 vi rabbitmq.config。① 输入命令 cd /etc/rabbitmq。rabbitmq从3.3.0开始, 默认用户。这一步可以不做，如果登录不了再配这个。
centos7 安装rabbitmq3.4.1-1
TesterLiao的专栏
12-18 365
centos7 安装rabbitmq3.4.1-1   安装环境：centos7版本     一、rabbitmq3.4.1-1安装环境配置： 安装erlang 1、创建Yum源 #创建yum源 sudo vi /etc/yum.repos.d/rabbitmq-erlang.repo #文件内容 [rabbitmq-e...
在Linux中RabbitMQ 3.4.1 安装
许进|沉思录
01-29 507
1.Linux下安装1.1.安装Erlang1.1.1.添加yum支持cd /usr/local/src/mkdir rabbitmqcd rabbitmq wget http://packages.erlang-solutions.com/erlang-solutions-1.0-1.noarch.rpmrpm -Uvh erlang-solutions-1.0-1.noarch.rpm ...
Centos6 下离线安装配置rabbitmq(3.4.1版本)(一)
xingxing12323的博客
04-01 788
文章目录一、安装资源文件的位置共享二、安装erlang环境三、安装rabbitmq四、修改配置文件，配置管理端五、添加用户和虚拟机并且设置权限添加用户添加虚拟机![在这里插入图片描述](https://img-blog.csdnimg.cn/20200401171846958.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,sh...
rabbitmQ
最新发布
04-12
### RabbitMQ 使用指南和教程 #### 安装 RabbitMQ RabbitMQ 是一种基于 AMQP 协议的消息中间件，用于实现分布式系统的可靠消息传递。以下是安装 RabbitMQ 的基本流程： 1. **安装 Erlang** RabbitMQ 基于 Erlang 编程语言开发，因此需要先安装 Erlang 运行环境。可以通过包管理器或者下载官方二进制文件完成安装。 2. **安装 RabbitMQ Server** 下载并安装 RabbitMQ Server 软件包。对于 Linux 用户，可以使用以下命令： ```bash sudo apt-get install rabbitmq-server ``` 3. **启动服务** 启动 RabbitMQ 服务后，默认监听端口为 `5672`（AMQP 协议），Web 管理界面默认运行在 `15672` 端口上。 ```bash sudo systemctl start rabbitmq-server ``` 4. **启用 Web 管理插件** 可通过以下命令启用 RabbitMQ 提供的 Web 管理工具： ```bash sudo rabbitmq-plugins enable rabbitmq_management ``` --- #### 配置用户与权限 为了安全访问 RabbitMQ 实例，通常需要创建自定义用户并分配相应权限。 - 创建新用户： ```bash rabbitmqctl add_user rabbitmq 211314 ``` 此操作会新增名为 `rabbitmq` 的用户，并将其密码设为 `211314`[^1]。 - 设置用户角色： ```bash rabbitmqctl set_user_tags rabbitmq administrator ``` 将该用户的标签设定为管理员角色，使其拥有完全控制权[^1]。 - 授予用户权限： ```bash rabbitmqctl set_permissions -p "/" rabbitmq ".*" ".*" ".*" ``` 上述命令授予用户对根虚拟主机 `/` 中所有资源的操作权限[^1]。 - 查看现有用户及其角色： ```bash rabbitmqctl list_users ``` --- #### 集群配置 RabbitMQ 支持多种集群模式来提升可用性和性能。主要分为两类：普通模式和镜像模式。 - **普通模式** 在这种模式下，各节点独立存储队列中的数据和其他元信息（如交换机）。当客户端尝试消费某个不在当前连接节点上的消息时，目标节点会被请求转发所需的数据[^2]。 - **镜像模式** 对比之下，在镜像模式中，指定队列的内容将在多个节点间保持一致副本。即使部分成员失效，剩余存活节点仍能继续提供完整的服务功能[^2]。 > 注意事项：尽管镜像模式提高了可靠性，但也带来了额外开销——网络流量增加以及写入延迟上升等问题需被充分考虑进去。 --- #### 应用集成示例 假设要在一个 Java 或 Python 应用程序里利用 RabbitMQ 来发送/接收消息，则可能涉及以下几个步骤： 1. **声明交换器 (Exchange)** 和绑定关系： ```java channel.exchangeDeclare(exchangeName, "direct", true); channel.queueDeclare(queueName, true, false, false, null); channel.queueBind(queueName, exchangeName, routingKey); ``` 如此一来便完成了持久化队列及路由键关联工作[^3]。 2. 发布一条测试消息至上述已建立好的通道路径之中； 3. 订阅对应主题下的事件流以便实时捕获最新动态更新情况； --- #### 总结 以上涵盖了从基础安装到高级特性使用的整个过程概述。希望这些指导能够帮助您快速掌握如何部署与维护属于自己的 RabbitMQ 平台实例！ 问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值