1、Channel 

1.1 channel.exchangeDeclare()：

type：有direct、fanout、topic三種：

fanout

fanout型別的Exchange路由規則非常簡單，它會把所有傳送到該Exchange的訊息路由到所有與它繫結的Queue中

direct

direct型別的Exchange路由規則也很簡單，它會把訊息路由到那些binding key與routing key完全匹配的Queue中。

topic

規則就是模糊匹配，可以通過萬用字元滿足一部分規則就可以傳送。它的約定是：

routing key為一個句點號“. ”分隔的字串（我們將被句點號“. ”分隔開的每一段獨立的字串稱為一個單詞），如“stock.usd.nyse”、“nyse.vmw”、“quick.orange.rabbit” binding key與routing key一樣也是句點號“. ”分隔的字串。

binding key中可以存在兩種特殊字元“”與“#”，用於做模糊匹配，其中“”用於匹配一個單詞，“#”用於匹配多個單詞(可以是零個）

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沒有實現，暫且不研究

　QoS = quality-of-service， 顧名思義，服務的質量。通常我們設計系統的時候不能完全排除故障或保證說沒有故障，而應該設計有完善的異常處理機制。在出現錯誤的時候知道在哪裡出現什麼樣子的錯誤，原因是什麼，怎麼去恢復或者處理才是真正應該去做的。在接收訊息出現故障的時候我們可以通過RabbitMQ重發機制來處理。重發就有重發次數的限制，有些時候你不可能不限次數的重發，這取決於訊息的大小，重要程度和處理方式。

甚至QoS是在接收端設定的。傳送端沒有任何變化，接收端的程式碼也比較簡單，只需要加如下程式碼：

channel.BasicQos(0, 1, false);

程式碼第一個引數是可接收訊息的大小的，但是似乎在客戶端2.8.6版本中它必須為0，即使：不受限制。如果不輸0，程式會在執行到這一行的時候報錯，說還沒有實現不為0的情況。第二個引數是處理訊息最大的數量。舉個例子，如果輸入1，那如果接收一個訊息，但是沒有應答，則客戶端不會收到下一個訊息，訊息只會在佇列中阻塞。如果輸入3，那麼可以最多有3個訊息不應答，如果到達了3個，則傳送端發給這個接收方得訊息只會在佇列中，而接收方不會有接收到訊息的事件產生。總結說，就是在下一次傳送應答訊息前，客戶端可以收到的訊息最大數量。第三個引數則設定了是不是針對整個Connection的，因為一個Connection可以有多個Channel，如果是false則說明只是針對於這個Channel的。

這種數量的設定，也為我們在多個客戶端監控同一個queue的這種負載均衡環境下提供了更多的選擇。

/**
     * 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.4channel.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.5channel.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.6channel.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.7 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.8 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.8channel.queueDeclare(QUEUE_NAME, false, false, false, null);

durable：true、false true：在伺服器重啟時，能夠存活

exclusive ：是否為當前連線的專用佇列，在連線斷開後，會自動刪除該佇列，生產環境中應該很少用到吧。
autodelete：當沒有任何消費者使用時，自動刪除該佇列。

/**
     * 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;

ref:RabbitMQ Channel 引數詳解 - 簡書 (jianshu.com)