All Superinterfaces:: AttributeMap, ChannelOutboundInvoker, Comparable<Channel>, FuturePromiseFactory, IoHandle

All Known Subinterfaces:: DatagramChannel, Http2StreamChannel, ServerChannel, ServerSocketChannel, SocketChannel, UnixChannel

All Known Implementing Classes:: AbstractChannel, AbstractNioByteChannel, AbstractNioChannel, AbstractNioMessageChannel, AbstractServerChannel, EmbeddedChannel, EpollDatagramChannel, EpollServerSocketChannel, EpollSocketChannel, KQueueDatagramChannel, KQueueServerSocketChannel, KQueueSocketChannel, LocalChannel, LocalServerChannel, NioDatagramChannel, NioServerSocketChannel, NioSocketChannel

public interface Channel
extends AttributeMap, ChannelOutboundInvoker, Comparable<Channel>, IoHandle

A nexus to a network socket or a component which is capable of I/O operations such as read, write, connect, and bind.

A channel provides a user:

the current state of the channel (e.g. is it open? is it connected?),
the configuration parameters of the channel (e.g. receive buffer size),
the I/O operations that the channel supports (e.g. read, write, connect, and bind), and
the ChannelPipeline which handles all I/O events and requests associated with the channel.

All I/O operations are asynchronous.

All I/O operations in Netty are asynchronous. It means any I/O calls will return immediately with no guarantee that the requested I/O operation has been completed at the end of the call. Instead, you will be returned with a Future instance which will notify you when the requested I/O operation has succeeded, failed, or canceled.

Channels are hierarchical

A Channel can have a parent depending on how it was created. For instance, a SocketChannel, that was accepted by ServerSocketChannel, will return the ServerSocketChannel as its parent on parent().

The semantics of the hierarchical structure depends on the transport implementation where the Channel belongs to. For example, you could write a new Channel implementation that creates the sub-channels that share one socket connection, as BEEP and SSH do.

Downcast to access transport-specific operations

Some transports exposes additional operations that is specific to the transport. Down-cast the Channel to sub-type to invoke such operations. For example, with the old I/O datagram transport, multicast join / leave operations are provided by DatagramChannel.

Storing stateful information

AttributeMap.attr(AttributeKey) allow you to store and access stateful information that is related with a handler and its context. Please refer to ChannelHandler to learn various recommended ways to manage stateful information.

Release resources

It is important to call close() to release all resources once you are done with the Channel. This ensures all resources are released in a proper way, i.e. filehandles.

Configuration / Option map

An option map property is a dynamic write-only property which allows the configuration of a Channel without down-casting. To update an option map, please call setOption(ChannelOption, Object).

All Channel types have the following options:

Name
`ChannelOption.CONNECT_TIMEOUT_MILLIS`
`ChannelOption.WRITE_SPIN_COUNT`
`ChannelOption.WRITE_BUFFER_WATER_MARK`
`ChannelOption.BUFFER_ALLOCATOR`
`ChannelOption.AUTO_READ`
`ChannelOption.ALLOW_HALF_CLOSURE`
`ChannelOption.MAX_MESSAGES_PER_WRITE`
`ChannelOption.ALLOW_HALF_CLOSURE`

More options are available in the sub-types of Channel. For example, you can configure the parameters which are specific to a TCP/IP socket as explained in SocketChannel.

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	Description
`default Future<Void>`	`bind(SocketAddress localAddress)`	Request to bind to the given `SocketAddress` and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`BufferAllocator`	`bufferAllocator()`	Return the assigned `BufferAllocator` which will be used to allocate `Buffer`s.
`default Future<Void>`	`close()`	Request to close the `Channel` and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`Future<Void>`	`closeFuture()`	Returns the `Future` which will be notified when this channel is closed.
`default Future<Void>`	`connect(SocketAddress remoteAddress)`	Request to connect to the given `SocketAddress` and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`default Future<Void>`	`connect(SocketAddress remoteAddress, SocketAddress localAddress)`	Request to connect to the given `SocketAddress` while bind to the localAddress and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`default Future<Void>`	`deregister()`	Request to deregister from the previous assigned `EventExecutor` and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`default Future<Void>`	`disconnect()`	Request to disconnect from the remote peer and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`EventLoop`	`executor()`	Return the `EventLoop` this `Channel` was registered to.
`default Channel`	`flush()`	Request to flush all pending messages via this ChannelOutboundInvoker.
`<T> T`	`getOption(ChannelOption<T> option)`	Return the value of the given `ChannelOption`
`ChannelId`	`id()`	Returns the globally unique identifier of this `Channel`.
`boolean`	`isActive()`	Return `true` if the `Channel` is active and so connected.
`boolean`	`isOpen()`	Returns `true` if the `Channel` is open and may get active later
`boolean`	`isOptionSupported(ChannelOption<?> option)`	Returns `true` if the given `ChannelOption` is supported by this `Channel` implementation.
`boolean`	`isShutdown(ChannelShutdownDirection direction)`	Returns `true` if the `ChannelShutdownDirection` of the `Channel` was shutdown before.
`default boolean`	`isWritable()`	Returns `true` if and only if the I/O thread will perform the requested flush operation immediately.
`SocketAddress`	`localAddress()`	Returns the local address where this channel is bound to.
`ChannelMetadata`	`metadata()`	Return the `ChannelMetadata` of the `Channel` which describe the nature of the `Channel`.
`Channel`	`parent()`	Returns the parent of this channel.
`ChannelPipeline`	`pipeline()`	Return the assigned `ChannelPipeline`.
`default Channel`	`read()`	Request to Read data from the `Channel` into the first inbound buffer, triggers an `ChannelHandler.channelRead(ChannelHandlerContext, Object)` event if data was read, and triggers a `channelReadComplete` event so the handler can decide to continue reading.
`default Future<Void>`	`register()`	Request to register on the `EventExecutor` for I/O processing.
`SocketAddress`	`remoteAddress()`	Returns the remote address where this channel is connected to.
`default Future<Void>`	`sendOutboundEvent(Object event)`	Send a custom outbound event via this `ChannelOutboundInvoker` through the `ChannelPipeline`.
`<T> Channel`	`setOption(ChannelOption<T> option, T value)`	Sets a configuration property with the specified name and value.
`default Future<Void>`	`shutdown(ChannelShutdownDirection direction)`	Request shutdown one direction of the `Channel` and notify the `Future` once the operation completes, either because the operation was successful or because of an error.
`long`	`writableBytes()`	Returns how many bytes can be written before the `Channel` becomes 'unwritable'.
`default Future<Void>`	`write(Object msg)`	Request to write a message via this `ChannelHandlerContext` through the `ChannelPipeline`.
`default Future<Void>`	`writeAndFlush(Object msg)`	Shortcut for call `ChannelOutboundInvoker.write(Object)` and `ChannelOutboundInvoker.flush()`.

Methods inherited from interface io.netty5.util.AttributeMap
attr, hasAttr

Methods inherited from interface io.netty5.channel.ChannelOutboundInvoker
newFailedFuture, newPromise, newSucceededFuture, newSucceededFuture

Methods inherited from interface java.lang.Comparable
compareTo

Methods inherited from interface io.netty5.channel.IoHandle
isRegistered

- Method Detail
  - id
```
ChannelId id()
```
    Returns the globally unique identifier of this Channel.
  - executor
```
EventLoop executor()
```
    Return the EventLoop this Channel was registered to.
    
    Specified by:
    
    executor in interface ChannelOutboundInvoker
    
    Returns:
    
    the executor.
  - parent
```
Channel parent()
```
    Returns the parent of this channel.
    
    Returns:
    
    the parent channel. null if this channel does not have a parent channel.
  - getOption
```
<T> T getOption(ChannelOption<T> option)
```
    Return the value of the given ChannelOption
    
    Type Parameters:
    
    T - the type of the value.
    
    Parameters:
    
    option - the ChannelOption.
    
    Returns:
    
    the value for the ChannelOption
    
    Throws:
    
    ChannelException - thrown on error.
    
    UnsupportedOperationException - if the ChannelOption is not supported.
  - setOption
```
<T> Channel setOption(ChannelOption<T> option,
                      T value)
```
    Sets a configuration property with the specified name and value.
    
    Type Parameters:
    
    T - the type of the value.
    
    Parameters:
    
    option - the ChannelOption.
    
    value - the value for the ChannelOption
    
    Returns:
    
    itself.
    
    Throws:
    
    ChannelException - thrown on error.
    
    UnsupportedOperationException - if the ChannelOption is not supported.
  - isOptionSupported
```
boolean isOptionSupported(ChannelOption<?> option)
```
    Returns true if the given ChannelOption is supported by this Channel implementation. If this methods returns false, calls to setOption(ChannelOption, Object) and getOption(ChannelOption) with the ChannelOption will throw an UnsupportedOperationException.
    
    Parameters:
    
    option - the option.
    
    Returns:
    
    true if supported, false otherwise.
  - isOpen
```
boolean isOpen()
```
    Returns true if the Channel is open and may get active later
  - isActive
```
boolean isActive()
```
    Return true if the Channel is active and so connected.
  - isShutdown
```
boolean isShutdown(ChannelShutdownDirection direction)
```
    Returns true if the ChannelShutdownDirection of the Channel was shutdown before.
  - metadata
```
ChannelMetadata metadata()
```
    Return the ChannelMetadata of the Channel which describe the nature of the Channel.
  - localAddress
```
SocketAddress localAddress()
```
    Returns the local address where this channel is bound to. The returned SocketAddress is supposed to be down-cast into more concrete type such as InetSocketAddress to retrieve the detailed information.
    
    Returns:
    
    the local address of this channel. null if this channel is not bound.
  - remoteAddress
```
SocketAddress remoteAddress()
```
    Returns the remote address where this channel is connected to. The returned SocketAddress is supposed to be down-cast into more concrete type such as InetSocketAddress to retrieve the detailed information.
    
    Returns:
    
    the remote address of this channel. null if this channel is not connected. If this channel is not connected but it can receive messages from arbitrary remote addresses (e.g. DatagramChannel, use DefaultAddressedEnvelope.recipient() to determine the origination of the received message as this method will return null.
  - closeFuture
```
Future<Void> closeFuture()
```
    Returns the Future which will be notified when this channel is closed. This method always returns the same future instance.
  - isWritable
```
default boolean isWritable()
```
    Returns true if and only if the I/O thread will perform the requested flush operation immediately. Any write requests made when this method returns false are queued until the I/O thread is ready to process the queued write requests.
  - writableBytes
```
long writableBytes()
```
    Returns how many bytes can be written before the Channel becomes 'unwritable'. Once a Channel becomes unwritable, all messages will be queued until the I/O thread is ready to process the queued write requests.
    
    Returns:
    
    the number of bytes that can be written before the Channel becomes unwritable.
  - pipeline
```
ChannelPipeline pipeline()
```
    Return the assigned ChannelPipeline.
  - bufferAllocator
```
BufferAllocator bufferAllocator()
```
    Return the assigned BufferAllocator which will be used to allocate Buffers.
  - read
```
default Channel read()
```
    Description copied from interface: ChannelOutboundInvoker
    
    Request to Read data from the Channel into the first inbound buffer, triggers an ChannelHandler.channelRead(ChannelHandlerContext, Object) event if data was read, and triggers a channelReadComplete event so the handler can decide to continue reading. If there's a pending read operation already, this method does nothing.
    This will result in having the ChannelHandler.read(ChannelHandlerContext) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
    
    Specified by:
    
    read in interface ChannelOutboundInvoker
  - bind
```
default Future<Void> bind(SocketAddress localAddress)
```
    Description copied from interface: ChannelOutboundInvoker
    
    Request to bind to the given SocketAddress and notify the Future once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelHandler.bind(ChannelHandlerContext, SocketAddress) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
    
    Specified by:
    
    bind in interface ChannelOutboundInvoker
  - connect
```
default Future<Void> connect(SocketAddress remoteAddress)
```
    Description copied from interface: ChannelOutboundInvoker
    
    Request to connect to the given SocketAddress and notify the Future once the operation completes, either because the operation was successful or because of an error.
    If the connection fails because of a connection timeout, the Future will get failed with a ConnectTimeoutException. If it fails because of connection refused a ConnectException will be used.
    This will result in having the ChannelHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
    
    Specified by:
    
    connect in interface ChannelOutboundInvoker
  - connect
```
default Future<Void> connect(SocketAddress remoteAddress,
                             SocketAddress localAddress)
```
    Description copied from interface: ChannelOutboundInvoker
    
    Request to connect to the given SocketAddress while bind to the localAddress and notify the Future once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
    
    Specified by:
    
    connect in interface ChannelOutboundInvoker
  - disconnect
```
default Future<Void> disconnect()
```
    Description copied from interface: ChannelOutboundInvoker
    
    Request to disconnect from the remote peer and notify the Future once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelHandler.disconnect(ChannelHandlerContext) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
    
    Specified by:
    
    disconnect in interface ChannelOutboundInvoker
  - close
```
default Future<Void> close()
```
    Description copied from interface: ChannelOutboundInvoker
    
    Request to close the Channel and notify the Future once the operation completes, either because the operation was successful or because of an error. After it is closed it is not possible to reuse it again.
    This will result in having the ChannelHandler.close(ChannelHandlerContext) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
    
    Specified by:
    
    close in interface ChannelOutboundInvoker
  - shutdown
```
default Future<Void> shutdown(ChannelShutdownDirection direction)
```
    Description copied from interface: ChannelOutboundInvoker
    
    Request shutdown one direction of the Channel and notify the Future once the operation completes, either because the operation was successful or because of an error.
    When completed, the channel will either not produce any inbound data anymore, or it will not be possible to write data anymore, depending on the given ChannelShutdownDirection.
    Depending on the transport implementation shutting down the ChannelShutdownDirection.Outbound or ChannelShutdownDirection.Inbound might also result in data transferred over the network. Like for example in case of TCP shutting down the ChannelShutdownDirection.Outbound will result in a FIN that is transmitted to the remote peer that will as a result shutdown ChannelShutdownDirection.Inbound.
    This will result in having the ChannelHandler.shutdown(ChannelHandlerContext, ChannelShutdownDirection). method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
    
    Specified by:
    
    shutdown in interface ChannelOutboundInvoker
  - register
```
default Future<Void> register()
```
    Description copied from interface: ChannelOutboundInvoker
    
    Request to register on the EventExecutor for I/O processing. Future once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelHandler.register(ChannelHandlerContext) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
    
    Specified by:
    
    register in interface ChannelOutboundInvoker
  - deregister
```
default Future<Void> deregister()
```
    Description copied from interface: ChannelOutboundInvoker
    
    Request to deregister from the previous assigned EventExecutor and notify the Future once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelHandler.deregister(ChannelHandlerContext) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
    
    Specified by:
    
    deregister in interface ChannelOutboundInvoker
  - write
```
default Future<Void> write(Object msg)
```
    Description copied from interface: ChannelOutboundInvoker
    
    Request to write a message via this ChannelHandlerContext through the ChannelPipeline. This method will not request to actual flush, so be sure to call ChannelOutboundInvoker.flush() once you want to request to flush all pending data to the actual transport.
    
    Specified by:
    
    write in interface ChannelOutboundInvoker
  - writeAndFlush
```
default Future<Void> writeAndFlush(Object msg)
```
    Description copied from interface: ChannelOutboundInvoker
    
    Shortcut for call ChannelOutboundInvoker.write(Object) and ChannelOutboundInvoker.flush().
    
    Specified by:
    
    writeAndFlush in interface ChannelOutboundInvoker
  - flush
```
default Channel flush()
```
    Description copied from interface: ChannelOutboundInvoker
    
    Request to flush all pending messages via this ChannelOutboundInvoker.
    
    Specified by:
    
    flush in interface ChannelOutboundInvoker
  - sendOutboundEvent
```
default Future<Void> sendOutboundEvent(Object event)
```
    Description copied from interface: ChannelOutboundInvoker
    
    Send a custom outbound event via this ChannelOutboundInvoker through the ChannelPipeline.
    This will result in having the ChannelHandler.sendOutboundEvent(ChannelHandlerContext, Object) method called of the next ChannelHandler contained in the ChannelPipeline of the Channel.
    
    Specified by:
    
    sendOutboundEvent in interface ChannelOutboundInvoker

Interface Channel

All I/O operations are asynchronous.

Channels are hierarchical

Downcast to access transport-specific operations

Storing stateful information

Release resources

Configuration / Option map

Method Summary

Methods inherited from interface io.netty5.util.AttributeMap

Methods inherited from interface io.netty5.channel.ChannelOutboundInvoker

Methods inherited from interface java.lang.Comparable

Methods inherited from interface io.netty5.channel.IoHandle

Method Detail

id

executor

parent

getOption

setOption

isOptionSupported

isOpen

isActive

isShutdown

metadata

localAddress

remoteAddress

closeFuture

isWritable

writableBytes

pipeline

bufferAllocator

read

bind

connect

connect

disconnect

close

shutdown

register

deregister

write

writeAndFlush

flush

sendOutboundEvent