RabbitMQ简介

l  JAVA平台异步消息模块

JAVA平台异步消息模块，是一个针对RabbitMQ的消息发送及处理封装，包含消息的配置、发送、接收、失败重试、日志记录等，总共分为4个部分：

1)RabbitMQ访问封装:JAMQP（Jar包）

2)消息模块公共对象、配置读取及接口定义：JMSG（Jar包）

3)消息发送端：JMSG—Client（Jar包）

4)消息接收端：JMSG—Server（War包）

l  RabbitMQ简介

MQ是消费-生产者模型的一个典型的代表，一端往消息队列中不断的写入消息，而另一端则可以读取或者订阅队列中的消息。RabbitMQ是一个在AMQP基础上完整的，可复用的企业消息系统。他遵循Mozilla Public License开源协议。RabbitMQ是流行的开源消息队列系统，用erlang语言开发。RabbitMQ是 AMQP的标准实现。

RabbitMQ的结构图如下：

 

Exchange：消息交换机，它指定消息按什么规则，路由到哪个队列。

Alternate exchange：发送给某Exchange的消息路由失败时，发送至该exchange。

Dead letter exchange：死信Exchange，将超过一定时间的Queue中的消息发送至该exchange。

Queue：消息队列载体，每个消息都会被投入到一个或多个队列。

Binding：绑定，它的作用就是把Exchange和Queue按照路由规则绑定起来。

Routing Key：路由关键字，Exchange根据这个关键字进行消息投递。

channel：消息通道，在客户端的每个连接里，可建立多个channel，每个channel代表一个会话任务。

l  RabbitMQ封装

1） RabbitConfig ：所有RabbitMQ有关配置

2） RabbitConnectPool ：RabbitMQ连接池，管理所有对RabbitMQ的连接

3） RabbitProxy ：RabbitMQ连接的封装，包含

4） RabbitSendProxy : 专门用于发送消息的连接，继承自RabbitProxy

5） RabbitReceiveProxy ：专门用于接收消息的连接，继承自RabbitProxy

6） RabbitReceiverDispatcher ： 消息分发器管理类，用于消息的接

7） 消息发送：从连接池RabbitConnectPool中Get出RabbitSendProxy，调用send方法发送消息，return获得的RabbitSendProxy。发送失败的消息记录本地文件，由轮询线程获取消息后重试3次

8） 消息接收：服务启动时向RabbitReceiverDispatcher注册要监听的队列，每一个监听对应一个线程以及一个处理消息的线程池，从RabbitMQ获取到推送来的消息后，通过线程池并行处理

l  内部流程

n  消息发送逻辑

 

n  消息接收逻辑

 

l  配置说明

n  RabbitMQ配置表

n  消息配置表

1） MessageName ： 消息名称，MessageConfig表中唯一

2） Url : 消息的业务处理Http API地址

3） Priority ： 消息优先级，必须写成P1,P2,P3....P8,P9，用于RabbitMQ的RouteKey，发送消息时的最终RouteKey = MessageName.Priority

l  使用方法

n  发送消息

消息发送方法定义：

    /**

     * 发送消息

     * @param transferObject

     *  消息主体对象

     * @param customTag

     *  自定义消息标签

     * @param messageName

     *  消息名称

     */

    void send(Object transferObject, String customTag, String messageName);

在消息配置表中配置好消息的信息，引用JMSG和JMSG-Client 两个Jar包，调用方法如下：

   public void SendMsg() {

              RabbitMQSender sender = new RabbitMQSender();

             sender.send(new Object(), "tag", "messageName");

      }

注意：传输的对象（transferObject）进行JSON序列化后，大小不能超过64K，否则会抛出异常

n  接收消息

1） 实现一个能够接收Post请求的Http API，Post请求参数形式如下：

   NameValuePair[] data = {

         new NameValuePair("message", message.getTransferObjectJSON()),

         new NameValuePair("messageName", message.getMessageName()),

         new NameValuePair("tag", message.getCustomTag()),

};

 

2） 该API的返回值要求为JSON串，内容要求如下（responseCode：0表示处理成功，小于0表示系统异常，大于0表示业务异常）：

"{exceptionMessgage:null, responseCode:0}"

3） 将该API的Url配置到MessageConsumersConfig表中

下面是一个简单的实例：

     @Controller

      public class ConsumerController {

 

      private static final Logger logger = Logger.getLogger(ConsumerController.class);

 

      @RequestMapping(value = "testmsgconsumer", method=RequestMethod.POST)

      @ResponseBody

      public String LogMessage(HttpServletRequest request) {

         logger.info(request.getParameter("messageName") + "(" + request.getParameter("tag") + "): " + request.getParameter("message"));

         return "{exceptionMessgage:null, responseCode:0}";

      }

   }

RabbitMQ组成及原理介绍

rabbitmq作为成熟的企业消息中间件，实现了应用程序间接口调用的解耦，提高系统的吞吐量。

1.RabbitMQ组成

  • 是由 LShift 提供的一个 Advanced Message Queuing Protocol (AMQP) 的开源实现，由以高性能、健壮以及可伸缩性出名的 Erlang 写成，因此也是继承了这些优点。
  • AMQP 里主要要说两个组件：Exchange 和 Queue （在 AMQP 1.0 里还会有变动），如下图所示，绿色的 X 就是 Exchange ，红色的是 Queue ，这两者都在 Server 端，又称作 Broker ，这部分是 RabbitMQ 实现的，而蓝色的则是客户端，通常有 Producer 和 Consumer 两种类型：

 

 

  •  RabbitMQ Server： 也叫broker server，它不是运送食物的卡车，而是一种传输服务。原话是RabbitMQ isn’t a food truck, it’s a delivery service. 他的角色就是维护一条从Producer到Consumer的路线，保证数据能够按照指定的方式进行传输。但是这个保证也不是100%的保证，但是对于普通的应用来说这已经足够了。当然对于商业系统来说，可以再做一层数据一致性的guard，就可以彻底保证系统的一致性了。
  • Client A & B： 也叫Producer，数据的发送方。create messages and publish (send) them to a broker server (RabbitMQ).一个Message有两个部分：payload（有效载荷）和label（标签）。payload顾名思义就是传输的数据。label是exchange的名字或者说是一个tag，它描述了payload，而且RabbitMQ也是通过这个label来决定把这个Message发给哪个Consumer。AMQP仅仅描述了label，而RabbitMQ决定了如何使用这个label的规则。
  • Client 1，2，3：也叫Consumer，数据的接收方。Consumers attach to a broker server (RabbitMQ) and subscribe to a queue。把queue比作是一个有名字的邮箱。当有Message到达某个邮箱后，RabbitMQ把它发送给它的某个订阅者即Consumer。当然可能会把同一个Message发送给很多的Consumer。在这个Message中，只有payload，label已经被删掉了。对于Consumer来说，它是不知道谁发送的这个信息的。就是协议本身不支持。但是当然了如果Producer发送的payload包含了Producer的信息就另当别论了。

  对于一个数据从Producer到Consumer的正确传递，还有三个概念需要明确：exchanges, queues and bindings。

  • Exchanges are where producers publish their messages.
  • Queues are where the messages end up and are received by consumers
  • Bindings are how the messages get routed from the exchange to particular queues.

   还有几个概念是上述图中没有标明的，那就是Connection（连接），Channel（通道，频道）。

  • Connection： 就是一个TCP的连接。Producer和Consumer都是通过TCP连接到RabbitMQ Server的。以后我们可以看到，程序的起始处就是建立这个TCP连接。
  • Channels： 虚拟连接。它建立在上述的TCP连接中。数据流动都是在Channel中进行的。也就是说，一般情况是程序起始建立TCP连接，第二步就是建立这个Channel。

  •  那么，为什么使用Channel，而不是直接使用TCP连接？

        对于OS来说，建立和关闭TCP连接是有代价的，频繁的建立关闭TCP连接对于系统的性能有很大的影响，而且TCP的连接数也有限制，这也限制了系统处理高并发的能力。但是，在TCP连接中建立Channel是没有上述代价的。对于Producer或者Consumer来说，可以并发的使用多个Channel进行Publish或者Receive。有实验表明，1s的数据可以Publish10K的数据包。当然对于不同的硬件环境，不同的数据包大小这个数据肯定不一样，但是我只想说明，对于普通的Consumer或者Producer来说，这已经足够了。如果不够用，你考虑的应该是如何细化split你的设计。

Exchange

Exchange是属于Vhost的。同一个Vhost不能有重复的Exchange名称。 Exhange有四种类型：fanout，Direct，header，topic。

Exchange接受Producer发送的Message并根据不同路由算法将Message发送到Message Queue。

　 从架构图可以看出，Procuder Publish的Message进入了Exchange。接着通过“routing keys”， RabbitMQ会找到应该把这个Message放到哪个queue里。queue也是通过这个routing keys来做的绑定。

    Exchange的绑定功能，可以绑定queue，也可以绑定Exchange。这个看具体业务了。如果绑定数据，需要在分发或者重新被分派，使用To Exchange绑定。如果要被直接处理，使用queue绑定。如果Exchange绑定了Queue，如果Route Key不对，也会导致数据不可达，被丢掉。（一个数据可以被Queue处理，需要Exchange绑定Queue，并且在Message发送的时候，Route Key 与绑定的Key相等。我们发送一个空数据，Route Key随便制定了Hello，消息虽然发送，但是客户获得失败。

 

    有四种类型的Exchanges：direct, fanout,topic。 每个实现了不同的路由算法（routing algorithm）。

  • Direct exchange: 如果 routing key 匹配, 那么Message就会被传递到相应的queue中。其实在queue创建时，它会自动的以queue的名字  作为routing key来绑定那个exchange。(转发消息到routigKey指定的队列)
  • Fanout exchange: 会向响应的queue广播。(转发消息到所有绑定队列)
  • Topic exchange: 对key进行模式匹配，比如ab*可以传递到所有ab*的queue。(按规则转发消息（最灵活）)

 Queue：

　　Message Queue会在Message不能被正常消费时将其缓存起来，但是当Consumer与Message Queue之间的连接通畅时，Message Queue将Message转发给Consumer。
    Message由Header和Body组成，Header是由Producer添加的各种属性的集合，包括Message是否客被缓存、由哪个Message Queue接受、优先级是多少等。而Body是真正需要传输的APP数据。
    Exchange与Message Queue之间的关联通过Binding来实现。Exchange在与多个Message Queue发生Binding后会生成一张路由表，路由表中存储着Message Queue所需消息的限制条件即Binding Key。当Exchange收到Message时会解析其Header得到Routing Key，Exchange根据Routing Key与Exchange Type将Message路由到Message Queue。

　　Binding Key由Consumer在Binding Exchange与Message Queue时指定，而Routing Key由Producer发送Message时指定，两者的匹配方式由Exchange Type决定。
    Exchange Type分为Direct（单播）、Topic（组播）、Fanout（广播）。当为Direct（单播）时，Routing Key必须与Binding Key相等时才能匹配成功，当为Topic（组播）时，Routing Key与Binding Key符合一种模式关系即算匹配成功，当为Fanout（广播）时，不受限制。默认Exchange Type是Direct（单播）。

routing：exchange和queue之间绑定的媒介，成为routing key。

message acknowledgment: 消息确认，解决消息确认问题，只有收到ack之后才能从消息系统中删除。

message durability: 消息持久化，当rabbitmq退出或崩溃后，会把queue中的消息持久化。但注意，RabbitMQ并不能百分之百保证消息一定不会丢失，因为为了提 升性能，RabbitMQ会把消息暂存在内存缓存中，直到达到阀值才会批量持久化到磁盘，也就是说如果在持久化到磁盘之前RabbitMQ崩溃了，那么就 会丢失一小部分数据，这对于大多数场景来说并不是不可接受的，如果确实需要保证任务绝对不丢失，那么应该使用事务机制。

Virtual hosts

   每个virtual host本质上都是一个RabbitMQ Server，拥有它自己的queue，exchange，和bind rule等等。这保证了你可以在多个不同的application中使用RabbitMQ。

　RabbitMQ的Vhost主要是用来划分不同业务模块。不同业务模块之间没有信息交互。Vhost之间相互完全隔离，不同Vhost之间无法共享Exchange和Queue。因此Vhost之间数据无法共享和分享。如果要实现这种功能，需要Vhost之间手动构建对应代码逻辑。

 

    Vhost其实在用户之间是透明的，Vhost可以被多个用户访问，而一个用户可以同时访问多个Vhost。 例如：peter可以同时访问"/"和"/vhost"。

    Virtual Host是个虚拟概念，可以持有一些Exchange和Message Queue。一个Virtual Host可以是一台服务器，也可以是由多台服务器组成的集群。Exchange和Message Queue可以分别部署在一台或者多台服务器上。

第三章 启动rabbitmq的webUI

一、启动步骤

1、启动rabbitmq

  • rabbitmq-server （前台启动）或者rabbitmq-server -detached（后台启动）

2、启动rabbitmq_management

  • rabbitmq-plugins enable rabbitmq_management

执行命令后启动的插件：

3、浏览器登入

http://localhost:15672/打开登录页使用{username:"guest",password:"guest"}登入。

 

二、webUI包含的监视项

  • overview页面：可以看到消息的接收和消费情况以及如下的其他一些总控的部分

　　

  • connections：tcp连接
  • channels：信道：一个connection内可以有多个channel，一个channel供一个线程使用
  • exchanges：交换器：消息生成者发送消息到交换器，最后交换器中的消息通过路由规则到达绑定的队列中供消费者使用
  • queues：队列：消息的最终到达地点。也是消费者获取消息的地方
  • admin：权限部分、用户列表、虚拟主机部分（虚拟主机与rabbitmq的关系就与虚拟机与物理机的关系一样）

三、注意点

我使用的是rabbitmq3.6.1，在这个版本登录webUI的话，有下面几种情况：

1、使用默认的guest登录

http://localhost:15672/，只能用localhost，不能写成具体的IP，包括127.0.0.1，包括当前的本机IP（这是>=3.3.0版本引入的功能）

2、自己创建用户进行登录

2.1、添加用户及密码

  • rabbitmqctl add_user zhaojigang wangna（添加了用户zhaojigang，密码是wangna）

2.2、设置用户角色

  • rabbitmqctl set_user_tags zhaojigang administrator（将用户zhaojigang设为administrator）

查看一下用户列表：

  • rabbitmqctl list_users

　　

2.3、登录webUI

http://192.168.23.238:15672/登录即可。

注意：必须为用户设置角色，否则可能无法登陆进入。各种角色、各种权限查看下文：

http://my.oschina.net/hncscwc/blog/262246

 

附：设置指定用户在指定虚拟主机上的配置、读、写权限

  • 添加虚拟主机：rabbitmqctl add_vhost zhaojigangvhost
  • 设置指定用户在指定虚拟主机上的配置、读、写权限： rabbitmqctl set_permissions -p zhaojigangvhost zhaojigang ".*" ".*" ".*"（设置用户zhaojigang在虚拟主机zhaojigangvhost的配置权限、写权限、读权限）

配置了这些权限后，zhaojigang在zhaojigangvhost上才有权限进行配置、读、写。

第四章 第一个rabbitmq程序

rabbitmq消息发送模型

要素：

  • 生产者
  • 消费者
  • 交换器：生产者将消息发送到交换器
  • 队列：交换器通过某种路由规则绑定到指定队列，将消息加入队列，消费者从队列消费消息

前提：

引入rabbitmq的java客户端jar包

        <!-- import rabbitmq/amqp-client -->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>3.5.6</version>
        </dependency>

 

一、消息生产者

1、代码：

 1 package com.xxx.producer;
 2 
 3 import java.io.IOException;
 4 import java.util.concurrent.TimeoutException;
 5 
 6 import com.rabbitmq.client.Channel;
 7 import com.rabbitmq.client.Connection;
 8 import com.rabbitmq.client.ConnectionFactory;
 9 
10 /**
11  * 消息生产者
12  */
13 public class HelloWorldProducer {
14     private static final String QUEUE_NAME    = "helloQueue";
15     private static final String EXCHANGE_NAME = "helloExchange";
16 
17     public static void main(String[] args) throws IOException, TimeoutException {
18         ConnectionFactory factory = new ConnectionFactory();// 建立连接工厂
19         factory.setHost("192.168.20.238");// 设置rabbitmq服务器地址
20         factory.setPort(5672);// 设置rabbitmq服务器端口
21         factory.setUsername("zhaojigang");
22         factory.setPassword("wangna");
23         factory.setVirtualHost("zhaojigangvhost");
24 
25         Connection connection = factory.newConnection();// 建立连接
26         Channel channel = connection.createChannel();// 建立信道
27 
28         /**
29          * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
30          * durable:队列是否持久化
31          * exclusive：当最后一个消费者取消订阅时，是否自动删除
32          * autoDelete：只有当前应用程序才能够消费队列消息（场景：限制一个队列只有一个消费者）
33          * arguments：other properties (construction arguments) for the queue
34          */
35         channel.queueDeclare(QUEUE_NAME, false, false, false, null);// 创建队列（如果队列不存在，创建；如果存在，什么都不做）
36         /**
37          * exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Map<String, Object> arguments)
38          * exchange:交换器名字
39          * type：3种类型 direct/fanout/topic
40          */
41         channel.exchangeDeclare(EXCHANGE_NAME, "direct", false, false, null);
42 
43         for (int i = 0; i < 10; i++) {
44             String msg = "helloworld_" + i;// 创建消息
45             /**
46              * basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
47              * exchange：交换器
48              * routingKey：路由键
49              * props：other properties for the message - routing headers etc
50              * body：消息体
51              */
52             channel.basicPublish(EXCHANGE_NAME, QUEUE_NAME, null, msg.getBytes());// 发布消息
53             System.out.println("发送消息：msg-->" + msg);
54         }
55 
56         channel.close();// 关闭信道
57         connection.close();// 关闭连接
58     }
59 }

2、步骤：

  • 创建并设置连接工厂
    • host、port、username、password、vhost
    • 值得注意的是，一定要现在rabbitmq server上把username和password设置好，并且开启该用户在指定vhost上的权限，才可以设置连接工厂成功
  • 创建连接
  • 创建信道
  • 创建队列
  • 创建交换器
  • 创建（创建之后也可以配置消息）并发送消息
  • 关闭信道
  • 关闭连接

3、注意点：

  • queueDeclare方法：如果队列不存在，创建；如果存在，什么都不做

  • basicPublish：发布消息到指定的交换器，并制定路由规则（用于消费者部分的绑定操作）

 

二、消息消费者

1、代码：

 1 package com.xxx.consumer;
 2 
 3 import java.io.IOException;
 4 import java.util.concurrent.TimeoutException;
 5 
 6 import com.rabbitmq.client.Channel;
 7 import com.rabbitmq.client.Connection;
 8 import com.rabbitmq.client.ConnectionFactory;
 9 import com.rabbitmq.client.Consumer;
10 import com.rabbitmq.client.DefaultConsumer;
11 import com.rabbitmq.client.Envelope;
12 import com.rabbitmq.client.AMQP.BasicProperties;
13 
14 /**
15  * 消息消费者
16  */
17 public class HelloWorldConsumer {
18     private final static String QUEUE_NAME = "helloQueue";
19     private static final String EXCHANGE_NAME = "helloExchange";
20 
21     public static void main(String[] args) throws IOException, TimeoutException {
22         ConnectionFactory factory = new ConnectionFactory();// 建立连接工厂
23         factory.setHost("192.168.20.238");// 设置rabbitmq服务器地址
24         factory.setPort(5672);// 设置rabbitmq服务器端口
25         factory.setUsername("zhaojigang");
26         factory.setPassword("wangna");
27         factory.setVirtualHost("zhaojigangvhost");
28 
29         Connection connection = factory.newConnection();// 建立连接
30         Channel channel = connection.createChannel();// 建立信道
31 
32         /**
33          * Note that we declare the queue here, as well. 
34          * Because we might start the receiver before the sender, 
35          * we want to make sure the queue exists before we try to consume messages from it.
36          */
37         channel.queueDeclare(QUEUE_NAME, false, false, false, null);// 创建队列（如果队列不存在，创建；如果存在，什么都不做）
38         channel.exchangeDeclare(EXCHANGE_NAME, "direct", false, false, null);
39         /**
40          * queueBind(String queue, String exchange, String routingKey)
41          */
42         channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, QUEUE_NAME);
43         Consumer consumer = new DefaultConsumer(channel){
44             @Override
45             public void handleDelivery(String consumerTag, 
46                                        Envelope envelope, 
47                                        BasicProperties properties,
48                                        byte[] body) throws IOException {
49                 String msg = new String(body,"UTF-8");
50                 System.out.println("接收消息：msg-->" + msg);
51             }
52         };54             /**
55              * basicConsume(String queue, boolean autoAck, Consumer callback)
56              * autoAck true if the server should consider messages acknowledged once delivered; 
57              * false if the server should expect explicit acknowledgements
　　　　　　　　　 * 这里启动一个consume，该consume会不断的接收消息，如果此处用while(true)包起来的话，就会不断的启动consume
58              */
59           channel.basicConsume(QUEUE_NAME, true, consumer);61         
62 //        channel.close();// 关闭信道
63 //        connection.close();// 关闭连接
64     }
65 }

2、步骤：

  • 创建并设置连接工厂
    • host、port、username、password、vhost
  • 创建连接
  • 创建信道
  • 创建队列
  • 创建交换器
  • 通过路由规则绑定队列和交换器
  • 创建消息处理函数
  • 从队列获取消息并消费消息（根据消息处理函数） 

三、测试

1、启动rabbitmq服务器

2、启动消费者进程

3、启动生产者进程

4、查看console即可或者查看rabbitmq的webUI

多个消费者监听同一个队列

生产者：代码如上一章

消费者1：代码如前一章

消费者2：与消费者1代码完全相同

注意：此时，消费者1和2监听在同一个队列上，队列会以轮训的方式将10个消息分别交给消费者1和2进行处理。

但是这种情况下，如果消费者1处理的消息比较繁重，而消费者2处理的消息比较轻松地话，实际上应该让消费者2多处理一些消息，在消费者代码添加中如下代码：

        /**
         * basicQos(int prefetchCount)
         * prefetchCount:maximum number of messages that the server will deliver, 0 if unlimited
         */
     channel.basicQos(1);//阻止rabbitmq将消息平均分配到每一个消费者，会优先的发给不忙的消费者，如果当前的消费者在忙的话，就将消息分配给下一个消费者
 

附1 rabbitmq常用命令

1、rabbitmq的启动和停止

  • rabbitmq-server （前台启动）
  • rabbitmq-server -detached（后台启动）
  • rabbitmqctl stop（停止）

2、查看rabbitmq的状态

  • rabbitmqctl status

3、用户管理

  • rabbitmqctl add_user zhaojigang wangna（添加用户zhaojigang，密码是wangna）
  • rabbitmqctl delete_user zhaojigang（删除用户zhaojigang）
  • rabbitmqctl list_users（列出所有用户名及其角色）
  • rabbitmqctl change_password zhaojigang wangna2（修改zhaojigang的密码为wangna2）

4、用户角色管理（5类角色）

5、虚拟主机vhost管理

  • rabbitmqctl list_vhosts（列出所有的虚拟主机）
  • rabbitmqctl add_vhost zhaojigangvhost（添加虚拟主机zhaojigangvhost）
  • rabbitmqctl delete_vhost zhaojigangvhost（删除虚拟主机zhaojigangvhost）

6、用户权限管理（3种权限）

  • rabbitmqctl set_permissions -p zhaojigangvhost zhaojigang ".*" ".*" ".*"（设置用户zhaojigang在虚拟主机zhaojigangvhost的配置权限、写权限、读权限）

  • rabbitmqctl set_permissions [-p vhost] {user} {conf} {write} {read}

附2 rabbitmq用户管理、角色管理与权限管理

本文摘自：http://my.oschina.net/hncscwc/blog/262246

1. 用户管理

用户管理包括增加用户，删除用户，查看用户列表，修改用户密码。

相应的命令

(1) 新增一个用户

rabbitmqctl  add_user  Username  Password

(2) 删除一个用户

rabbitmqctl  delete_user  Username

(3) 修改用户的密码

rabbitmqctl  change_password  Username  Newpassword

(4) 查看当前用户列表

rabbitmqctl  list_users

2. 用户角色

按照个人理解，用户角色可分为五类，超级管理员, 监控者, 策略制定者, 普通管理者以及其他。

(1) 超级管理员(administrator)

可登陆管理控制台(启用management plugin的情况下)，可查看所有的信息，并且可以对用户，策略(policy)进行操作。

(2) 监控者(monitoring)

可登陆管理控制台(启用management plugin的情况下)，同时可以查看rabbitmq节点的相关信息(进程数，内存使用情况，磁盘使用情况等)

(3) 策略制定者(policymaker)

可登陆管理控制台(启用management plugin的情况下), 同时可以对policy进行管理。但无法查看节点的相关信息(上图红框标识的部分)。

与administrator的对比，administrator能看到这些内容

(4) 普通管理者(management)

仅可登陆管理控制台(启用management plugin的情况下)，无法看到节点信息，也无法对策略进行管理。

(5) 其他

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

了解了这些后，就可以根据需要给不同的用户设置不同的角色，以便按需管理。

设置用户角色的命令为：

rabbitmqctl  set_user_tags  User  Tag

User为用户名， Tag为角色名(对应于上面的administrator，monitoring，policymaker，management，或其他自定义名称)。

也可以给同一用户设置多个角色，例如

rabbitmqctl  set_user_tags  hncscwc  monitoring  policymaker

3. 用户权限

用户权限指的是用户对exchange，queue的操作权限，包括配置权限，读写权限。配置权限会影响到exchange，queue的声明和删除。读写权限影响到从queue里取消息，向exchange发送消息以及queue和exchange的绑定(bind)操作。

例如： 将queue绑定到某exchange上，需要具有queue的可写权限，以及exchange的可读权限；向exchange发送消息需要具有exchange的可写权限；从queue里取数据需要具有queue的可读权限。详细请参考官方文档中"How permissions work"部分。

相关命令为：

(1) 设置用户权限

rabbitmqctl  set_permissions  -p  VHostPath  User  ConfP  WriteP  ReadP

(2) 查看(指定hostpath)所有用户的权限信息

rabbitmqctl  list_permissions  [-p  VHostPath]

(3) 查看指定用户的权限信息

rabbitmqctl  list_user_permissions  User

(4)  清除用户的权限信息

rabbitmqctl  clear_permissions  [-p VHostPath]  User

posted @ 2021-12-24 15:29  hanease  阅读(2954)  评论(0)  编辑  收藏  举报