RabbitMQ基础篇

　　RabbitMQ是基于AMQP（Advanced Message Queue）标准协议规范的实现，由Erlang语言开发。

　　RabbitMQ结构图：

　　　　

---

一、名词概念

　　Broker：消息队列服务器实体。

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

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

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

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

　　vhost：虚拟主机，一个broker里可以开设多个vhost，用作不同用户的权限分离。

　　producer：消息生产者，就是投递消息的程序。

　　consumer：消息消费者，就是接受消息的程序，消费者分为持续订阅（basicConsumer）和单条订阅(basicGet)。

　　channel：消息通道，建立在TCP连接之上。在客户端的每个连接里，可建立多个channel【实际上信道的创建是没有限制的】，每个channel代表一个会话任务。

---

二、使用流程

　　　　　　

　　生产者（客户端）：

　　　　(1)客户端连接到消息队列服务器，打开一个channel。

　　　　(2)客户端声明一个exchange，并设置相关属性。

　　　　(3)客户端声明一个queue，并设置相关属性。【注：若不声明队列，则rabbitmq会默认生成个随机队列】

　　　　(4)客户端使用routing key，在exchange和queue之间建立好绑定关系。

　　　　(5)客户端投递消息到exchange。　　　

package producer.normal;

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

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class DirectProducer {

    private final static String EXCHANGE_NAME = "direct_log";
    public static void main(String[] args) throws IOException, TimeoutException {
        // 创建连接工厂
        ConnectionFactory cf = new ConnectionFactory();
        // 工厂属性配置，列举如下几个，其他属性自行点击ConnectionFactory进去查看
        cf.setHost("127.0.0.1");// ip
        cf.setPort(5672);// 端口
        cf.setUsername("guest");// 用户名
        cf.setPassword("guest");// 密码
        // 创建连接
        Connection con = cf.newConnection();
        // 创建信道
        Channel channel = con.createChannel();
        // 声明交换器
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        String[] logLevels = {"info", "error", "warning"};
        for (int i = 0; i < logLevels.length; i++) {
            String logLevel = logLevels[i];
            String message = logLevel + ":" + "hello rabbitmq";
            channel.basicPublish(EXCHANGE_NAME, logLevel, null, message.getBytes());
            System.out.println("send message:" + message);
        }
        channel.close();
        con.close();
    }
}

　　消费者：

　　　　(1)连接到消息队列服务器，打开一个channel。

　　　　(2)声明一个exchange，并设置相关属性。

　　　　(3)声明一个queue，并设置相关属性。【注：若不声明队列，则rabbitmq会默认生成个随机队列】

　　　　(4)使用routing key，在exchange和queue之间建立好绑定关系。

　　　　(5)接收exchange中的消息进行消费处理。

package consumer.normal;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.concurrent.TimeoutException;

public class DirectConsumerAll {
    private final static String EXCHANGE_NAME = "direct_log";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory cf = new ConnectionFactory();
        Connection con = cf.newConnection();
        Channel channel = con.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        String queueName = channel.queueDeclare().getQueue();//声明随机队列
        String[] logLevels = {"info", "error", "warning"};
        for (String logLevel : logLevels) {
            channel.queueBind(queueName, EXCHANGE_NAME, logLevel);
        }
        System.out.println("waiting message...");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,
                                       byte[] body) {
                String message = new String(body, Charset.defaultCharset());
                System.out.println("accept " + envelope.getRoutingKey() + ":" + message);
            }
        };
        channel.basicConsume(queueName, true, consumer);

    }
}

---

三、交换器类型

　　DIRECT：完全路由键匹配，例如，绑定时设置了routing key为"abc"，那么客户端提交的消息，只有设置了key为"abc"的才会投递到队列。

　　FANOUT：不需要路由键，采取广播模式。例如，一条消息进来时，投递到与该交换机绑定的所有队列。

　　TOPIC：主题，根据路由键进行模式匹配投递消息，符号"#"匹配一个或多个词，符号"*"匹配正好一个词。例如"abc.#"匹配"abc.def.ghi"，"abc.*"只匹配"abc.def"。

　　HEADERS：消息头，不作过多讲解，使用场景很少。

---

 四、消息持久化

　　RabbitMQ支持消息的持久化，也就是数据写在磁盘上，为了数据安全考虑。但相应会带来性能的下降，大致10倍。消息队列持久化包括以下3个部分：

　　　　(1)exchange持久化，在声明时指定durable => 1

　　　　(2)queue持久化，在声明时指定durable => 1

　　　　(3)消息持久化，在投递时指定delivery_mode => 2(1是非持久化)

　　如果exchange和queue都是持久化的，那么它们之间的binding也是持久化的。如果exchange和queue两者之间有一个持久化，一个非持久化，就不允许建立绑定。

---

五、消息确认和发送方确认

　　1、消息确认：

　　　　消费者收到的每一条消息都必须进行确认，分为自动确认和消费者自行确认。

　　　　消费者在声明队列时，指定autoAck参数，true自动确认，false时rabbitmq会等到消费者显示的发回一个ack信号才会删除消息。autoAck=false，有足够时间让消费者处理消息，直到消费者显示调用basicAck为止。

　　　　Rabbitmq中消息分为了两部分：1、等待投递的消息；2、已经投递，但是还没有收到ack信号的。如果消费者断连了，服务器会把消息重新入队，投递给下一个消费者。未ack的消息是没有超时时间的。

　　2、发送方确认

　　　　生产者不知道消息是否真正到达RabbitMq，也就是说发布操作不返回任何消息给生产者。

　　　　AMQP协议层面为我们提供的事务机制解决了这个问题，但是事务机制本身也会带来问题：

　　　　　　 1、严重的性能问题

　　　　　　 2、使生产者应用程序产生同步

　　 　　RabbitMQ团队为我们拿出了更好的方案，即采用发送方确认模式，该模式比事务更轻量，性 能影响几乎可以忽略不计—— 发送方确认模式的机制。

　　注意：发送方确认模式和消费者对消息的确认是不同的。

package producer.confirm;

import com.rabbitmq.client.*;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.concurrent.TimeoutException;

/**
 * 发送方确认模式——异步模式
 */
public class ProducerConfirmAsync {
    private final static String EXCHANGE_NAME = "confirm_log";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        ConnectionFactory cf = new ConnectionFactory();
        Connection con = cf.newConnection();
        // 监听连接关闭事件，一般用于重连机制
        con.addShutdownListener(new ShutdownListener() {
            @Override
            public void shutdownCompleted(ShutdownSignalException cause) {

            }
        });
        Channel channel = con.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        // 将信道设置为发送方确认
        channel.confirmSelect();
        // 监听信道事件
        channel.addShutdownListener(new ShutdownListener() {
            @Override
            public void shutdownCompleted(ShutdownSignalException cause) {

            }
        });
        // deliveryTag:代表消息在信道中的唯一一次投递，单调递增
        // multiple:是否批处理，默认false
        // 监听已被投递的消息
        channel.addConfirmListener(new ConfirmListener() {
            @Override
            public void handleAck(long deliveryTag, boolean multiple) {
                System.out.println("Ack deliveryTag=" + deliveryTag + ",multiple=" + multiple);
            }

            @Override
            public void handleNack(long deliveryTag, boolean multiple) {
                System.out.println("Ack deliveryTag=" + deliveryTag + ",multiple=" + multiple);
            }
        });

        // 监听未被投递到队列的消息
        channel.addReturnListener(new ReturnListener() {
            @Override
            public void handleReturn(int replyCode, String replyText, String exchange, String routingKey,
                                     AMQP.BasicProperties properties, byte[] body) {
                System.out.println("replyCode:" + replyCode);
                System.out.println("replyText:" + replyText);
                System.out.println("exchange:" + exchange);
                System.out.println("routingKey:" + routingKey);
                System.out.println("message:" + new String(body));
            }
        });
        String[] logLevels = {"error", "info", "warning"};
        System.out.println("waiting message sent...");
        // mandatory参数为true,当投递消息无法找到合适的消息队列，则返回生成者；false为缺省，丢弃消息
        for (int i = 0; i < 3; i++) {
            String message =  " hello rabbitMq" + (i + 1);
            channel.basicPublish(EXCHANGE_NAME, logLevels[i], true, null,
                    message.getBytes(Charset.defaultCharset()));
            System.out.println("---------------------------------------------------");
            System.out.println("sent message: [" +logLevels[i] +"]" + message);
            Thread.sleep(200);
        }
    }
}

 

面试环节可能会问到几个基础问题：

　　1.  如果消息达到无人订阅的队列会怎么办？

 　　消息会一直在队列中等待，rabbitmq会默认队列是无限长度的。

　　2.  多个消费者订阅到同一队列怎么办？

　　消息会轮询的方式发送给消费者，每个消息只会发送给一个消费者

　　3.  消息路由到了不存在的队列怎么办？

　　会忽略，当消息不存在，消息丢失了。

　　4.  如何明确拒绝消息？

 　　1、消费者断连，2、消费者使用reject命令（requeue=true,重新分发消息，false移除消息），3、nack命令（批量的拒绝）