初识RabbitMQ整理

---- RabbitMQ简介

    RabbitMQ是一种消息队列，有着类似代理的作用，它允许软件、应用相互连接和扩展。这些应用可以相互链接起来组成一个更大的应用，或者将用户设备和数据进行连接，消息系统通过将消息的发送和接收分离来实现应用程序的异步和解偶。它可以为你的应用提供一个通用的消息发送和接收平台，并且保证消息在传输过程中的安全。

--- 进一步理解

    RabbitMQ如同一个邮局，在其中通过接收寄信人发过来的邮件，并且将这些邮件进行归纳好分别发给各个对应的邮箱，然后再由快递员将各个邮件送至收件人手中。在其中，寄信人相当于生产者，邮件相当于消息，邮箱相当于消息队列，收件人相当于消费者。

--- 结构概念

   生产者：指发布消息的应用程序

   消息队列：用于存储消息的缓存区，本质上是存储在内存或者磁盘上，负责接收消息、保存消息以及发送消息

   消费者：指等待处理消息程序

   交换机：生产者发过来的消息需要经过交换机，交换机将决定将消息放到哪些队列当中

   RabbitMQ是基于AMQP网络协议的一种消息代理机制，由于AMQP是一个网络协议，所以这个过程中的生产者，消费者，消息代理 可以存在于不同的设备上。如下图：

--- 相关概念

   循环分发：即在消息队列中的消息是通过轮流的方式发给消费者的，比如当消息队列中存在a,b,c,d四个消息，同时有两个消费者C1、C2，那么可能a和c消息被C1接收了，b和d消息被C2接收了，这样的好处就是不会让消息都存储着而没有被利用，同时也有个坏处，假如当a和c都是比较耗时的任务，b和d都是比较简单的任务，就会导致C1可能要不停地工作，而C2就会产生空闲，造成资源浪费。

   公平发放：指消息队列只会把消息发给比较空闲的消费者，如果它看到原本要发送的消费者正在忙，那么就会自动去寻找下个空闲的消费者。

   消息确认：正常情况下，当一个消息发送出去之后，RabbitMQ会将该消息自动从队列中剔除出去，但是，假如处理该消息的时候出现了失误之类的，此时会造成该消息的丢失，所以引入了一个“消息确认”的东西，即消息代理不会完全地把消息从队列中剔除出去，直到接收到消费者返回的确认回执，才会将该消息清除，这样即使消费者挂掉了，消息也不会丢失。

----？相关代码

消费者：

package com.maxwell.rabbitdemo.workqueues;

import java.io.IOException;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

//工作队列，一个生产者分发给多个消费者（循环分发、消息确认、消息持久、公平分发）
public class Worker {
    private static final String TASK_QUEUE_NAME = "task_queue";
    
    public static void main(String[] args) throws Exception {
         ConnectionFactory factory = new ConnectionFactory();
         factory.setHost("192.168.153.136");
         factory.setPort(5672);
         
         final Connection connection = factory.newConnection();
         final Channel channel = connection.createChannel();
         
         channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
         System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
         
         //工作者让rabbitmq不会去轮流地发送消息  而是去寻找空闲的工作者 
         //一次只接收一条确认的消息
         channel.basicQos(1);
         
         final Consumer consumer = new DefaultConsumer(channel){
             @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {
                 String message = new String(body, "UTF-8");
                 System.out.println(" [x] Received '" + message + "'");
                 
                  try {
                      doWork(message);
                    } finally {
                      System.out.println(" [x] Done");
                      channel.basicAck(envelope.getDeliveryTag(), false);
                    }
            }
         };
         
         //消息确认机制：当消费者接收信息过程中出现了问题，没有接收消费者发出的确认消息，mq会自己将该信息重新加到队列中同时就算消费者挂掉了
        //信息也会当做没处理过的，重新加回队列，等待重新发送给消费者
         //默认该机制是开启的，这里将其关了
         boolean autoAck = false;
         channel.basicConsume(TASK_QUEUE_NAME, autoAck, consumer);
    }
    
     private static void doWork(String task) {
            for (char ch : task.toCharArray()) {
              if (ch == '.') {
                try {
                  Thread.sleep(1000);
                } catch (InterruptedException _ignored) {
                  Thread.currentThread().interrupt();
                }
              }
            }
          }
}

生产者：

package com.maxwell.rabbitdemo.workqueues;

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

public class NewTask {
     private static final String TASK_QUEUE_NAME = "task_queue";
     
     public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.153.136");
        factory.setPort(5672);
        
        Connection con = factory.newConnection();
        Channel channel = con.createChannel();
        
        //设置队列不丢失
        boolean qurable = true;
        channel.queueDeclare(TASK_QUEUE_NAME, qurable, false, false, null);
        String message = "4";
        
        //发布消息   设置MessageProperties的值为PERSISTENT_TEXT_PLAIN使得消息持久化
        channel.basicPublish("", TASK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN,  message.getBytes("UTF-8"));
        System.out.println(" [x] Sent '" + message + "'");

        channel.close();
        con.close();
    }
}

运行结果：先开启两个消费者程序，再运行一个生产者，之后再修改发送的内容再次运行，以下是两个消费者的运行情况：

--- 交换机类型

   首先，生产者发送消息到交换机，同时发送一个 key，也称之为路由键，通过这个 key，交换机就知道该把消息发到哪个队列。随后交换机把消息发送到相应的队列中。由队列将消息发送给消费者。消费者监听某些队列，当有消息过来时，就立即处理消息。

    在RabbitMQ一共有四种交换机，分别是直连型交换机（direct exchange）、扇型交换机（funout exchange）、主题交换机（topic exchanges）和头部交换机（headers exchange）。

• 直连型交换机（direct exchange）

          直型交换机是根据消息携带的路由键（routing key）将消息投递给对应队列的，它是将先将一个队列绑定在直连交换机上的时候，同时会赋予一个key，当之后的消息发送过来的时候，也会携带一个key，当只有这个key与交换机和队列之间的那个对应上了，交换机才会让该消息进入队列之中，否则会被丢弃。

        如上图所示，只有消息携带的key是小埋或者是康纳的时候才能进入Q1或者Q2队列之中，同时我们可以看到，直连交换机支持多重绑定，即多个队列以相同的key绑定到交换机上，如上边的key为康纳，这样即当消息发送过来携带的key是康纳的话，那么这个消息就会一同地发往Q1和Q2队列中。

 ----？相关代码

 生产者：

package com.maxwell.rabbitdemo.direct;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class EmitLogDirect {

    private static final String EXCHANGE_NAME = "direct_logs";
    
    public static void main(String[] args) throws Exception{
         //创建连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.153.136");
        factory.setPort(5672);
        
        Connection con =  factory.newConnection();
        Channel channel = con.createChannel();
        
        //声明路由器和类型
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        
             String severity = "小埋";
          String message = ".........i am msg.........";

            //发布消息
            channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + severity + "':'" + message + "'");

            channel.close();
            con.close();        
    }
   
}

消费者：

package com.maxwell.rabbitdemo.direct;

import java.io.IOException;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

//实现分别监听不同等级内容的消息   核心思想：在实现基本的分布信息基础上，通过改变路由类型为Direct,并且将要监听的类型进行绑定
public class ReceiveLogsDirect {
 
    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) throws Exception{
         //创建连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.153.136");
        factory.setPort(5672);
        
        Connection con =  factory.newConnection();
        Channel channel = con.createChannel();
        
        //声明路由器以及类型
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //声明队列
        String queueName = channel.queueDeclare().getQueue();
        //定义要监听的级别
        String[] severities = {"康纳"};
        
        //根据绑定键进行绑定
         for(String severity : severities){
             channel.queueBind(queueName, EXCHANGE_NAME, severity);
         }
         System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
         
          Consumer consumer = new DefaultConsumer(channel) {
             @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {
                String message = new String(body, "UTF-8");
              System.out.println(" [x] Received '" + envelope.getRoutingKey() + "':'" + message + "'");
            }
          };
               
            channel.basicConsume(queueName, true, consumer);
    }
}

运行结果：通过先运行route_key为康纳，小埋，然后修改为康纳再次运行，此时就有两个绑定不同的消费者在后台监听，之后分别运行生产者的route_key为康纳和小埋的，结果如下：

 

• 扇型交换机（funout exchange）

      扇型交换机将消息路由给绑定到它身上的所有队列，而不理会绑定的路由键。如果N个队列绑定到某个扇型交换机上，当有消息发送给此扇型交换机时，交换机会将消息的拷贝分别发送给这所有的N个队列。类似广播的作用。

 ----？相关代码

生产者：

package com.maxwell.rabbitdemo.fanout;

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

//日志发布者
public class EmitLog {

    public static final String Exchange_name = "logs";
    
    public static void main(String[] args) throws Exception{
        //建立通道和连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.153.136");
        factory.setPort(5672);
        
        Connection con =  factory.newConnection();
        Channel channel = con.createChannel();
        
        //声明路由器以及路由类型
        channel.exchangeDeclare(Exchange_name, BuiltinExchangeType.FANOUT);
        
        String msg = "康纳赛高...";
        
        //发布消息     其中第一个参数是代表Exchange的名字，默认情况下是空字符串
        channel.basicPublish(Exchange_name, "", null, msg.getBytes("UTF-8"));
        System.out.println("[x] Sent '"+msg+"'");
        
        //关闭连接和通道
        channel.close();
        con.close();
    }
}

消费者：

package com.maxwell.rabbitdemo.fanout;

import java.io.IOException;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

//一个生产者发布给多个消费者(发布、订阅)  核心思想:定义exchange，定义路由器类型，再将路由与定义的随机队列进行绑定
//日志接收者
public class ReceiveLogs {
    //定义exchange的名字，作用于接收生产者发来的消息并且推送到队列中
    public static final String Exchange_name = "logs";
    
    public static void main(String[] args) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.153.136");
        factory.setPort(5672);
        
        Connection con =  factory.newConnection();
        Channel channel = con.createChannel();
        //声明路由器以及类型         fanout会将接受到的信息广播给其他队列
        channel.exchangeDeclare(Exchange_name, BuiltinExchangeType.FANOUT);
        //声明一个随机名字的队列
        String queueName = channel.queueDeclare().getQueue();
        //绑定队列到路由器上
        channel.queueBind(queueName, Exchange_name, "");
        
        System.out.println(" [*]Waiting for messages, To exit press Ctrl+C");
        
        //开始监听消息
        Consumer consumer = new DefaultConsumer(channel){
            
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {
                 String message = new String(body, "UTF-8");
                 System.out.println(" [x] Received '" + message + "'");
            }
        };
        channel.basicConsume(queueName, true, consumer);
    }
}

运行情况：先运行两次消费者程序，此时后台有两个消费者在同时监听，当运行没运行一次生产者程序，消费者都能够监听到生产者发送的信息。

• 主题交换机（topic exchanges）

       主题交换机通过对消息的路由键和队列到交换机的绑定模式之间的匹配，将消息路由给一个或多个队列，所以经常用于消息的多播路由。

       主题交换机其实和直连交换机有点类似，也是需要路由键将队列和交换机进行绑定，但是唯一不同的点是，路由键的它必须是一些单词的集合，中间用点号.分割。这些单词可以是任意的，但通常会体现出消息的特征。一些有效的路由键示例：stock.usd.nyse，nyse.vmw，quick.orange.rabbit。这些路由键可以包含很多单词，但路由键总长度不能超过255个字节。其中，一些特殊符号表示如下：

    ①*（星号）仅代表一个单词
    ②#（井号）代表任意个单词

    按照上图可以看到：

    Q1绑定的路由键："*.康纳"、"#.小埋"

    Q2绑定的路由键：“#.康纳”

    所以，假如消息携带的路由键为小.康纳，那么Q1、Q2都能接收到该消息，假如携带的是小.小.康纳，那么就只有Q1能接收到该信息，依次类推。

    （注意以英文句号划分的都当做一个单词）

 ----？相关代码

 生产者：

package com.maxwell.rabbitdemo.topic;

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

public class EmitLogTopic {

     private static final String EXCHANGE_NAME = "topic_logs";

        public static void main(String[] argv) {
            Connection connection = null;
            Channel channel = null;
            try {
                //建立连接和通道
                ConnectionFactory factory = new ConnectionFactory();
                factory.setHost("192.168.153.136");
                factory.setPort(5672);
                connection = factory.newConnection();
                channel = connection.createChannel();

                //声明路由器和路由器类型
                channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);

                //定义路由键和消息
                String routingKey = "小.小.康纳";
                String message = "小恶龙咆哮";

                //发布消息
                channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes("UTF-8"));
                System.out.println(" [x] Sent '" + routingKey + "':'" + message + "'");

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (connection != null) {
                    try {
                        connection.close();
                    } catch (Exception ignore) {
                    }
                }
            }
        }
}

消费者：

package com.maxwell.rabbitdemo.topic;

import java.io.IOException;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

public class ReceiveLogsTopic {
      private static final String EXCHANGE_NAME = "topic_logs";

        public static void main(String[] args) throws Exception {
            //建立连接和通道
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("192.168.153.136");
            factory.setPort(5672);
            
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();

            //声明路由器和路由器类型
            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
            String queueName = channel.queueDeclare().getQueue();

            //*（星号）仅代表一个单词      #（井号）代表任意个单词
            String bingingKeys[] = {"#.康纳"};

            for (String bindingKey : bingingKeys) {
                channel.queueBind(queueName, EXCHANGE_NAME, bindingKey);
            }

            System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

            //监听消息
            Consumer consumer = new DefaultConsumer(channel) {
              @Override
            public void handleDelivery(String consumerTag,
                    Envelope envelope, BasicProperties properties,
                    byte[] body) throws IOException {
                  String message = new String(body, "UTF-8");
                  System.out.println(" [x] Received '" + envelope.getRoutingKey() + "':'" + message + "'");
            }
            };
            channel.basicConsume(queueName, true, consumer);
        }
}

运行情况：通过修改消费者中路由键的信息分别运行Q1和Q2，然后修改生产者中路由键为小.康纳，携带信息为恶龙咆哮，运行；继续修改生产者路由键为小.小.康纳，携带信息为小恶龙咆哮，运行，结果如下：

参考文档：RabbitMQ总结教程

                  RabbitMQ中文文档