Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.rabbitmq.client.impl
Class AMQChannel

    java.lang.Object
      com.rabbitmq.client.impl.ShutdownNotifierComponent
          com.rabbitmq.client.impl.AMQChannel

All Implemented Interfaces:
  ShutdownNotifier

Direct Known Subclasses:
  ChannelN

    public abstract class AMQChannel

extends ShutdownNotifierComponent

Base class modelling an AMQ channel. Subclasses implement `Channel.close()` and `processAsync()`, and may choose to override `processShutdownSignal()` and `rpc()`.

See Also:
  `ChannelN`, `Connection`

Nested Class Summary
`static class` | `AMQChannel.BlockingRpcContinuation<T>`
`static interface` | `AMQChannel.RpcContinuation`
`static class` | `AMQChannel.SimpleBlockingRpcContinuation`

Field Summary
`boolean` | `_blockContent` Whether transmission of content-bearing methods should be blocked
`protected java.lang.Object` | `_channelMutex` Protected; used instead of synchronizing on the channel itself, so that clients can themselves use the channel to synchronize on.

Constructor Summary
`AMQChannel(AMQConnection connection, int channelNumber)` Construct a channel on the given connection, with the given channel number.

Method Summary
`void` | `enqueueRpc(AMQChannel.RpcContinuation k)`
`void` | `ensureIsOpen()`
`AMQCommand` | `exnWrappingRpc(Method m)` Placeholder until we address bug 15786 (implementing a proper exception hierarchy).
`int` | `getChannelNumber()` Public API - Retrieves this channel's channel number.
`AMQConnection` | `getConnection()`
`void` | `handleCompleteInboundCommand(AMQCommand command)` Private API - handle a command which has been assembled
`void` | `handleFrame(Frame frame)` Private API - When the Connection receives a Frame for this channel, it passes it to this method.
`boolean` | `isOutstandingRpc()`
`AMQChannel.RpcContinuation` | `nextOutstandingRpc()`
`void` | `notifyOutstandingRpc(ShutdownSignalException signal)`
`abstract boolean` | `processAsync(Command command)` Protected API - called by nextCommand to check possibly handle an incoming Command before it is returned to the caller of nextCommand.
`void` | `processShutdownSignal(ShutdownSignalException signal, boolean ignoreClosed, boolean notifyRpc)` Protected API - respond, in the driver thread, to a `ShutdownSignalException`.
`void` | `quiescingRpc(Method m, AMQChannel.RpcContinuation k)`
`void` | `quiescingTransmit(AMQCommand c)`
`void` | `quiescingTransmit(Method m)`
`AMQCommand` | `rpc(Method m)` Protected API - sends a `Method` to the broker and waits for the next in-bound Command from the broker: only for use from non-connection-MainLoop threads!
`void` | `rpc(Method m, AMQChannel.RpcContinuation k)`
`java.lang.String` | `toString()`
`void` | `transmit(AMQCommand c)`
`void` | `transmit(Method m)`
`static java.io.IOException` | `wrap(ShutdownSignalException ex)` Placeholder until we address bug 15786 (implementing a proper exception hierarchy).
`static java.io.IOException` | `wrap(ShutdownSignalException ex, java.lang.String message)`

Methods inherited from class com.rabbitmq.client.impl.ShutdownNotifierComponent
`addShutdownListener, getCloseReason, isOpen, notifyListeners, removeShutdownListener, setShutdownCauseIfOpen`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

### _channelMutex

    protected final java.lang.Object _channelMutex

  Protected; used instead of synchronizing on the channel itself, so that clients can themselves use the channel to synchronize on.

### _blockContent

    public boolean _blockContent

  Whether transmission of content-bearing methods should be blocked

Constructor Detail

### AMQChannel

    public AMQChannel(AMQConnection connection,
                      int channelNumber)

  Construct a channel on the given connection, with the given channel number.

  Parameters:
    `connection` - the underlying connection for this channel
    `channelNumber` - the allocated reference number for this channel

Method Detail

### getChannelNumber

    public int getChannelNumber()

  Public API - Retrieves this channel's channel number.

  Returns:
    the channel number

### handleFrame

    public void handleFrame(Frame frame)
                     throws java.io.IOException

  Private API - When the Connection receives a Frame for this channel, it passes it to this method.

  Parameters:
    `frame` - the incoming frame
  Throws:
    `java.io.IOException` - if an error is encountered

### wrap

    public static java.io.IOException wrap(ShutdownSignalException ex)

  Placeholder until we address bug 15786 (implementing a proper exception hierarchy). In the meantime, this at least won't throw away any information from the wrapped exception.

  Parameters:
    `ex` - the exception to wrap
  Returns:
    the wrapped exception

### wrap

    public static java.io.IOException wrap(ShutdownSignalException ex,
                                           java.lang.String message)

### exnWrappingRpc

    public AMQCommand exnWrappingRpc(Method m)
                              throws java.io.IOException

  Placeholder until we address bug 15786 (implementing a proper exception hierarchy).

  Throws:
    `java.io.IOException`

### handleCompleteInboundCommand

    public void handleCompleteInboundCommand(AMQCommand command)
                                      throws java.io.IOException

  Private API - handle a command which has been assembled

  Parameters:
    `command` - the incoming command
  Throws:
    `java.io.IOException` - if there's any problem
    `java.io.IOException`

### enqueueRpc

    public void enqueueRpc(AMQChannel.RpcContinuation k)

### isOutstandingRpc

    public boolean isOutstandingRpc()

### nextOutstandingRpc

    public AMQChannel.RpcContinuation nextOutstandingRpc()

### ensureIsOpen

    public void ensureIsOpen()
                      throws AlreadyClosedException

  Throws:
    `AlreadyClosedException`

### rpc

    public AMQCommand rpc(Method m)
                   throws java.io.IOException,
                          ShutdownSignalException

  Protected API - sends a `Method` to the broker and waits for the next in-bound Command from the broker: only for use from non-connection-MainLoop threads!

  Throws:
    `java.io.IOException`
    `ShutdownSignalException`

### rpc

    public void rpc(Method m,
                    AMQChannel.RpcContinuation k)
             throws java.io.IOException

  Throws:
    `java.io.IOException`

### quiescingRpc

    public void quiescingRpc(Method m,
                             AMQChannel.RpcContinuation k)
                      throws java.io.IOException

  Throws:
    `java.io.IOException`

### processAsync

    public abstract boolean processAsync(Command command)
                                  throws java.io.IOException

  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.

  Parameters:
    `command` - the command to handle asynchronously
  Returns:
    true if we handled the command; otherwise the caller should consider it "unhandled"
  Throws:
    `java.io.IOException`

### toString

    public java.lang.String toString()

  Overrides:
    `toString` in class `java.lang.Object`

### processShutdownSignal

    public void processShutdownSignal(ShutdownSignalException signal,
                                      boolean ignoreClosed,
                                      boolean notifyRpc)

  Protected API - respond, in the driver thread, to a `ShutdownSignalException`.

  Parameters:
    `signal` - the signal to handle
    `ignoreClosed` - the flag indicating whether to ignore the AlreadyClosedException thrown when the channel is already closed
    `notifyRpc` - the flag indicating whether any remaining rpc continuation should be notified with the given signal

### notifyOutstandingRpc

    public void notifyOutstandingRpc(ShutdownSignalException signal)

### transmit

    public void transmit(Method m)
                  throws java.io.IOException

  Throws:
    `java.io.IOException`

### transmit

    public void transmit(AMQCommand c)
                  throws java.io.IOException

  Throws:
    `java.io.IOException`

### quiescingTransmit

    public void quiescingTransmit(Method m)
                           throws java.io.IOException

  Throws:
    `java.io.IOException`

### quiescingTransmit

    public void quiescingTransmit(AMQCommand c)
                           throws java.io.IOException

  Throws:
    `java.io.IOException`

### getConnection

    public AMQConnection getConnection()

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD