RabbitMQ-客户端源码之AMQChannel

AMQChannel是一个抽象类，是ChannelN的父类。其中包含唯一的抽象方法：

/**
 * Protected API - called by nextCommand to check possibly handle an incoming Command before it is returned to the caller of nextCommand. If this method
 * returns true, the command is considered handled and is not passed back to nextCommand's caller; if it returns false, nextCommand returns the command as
 * usual. This is used in subclasses to implement handling of Basic.Return and Basic.Deliver messages, as well as Channel.Close and Connection.Close.
 * @param command the command to handle asynchronously
 * @return true if we handled the command; otherwise the caller should consider it "unhandled"
 */
public abstract boolean processAsync(Command command) throws IOException;

有关processAsync()这个方法的会在介绍ChannelN类的时候详细阐述（[[八]RabbitMQ-客户端源码之ChannelN][RabbitMQ-_ChannelN]）。

---

首先来说下AMQChannel的成员变量：

protected final Object _channelMutex = new Object();
/** The connection this channel is associated with. */
private final AMQConnection _connection;
/** This channel's channel number. */
private final int _channelNumber;
/** Command being assembled */
private AMQCommand _command = new AMQCommand();
/** The current outstanding RPC request, if any. (Could become a queue in future.) */
private RpcContinuation _activeRpc = null;
/** Whether transmission of content-bearing methods should be blocked */
public volatile boolean _blockContent = false;

• _channelMutex这个是内部用来当对象锁的，没有实际的意义，可忽略
• _connection是指AMQConnection这个对象。
• _channelNumber是指channel number, 这个应该不用多解释了吧。通道编号为０的代表全局连接中的所有帧，1-65535代表特定通道的帧．
• _command是内部处理使用的对象，调用AMQCommand的方法来处理一些东西。
• _activeRpc是指当前未处理完的rpc请求（the current outstanding rpc request）。
• _blockContent 是在Channel.Flow里用到的，其余情况都是false
  在AMQChannel的构造函数中，只有两个参数：AMQConnection connection以及int channelNumber.

---

AMQChannel中有个handleFrame方法：

/**
 * Private API - When the Connection receives a Frame for this
 * channel, it passes it to this method.
 * @param frame the incoming frame
 * @throws IOException if an error is encountered
 */
public void handleFrame(Frame frame) throws IOException {
    AMQCommand command = _command;
    if (command.handleFrame(frame)) { // a complete command has rolled off the assembly line
        _command = new AMQCommand(); // prepare for the next one
        handleCompleteInboundCommand(command);
    }
}

/**
 * Private API - handle a command which has been assembled
 * @throws IOException if there's any problem
 *
 * @param command the incoming command
 * @throws IOException
 */
public void handleCompleteInboundCommand(AMQCommand command) throws IOException {
    // First, offer the command to the asynchronous-command
    // handling mechanism, which gets to act as a filter on the
    // incoming command stream.  If processAsync() returns true,
    // the command has been dealt with by the filter and so should
    // not be processed further.  It will return true for
    // asynchronous commands (deliveries/returns/other events),
    // and false for commands that should be passed on to some
    // waiting RPC continuation.
    if (!processAsync(command)) {
        // The filter decided not to handle/consume the command,
        // so it must be some reply to an earlier RPC.
        nextOutstandingRpc().handleCommand(command);
        markRpcFinished();
    }
}

这个在[[六]RabbitMQ-客户端源码之AMQCommand][RabbitMQ-_AMQCommand]有所介绍，主要是用来处理Frame帧的，当调用AMQCommand的handleFrame处理之后返回为true是，即处理完毕时继续调用handleCompleteInboundCommand方法。这其中也牵涉到AMQConnection的MainLoop内部类，具体可以看看：[[六]RabbitMQ-客户端源码之AMQCommand][RabbitMQ-_AMQCommand]。

---

AMQChannel中有很多方法带有rpc的字样，这来做一个整理。
首先是：

public void enqueueRpc(RpcContinuation k)
{
    synchronized (_channelMutex) {
        boolean waitClearedInterruptStatus = false;
        while (_activeRpc != null) {
            try {
                _channelMutex.wait();
            } catch (InterruptedException e) {
                waitClearedInterruptStatus = true;
            }
        }
        if (waitClearedInterruptStatus) {
            Thread.currentThread().interrupt();
        }
        _activeRpc = k;
    }
}

这个方法在AMQConnection.start()方法中有过使用：_channel0.enqueueRpc(conStartBroker)。这个方法就是将参数付给成员变量_activeRpc，至于这个RpcContinuation到底是个什么gui，我们下面再讲。
继续下一个方法：

public boolean isOutstandingRpc()
{
    synchronized (_channelMutex) {
        return (_activeRpc != null);
    }
}

这个方法是判断一下当前的_activeRpc是否为null，为null则为false，否则为true。看方法的名字应该猜出大半。
下面一个方法：

public RpcContinuation nextOutstandingRpc()
{
    synchronized (_channelMutex) {
        RpcContinuation result = _activeRpc;
        _activeRpc = null;
        _channelMutex.notifyAll();
        return result;
    }
}

方法将当前的_activeRpc返回，并置AQMChannel的_activeRpc为null。