1當消費者消費這條消息的同時,出現異常,導致沒有保存到數據庫,所以在finally加上,重試機制
2在消費者消費這條消息的同時,服務器宕機,都不會出現丟失消息的情況,這是我們想要的結果,所以要設置隊列手動確認接收到消息
下面是代碼,以下有任何問題和疑問,請指出
package com.incar.web.controller.order; import com.rabbitmq.client.*; import org.springframework.amqp.core.Message; import org.springframework.amqp.core.MessageListener; import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener; import java.io.IOException; public class QueueListenter implements ChannelAwareMessageListener { private final static String QUEUE_NAME = "car_order_finish"; enum Action { ACCEPT, // 處理成功 RETRY, // 可以重試的錯誤 REJECT, // 無需重試的錯誤 } @Override public void onMessage(Message message, Channel channel) { Action action = Action.ACCEPT; long tag = 0; try { message.getMessageProperties().getConsumerTag(); System.out.println( message.getMessageProperties().getConsumerTag()); String message1 = new String(message.getBody(), "UTF-8"); System.out.println("獲取消息'" + message1 + "'"); // 下面註釋每次只接收一個消息 // channel.basicQos(1); } catch (Exception e) { // 根據異常種類決定是ACCEPT、RETRY還是 REJECT action = Action.RETRY; e.printStackTrace(); } finally { try { // 通過finally塊來保證Ack/Nack會且只會執行一次 if (action == Action.ACCEPT) { channel.basicAck(tag, true); // 重試 } else if (action == Action.RETRY) { channel.basicNack(tag, false, true); Thread.sleep(2000L); // 拒絕消息也相當於主動刪除mq隊列的消息 } else { channel.basicNack(tag, false, false); } } catch (Exception e) { e.printStackTrace(); } } } }
rabbitmq channel參數詳解
1、Channel 1.1 channel.exchangeDeclare():
type:有direct、fanout、topic三種 durable:true、false true:服務器重啓會保留下來Exchange。警告:僅設置此選項,不代表消息持久化。即不保證重啓後消息還在。原文:true if we are declaring a durable exchange (the exchange will survive a server restart) autoDelete:true、false.true:當已經沒有消費者時,服務器是否可以刪除該Exchange。原文1:true if the server should delete the exchange when it is no longer in use。
/** * Declare an exchange. * @see com.rabbitmq.client.AMQP.Exchange.Declare * @see com.rabbitmq.client.AMQP.Exchange.DeclareOk * @param exchange the name of the exchange * @param type the exchange type * @param durable true if we are declaring a durable exchange (the exchange will survive a server restart) * @param autoDelete true if the server should delete the exchange when it is no longer in use * @param arguments other properties (construction arguments) for the exchange * @return a declaration-confirm method to indicate the exchange was successfully declared * @throws java.io.IOException if an error is encountered */ Exchange.DeclareOk exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, Map<String, Object> arguments) throws IOException;
1.2 chanel.basicQos()
prefetchSize:0 prefetchCount:會告訴RabbitMQ不要同時給一個消費者推送多於N個消息,即一旦有N個消息還沒有ack,則該consumer將block掉,直到有消息ack global:true\false 是否將上面設置應用於channel,簡單點說,就是上面限制是channel級別的還是consumer級別
備註:據說prefetchSize 和global這兩項,rabbitmq沒有實現,暫且不研究
/** * Request specific "quality of service" settings. * * These settings impose limits on the amount of data the server * will deliver to consumers before requiring acknowledgements. * Thus they provide a means of consumer-initiated flow control. * @see com.rabbitmq.client.AMQP.Basic.Qos * @param prefetchSize maximum amount of content (measured in * octets) that the server will deliver, 0 if unlimited * @param prefetchCount maximum number of messages that the server * will deliver, 0 if unlimited * @param global true if the settings should be applied to the * entire channel rather than each consumer * @throws java.io.IOException if an error is encountered */ void basicQos(int prefetchSize, int prefetchCount, boolean global) throws IOException;
1.3 channel.basicPublish()
routingKey:路由鍵,#匹配0個或多個單詞,*匹配一個單詞,在topic exchange做消息轉發用 mandatory:true:如果exchange根據自身類型和消息routeKey無法找到一個符合條件的queue,那麼會調用basic.return方法將消息返還給生產者。false:出現上述情形broker會直接將消息扔掉
immediate:true:如果exchange在將消息route到queue(s)時發現對應的queue上沒有消費者,那麼這條消息不會放入隊列中。當與消息routeKey關聯的所有queue(一個或多個)都沒有消費者時,該消息會通過basic.return方法返還給生產者。 BasicProperties :需要注意的是BasicProperties.deliveryMode,0:不持久化 1:持久化 這裏指的是消息的持久化,配合channel(durable=true),queue(durable)可以實現,即使服務器宕機,消息仍然保留 簡單來說:mandatory標誌告訴服務器至少將該消息route到一個隊列中,否則將消息返還給生產者;immediate標誌告訴服務器如果該消息關聯的queue上有消費者,則馬上將消息投遞給它,如果所有queue都沒有消費者,直接把消息返還給生產者,不用將消息入隊列等待消費者了。
/** * Publish a message. * * Publishing to a non-existent exchange will result in a channel-level * protocol exception, which closes the channel. * * Invocations of <code>Channel#basicPublish</code> will eventually block if a * <a href="http://www.rabbitmq.com/alarms.html">resource-driven alarm</a> is in effect. * * @see com.rabbitmq.client.AMQP.Basic.Publish * @see <a href="http://www.rabbitmq.com/alarms.html">Resource-driven alarms</a>. * @param exchange the exchange to publish the message to * @param routingKey the routing key * @param mandatory true if the 'mandatory' flag is to be set * @param immediate true if the 'immediate' flag is to be * set. Note that the RabbitMQ server does not support this flag. * @param props other properties for the message - routing headers etc * @param body the message body * @throws java.io.IOException if an error is encountered */ void basicPublish(String exchange, String routingKey, boolean mandatory, boolean immediate, BasicProperties props, byte[] body) throws IOException;
1.4 channel.basicAck();
deliveryTag:該消息的index multiple:是否批量.true:將一次性ack所有小於deliveryTag的消息。
/** * Acknowledge one or several received * messages. Supply the deliveryTag from the {@link com.rabbitmq.client.AMQP.Basic.GetOk} * or {@link com.rabbitmq.client.AMQP.Basic.Deliver} method * containing the received message being acknowledged. * @see com.rabbitmq.client.AMQP.Basic.Ack * @param deliveryTag the tag from the received {@link com.rabbitmq.client.AMQP.Basic.GetOk} or {@link com.rabbitmq.client.AMQP.Basic.Deliver} * @param multiple true to acknowledge all messages up to and * including the supplied delivery tag; false to acknowledge just * the supplied delivery tag. * @throws java.io.IOException if an error is encountered */ void basicAck(long deliveryTag, boolean multiple) throws IOException;
1.5 channel.basicNack(delivery.getEnvelope().getDeliveryTag(), false, true);
deliveryTag:該消息的index multiple:是否批量.true:將一次性拒絕所有小於deliveryTag的消息。 requeue:被拒絕的是否重新入隊列
/** * Reject one or several received messages. * * Supply the <code>deliveryTag</code> from the {@link com.rabbitmq.client.AMQP.Basic.GetOk} * or {@link com.rabbitmq.client.AMQP.Basic.GetOk} method containing the message to be rejected. * @see com.rabbitmq.client.AMQP.Basic.Nack * @param deliveryTag the tag from the received {@link com.rabbitmq.client.AMQP.Basic.GetOk} or {@link com.rabbitmq.client.AMQP.Basic.Deliver} * @param multiple true to reject all messages up to and including * the supplied delivery tag; false to reject just the supplied * delivery tag. * @param requeue true if the rejected message(s) should be requeued rather * than discarded/dead-lettered * @throws java.io.IOException if an error is encountered */ void basicNack(long deliveryTag, boolean multiple, boolean requeue) throws IOException;
1.5 channel.basicReject(delivery.getEnvelope().getDeliveryTag(), false);
deliveryTag:該消息的index requeue:被拒絕的是否重新入隊列 channel.basicNack 與 channel.basicReject 的區別在於basicNack可以拒絕多條消息,而basicReject一次只能拒絕一條消息
/** * Reject a message. Supply the deliveryTag from the {@link com.rabbitmq.client.AMQP.Basic.GetOk} * or {@link com.rabbitmq.client.AMQP.Basic.Deliver} method * containing the received message being rejected. * @see com.rabbitmq.client.AMQP.Basic.Reject * @param deliveryTag the tag from the received {@link com.rabbitmq.client.AMQP.Basic.GetOk} or {@link com.rabbitmq.client.AMQP.Basic.Deliver} * @param requeue true if the rejected message should be requeued rather than discarded/dead-lettered * @throws java.io.IOException if an error is encountered */ void basicReject(long deliveryTag, boolean requeue) throws IOException;
1.6 channel.basicConsume(QUEUE_NAME, true, consumer);
autoAck:是否自動ack,如果不自動ack,需要使用channel.ack、channel.nack、channel.basicReject 進行消息應答
/** * Start a non-nolocal, non-exclusive consumer, with * a server-generated consumerTag. * @param queue the name of the queue * @param autoAck true if the server should consider messages * acknowledged once delivered; false if the server should expect * explicit acknowledgements * @param callback an interface to the consumer object * @return the consumerTag generated by the server * @throws java.io.IOException if an error is encountered * @see com.rabbitmq.client.AMQP.Basic.Consume * @see com.rabbitmq.client.AMQP.Basic.ConsumeOk * @see #basicConsume(String, boolean, String, boolean, boolean, Map, Consumer) */ String basicConsume(String queue, boolean autoAck, Consumer callback) throws IOException;
1.7 chanel.exchangeBind()
channel.queueBind(queueName, EXCHANGE_NAME, bindingKey); 用於通過綁定bindingKey將queue到Exchange,之後便可以進行消息接收
/** * Bind an exchange to an exchange, with no extra arguments. * @see com.rabbitmq.client.AMQP.Exchange.Bind * @see com.rabbitmq.client.AMQP.Exchange.BindOk * @param destination the name of the exchange to which messages flow across the binding * @param source the name of the exchange from which messages flow across the binding * @param routingKey the routine key to use for the binding * @return a binding-confirm method if the binding was successfully created * @throws java.io.IOException if an error is encountered */ Exchange.BindOk exchangeBind(String destination, String source, String routingKey) throws IOException;
1.8 channel.queueDeclare(QUEUE_NAME, false, false, false, null);
durable:true、false true:在服務器重啓時,能夠存活
exclusive :是否爲當前連接的專用隊列,在連接斷開後,會自動刪除該隊列,生產環境中應該很少用到吧。 autodelete:當沒有任何消費者使用時,自動刪除該隊列。this means that the queue will be deleted when there are no more processes consuming messages from it.
/** * Declare a queue * @see com.rabbitmq.client.AMQP.Queue.Declare * @see com.rabbitmq.client.AMQP.Queue.DeclareOk * @param queue the name of the queue * @param durable true if we are declaring a durable queue (the queue will survive a server restart) * @param exclusive true if we are declaring an exclusive queue (restricted to this connection) * @param autoDelete true if we are declaring an autodelete queue (server will delete it when no longer in use) * @param arguments other properties (construction arguments) for the queue * @return a declaration-confirm method to indicate the queue was successfully declared * @throws java.io.IOException if an error is encountered */ Queue.DeclareOk queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments) throws IOException;