RabbitMQ安装使用详解

1.下载相应的版本安装：
http://www.rabbitmq.com/download.html
eg:http://www.rabbitmq.com/releases/rabbitmq-server/v3.5.1/rabbitmq-server_3.5.1-1_all.deb

2.安装web管理插件
rabbitmq在ubuntu下路径：
/etc/rabbitmq 
/usr/lib/rabbitmq
eg:
cd /usr/lib/rabbitmq/bin
sudo rabbitmq-plugins enable rabbitmq_management

3.打开rabbitmq
重启：sudo service rabbitmq-server restart
启动：sudo service rabbitmq-server start
关闭： sudo service rabbitmq-server stop
查看状态：sudo service rabbitmqctl status

4.web控制台
http://127.0.0.1:15672/ 
用户名：guest 
密码：guest

5.客户端测试
https://github.com/sdyy321/rabbitmq-client/archive/master.zip
详解见：

http://blog.csdn.net/sdyy321/article/details/9241445

---------------------------------------------------------------------------------------------

方法二：使用APT来装
1.添加以下地址到/etc/apt/sources.list
deb http://www.rabbitmq.com/debian/ testing main

2.添加public key：在命令行窗口中输入：
$ wget http://www.rabbitmq.com/rabbitmq-signing-key-public.asc 
$ sudo apt-key add rabbitmq-signing-key-public.asc

3.$ sudo apt-get update

4.$ sudo apt-get install rabbitmq-server

在rabbitmq安装的过程中，需要用到erlang，使用以上方法安装时，都可以自动安装这些必要的包

一些常用的命令
服务器相关命令：
启动：sudo rabbitmq-server start
关闭： sudo rabbitmq-server stop
查看状态：sudo rabbitmqctl status

注意新版本的问题：

安装最新版本的rabbitmq(3.3.1)，并启用management plugin后，使用默认的账号guest登陆管理控制台，却提示登陆失败。
翻看官方的release文档后，得知由于账号guest具有所有的操作权限，并且又是默认账号，出于安全因素的考虑，guest用户只能通过localhost登陆使用，并建议修改guest用户的密码以及新建其他账号管理使用rabbitmq(该功能是在3.3.0版本引入的)。
虽然可以以比较猥琐的方式：将ebin目录下rabbit.app中loopback_users里的<<"guest">>删除， 
 并重启rabbitmq，可通过任意IP使用guest账号登陆管理控制台，但始终是违背了设计者的初衷，再加上以前对这一块了解也不多，因此有必要总结一下。

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

rabbitmqctl environment

查看当前环境状态及配置信息

----------------------------------------------------

如果需要http调用rabbitMQ的相关函数，需要http auth验证,使用HTTP AUTH需要在server端配置http auth信息，我用简述一下http auth的过程：

1.客户端发送http请求;
2.服务器发现配置了http auth，检查request里面有没有"Authorization"的http header:
如果有，则判断Authorization里面的内容是否在用户列表里面，Authorization header的典型数据为"Authorization: Basic jdhaHY0="，其中Basic表示基础认证， jdhaHY0=是base64编码的"user:passwd"字符串。
如果没有，或者用户密码不对，则返回http code 401页面给客户端
3.标准的http浏览器在收到401页面之后，应该弹出一个对话框让用户输入帐号密码；并在用户点确认的时候再次发出请求，这次请求里面将带上Authorization header

下面的在线工具可以生成用户名和密码：

http://tool.chinaz.com/Tools/Base64.aspx

比如：

用户名：guest，密码：guest

即：guest:guest   加密后为：Z3Vlc3Q6Z3Vlc3Q=

----------------------------------------------------

附：java使用springmvc读取消息的监听类：

package cn.lsoft.undoner.mq;

import cn.lsoft.undoner.model.MessageRequest;
import cn.lsoft.undoner.service.MessageService;
import com.google.gson.Gson;
import com.rabbitmq.client.Channel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageDeliveryMode;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * MessageQueueListener
 *
 * @author <A HREF="mailto:undoner@gmail.com">undoner</A> Dec 18, 2015
 */

@Service
public class MessageQueueListener implements ChannelAwareMessageListener {
    private final static Logger LOGGER = LoggerFactory.getLogger(MessageQueueListener.class);

    @Autowired
    private MessageService messageService;

    private static final Gson gson = new Gson();

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        boolean isSuccess = false;
        String taskId = null;
        String content = new String(message.getBody());
        LOGGER.debug("MessageQueueListener Receive Queue:" + message.toString());
        LOGGER.debug("MessageQueueListener Receive Message:" + content);

        //DeliveryTag，对于每个Channel来说，每个消息都会有一个DeliveryTag，一般用接收消息的顺序来表示：1,2,3,4 等等
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            final MessageRequest messageRequest = gson.fromJson(content, MessageRequest.class);
            taskId = messageRequest.getRequestUuid();
            isSuccess = messageService.saveMessageRequest(messageRequest);
            LOGGER.debug("MessageQueueListener End!");
        } catch (Exception e) {
            LOGGER.error(e.getMessage(), e);
        } finally {
            if (isSuccess) {
                //消息确认，接收方处理完消息后，向服务器发送消息确认，服务器再删除该消息
                //channel.basicAck(deliveryTag, false);
                LOGGER.debug(taskId + " is done! ACK it.");
            } else {
                if (!message.getMessageProperties().isRedelivered()) {
                    //消息拒收，接收端在收到消息后，向服务器发送：true-放回queue，重做该任务，注意避免死循环
                    channel.basicReject(deliveryTag, true);
                    LOGGER.debug(taskId + " is fail! REJECT it");
                } else {
                    //消息拒收，接收端在收到消息后，向服务器发送：false-扔掉消息
                    channel.basicReject(deliveryTag, false);
                    LOGGER.debug(taskId + " is fail! Resend to dead queue by Spring");
                }
            }
        }

    }

    public void getMessage(Message message){
        //message.toString()该方法可以获取主要的queque信息
        String AppId = message.getMessageProperties().getAppId();
        String ClusterId = message.getMessageProperties().getClusterId();
        String ContentEncoding = message.getMessageProperties().getContentEncoding();
        String ContentType = message.getMessageProperties().getContentType();
        String Expiration = message.getMessageProperties().getExpiration();
        String MessageId = message.getMessageProperties().getMessageId();
        String ReceivedExchange = message.getMessageProperties().getReceivedExchange();
        String ReceivedRoutingKey = message.getMessageProperties().getReceivedRoutingKey();
        String ReplyTo = message.getMessageProperties().getReplyTo();
        String Type = message.getMessageProperties().getType();
        String UserId = message.getMessageProperties().getUserId();
        String ContentLength = String.valueOf(message.getMessageProperties().getContentLength());
        String CorrelationId = String.valueOf(message.getMessageProperties().getCorrelationId());
        MessageDeliveryMode DeliveryMode = message.getMessageProperties().getDeliveryMode();
        String DeliveryTag = String.valueOf(message.getMessageProperties().getDeliveryTag());
        String Headers = String.valueOf(message.getMessageProperties().getHeaders());
        String MessageCount = String.valueOf(message.getMessageProperties().getMessageCount());
        String Priority = String.valueOf(message.getMessageProperties().getPriority());
        String Timestamp = String.valueOf(message.getMessageProperties().getTimestamp());
        String ReplyToAddress = String.valueOf(message.getMessageProperties().getReplyToAddress());
        System.out.println("AppId :"+ AppId);
        System.out.println("ClusterId :"+ ClusterId);
        System.out.println("ContentEncoding :"+ ContentEncoding);
        System.out.println("ContentType :"+ ContentType);
        System.out.println("Expiration :"+ Expiration);
        System.out.println("MessageId :"+ MessageId);
        System.out.println("ReceivedExchange :"+ ReceivedExchange);
        System.out.println("ReceivedRoutingKey :"+ ReceivedRoutingKey);
        System.out.println("ReplyTo :"+ ReplyTo);
        System.out.println("Type :"+ Type);
        System.out.println("UserId :"+ UserId);
        System.out.println("ContentLength :"+ ContentLength);
        System.out.println("CorrelationId :"+ CorrelationId);
        System.out.println("DeliveryMode :"+ DeliveryMode.toString());
        System.out.println("DeliveryTag :"+ DeliveryTag);
        System.out.println("Headers :"+ Headers);
        System.out.println("MessageCount :"+ MessageCount);
        System.out.println("Priority :"+ Priority);
        System.out.println("Timestamp :"+ Timestamp);
        System.out.println("ReplyToAddress :"+ ReplyToAddress);
    }

}