AbstractChannel (Netty API Reference (4.1.22.Final))

java.lang.Object
- io.netty.util.DefaultAttributeMap
- - io.netty.channel.AbstractChannel

All Implemented Interfaces:

Channel ， ChannelOutboundInvoker ， AttributeMap ，java.lang.Comparable的< Channel >

已知直接子类：

AbstractEpollServerChannel ， AbstractEpollStreamChannel ， AbstractKQueueServerChannel ， AbstractKQueueStreamChannel ， AbstractNioChannel ， AbstractOioChannel ， AbstractServerChannel ， EmbeddedChannel ， EpollDatagramChannel ， KQueueDatagramChannel ， LocalChannel
```
public abstract class AbstractChannel
extends DefaultAttributeMap
implements Channel
```
一个骨架Channel的实现。

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`AbstractChannel.AbstractUnsafe` `Unsafe`子类必须扩展和使用的实现。

Nested classes/interfaces inherited from interface io.netty.channel.Channel
Channel.Unsafe

构造方法摘要

构造方法
Modifier	Constructor and Description
`protected`	`AbstractChannel(Channel parent)` 创建一个新的实例。
`protected`	`AbstractChannel(Channel parent, ChannelId id)` 创建一个新的实例。

方法摘要

所有方法接口方法抽象方法具体的方法弃用的方法
Modifier and Type	Method and Description
`ByteBufAllocator`	`alloc()` 返回分配的`ByteBufAllocator`这将被用于分配`ByteBuf`秒。
`ChannelFuture`	`bind(java.net.SocketAddress localAddress)` 请求绑定到给定的`SocketAddress`并在操作完成后通知`ChannelFuture` ，无论是因为操作成功还是由于错误。
`ChannelFuture`	`bind(java.net.SocketAddress localAddress, ChannelPromise promise)` 请求绑定到给定的`SocketAddress`并在操作完成后通知`ChannelFuture` ，无论是因为操作成功还是由于错误。
`long`	`bytesBeforeUnwritable()` 获取可以写入多少个字节，直到 `Channel.isWritable()`返回 `false` 。
`long`	`bytesBeforeWritable()` 从 `Channel.isWritable()`返回 `true`之前，必须从基础缓冲区中清除多少个字节。
`ChannelFuture`	`close()` 请求关闭`Channel`，并在操作完成后通知`ChannelFuture` ，无论是因为操作成功还是由于错误。
`ChannelFuture`	`close(ChannelPromise promise)` 请求关闭`Channel`，并在操作完成后通知`ChannelFuture` ，无论是因为操作成功还是由于错误。
`ChannelFuture`	`closeFuture()` 返回此通道关闭时将通知的`ChannelFuture` 。
`int`	`compareTo(Channel o)`
`ChannelFuture`	`connect(java.net.SocketAddress remoteAddress)` 请求连接到给定的`SocketAddress`并在操作完成后通知`ChannelFuture` ，这可能是因为操作成功或者由于错误。
`ChannelFuture`	`connect(java.net.SocketAddress remoteAddress, ChannelPromise promise)` 请求连接到给定的`SocketAddress`并在操作完成后通知`ChannelFuture` ，无论是因为操作成功还是由于错误。
`ChannelFuture`	`connect(java.net.SocketAddress remoteAddress, java.net.SocketAddress localAddress)` 请求连接到给定的`SocketAddress`同时绑定到localAddress，并在操作完成后通知`ChannelFuture` ，无论是因为操作成功还是由于错误。
`ChannelFuture`	`connect(java.net.SocketAddress remoteAddress, java.net.SocketAddress localAddress, ChannelPromise promise)` 请求连接到给定的`SocketAddress`同时绑定到localAddress，并在操作完成后通知`ChannelFuture` ，无论是因为操作成功还是由于错误。
`ChannelFuture`	`deregister()` 请求从先前分配的`EventExecutor`注销，并在操作完成后通知`ChannelFuture` ，无论是因为操作成功还是由于错误。
`ChannelFuture`	`deregister(ChannelPromise promise)` 请求从先前分配的`EventExecutor`注销，并在操作完成后通知`ChannelFuture` ，无论是因为操作成功还是由于错误。
`ChannelFuture`	`disconnect()` 请求断开与远程对等方的连接，并在操作完成后通知`ChannelFuture` ，可能是因为操作成功或错误。
`ChannelFuture`	`disconnect(ChannelPromise promise)` 请求从远程对等方断开连接，并在操作完成后通知`ChannelFuture` ，无论是因为操作成功还是由于错误。
`protected abstract void`	`doBeginRead()` 安排读取操作。
`protected abstract void`	`doBind(java.net.SocketAddress localAddress)` 将`Channel`绑定到`SocketAddress`
`protected abstract void`	`doClose()` 关闭`Channel`
`protected void`	`doDeregister()` 注销`Channel`从`EventLoop` 。
`protected abstract void`	`doDisconnect()` 将此`Channel`从其远程对等端断开
`protected void`	`doRegister()` 之后，被称为`Channel`与其注册`EventLoop`作为注册过程的一部分。
`protected void`	`doShutdownOutput()` 当条件证明关闭通道的输出部分时调用。
`protected abstract void`	`doWrite(ChannelOutboundBuffer in)` 将给定缓冲区的内容刷新到远程对等体。
`boolean`	`equals(java.lang.Object o)` 当且仅当指定的对象与此通道相同（即： `this == o` ）时才返回 `true` 。
`EventLoop`	`eventLoop()` 返回`EventLoop`此`Channel`已注册。
`protected java.lang.Object`	`filterOutboundMessage(java.lang.Object msg)` 在将新消息添加到此`AbstractChannel`的`ChannelOutboundBuffer`时调用，以便`Channel`实现将消息转换为另一个消息。
`Channel`	`flush()` 请求通过此ChannelOutboundInvoker清除所有未决消息。
`int`	`hashCode()` 返回此频道的ID。
`ChannelId`	`id()` 返回此`Channel`的全局唯一标识符。
`protected void`	`invalidateLocalAddress()` 已过时。没有这个用例。
`protected void`	`invalidateRemoteAddress()` 已过时。没有这个用例。
`protected abstract boolean`	`isCompatible(EventLoop loop)` 如果给定的`EventLoop`与此实例兼容，则返回`true` 。
`boolean`	`isRegistered()` 返回`true`如果`Channel`与一个注册`EventLoop` 。
`boolean`	`isWritable()` 当且仅当I / O线程将立即执行请求的写入操作时才返回 `true` 。
`java.net.SocketAddress`	`localAddress()` 返回此通道绑定的本地地址。
`protected abstract java.net.SocketAddress`	`localAddress0()` 返回本地绑定的 `SocketAddress` 。
`protected DefaultChannelPipeline`	`newChannelPipeline()` 返回一个新的`DefaultChannelPipeline`实例。
`ChannelFuture`	`newFailedFuture(java.lang.Throwable cause)` 创建一个新的已被标记为失败的`ChannelFuture` 。
`protected ChannelId`	`newId()` 返回一个新的`DefaultChannelId`实例。
`ChannelProgressivePromise`	`newProgressivePromise()` 返回一个新的`ChannelProgressivePromise`
`ChannelPromise`	`newPromise()` 返回一个新的`ChannelPromise` 。
`ChannelFuture`	`newSucceededFuture()` 创建一个新的标记为已成功的`ChannelFuture` 。
`protected abstract AbstractChannel.AbstractUnsafe`	`newUnsafe()` 创建一个新的`AbstractChannel.AbstractUnsafe`实例，该实例将用于`Channel`的生命周期
`Channel`	`parent()` 返回此频道的父级。
`ChannelPipeline`	`pipeline()` 返回分配的`ChannelPipeline` 。
`Channel`	`read()` 请求将`Channel`中的数据读入第一个入站缓冲区，如果读取了数据，则触发`ChannelInboundHandler.channelRead(ChannelHandlerContext, Object)`事件，并触发`channelReadComplete`事件，以便处理程序决定继续读取数据。
`java.net.SocketAddress`	`remoteAddress()` 返回此通道连接到的远程地址。
`protected abstract java.net.SocketAddress`	`remoteAddress0()` 返回`SocketAddress`其中`Channel`被连接到。
`java.lang.String`	`toString()` 返回此频道的 `String`表示形式。
`Channel.Unsafe`	`unsafe()` 返回提供不安全操作的仅供内部使用的对象。
`ChannelPromise`	`voidPromise()` 返回一个特殊的ChannelPromise，可用于不同的操作。
`ChannelFuture`	`write(java.lang.Object msg)` 请求通过`ChannelHandlerContext`通过`ChannelPipeline`写一条消息。
`ChannelFuture`	`write(java.lang.Object msg, ChannelPromise promise)` 要求通过`ChannelHandlerContext`通过`ChannelPipeline`写信息。
`ChannelFuture`	`writeAndFlush(java.lang.Object msg)` 致电 `ChannelOutboundInvoker.write(Object)`和 `ChannelOutboundInvoker.flush()`的快捷方式。
`ChannelFuture`	`writeAndFlush(java.lang.Object msg, ChannelPromise promise)` 致电 `ChannelOutboundInvoker.write(Object, ChannelPromise)`和 `ChannelOutboundInvoker.flush()`的快捷方式。

Methods inherited from class io.netty.util.DefaultAttributeMap
attr, hasAttr

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

Methods inherited from interface io.netty.channel.Channel
config, isActive, isOpen, metadata

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

- 构造方法详细信息
  - AbstractChannel
```
protected AbstractChannel(Channel parent)
```
    创建一个新的实例。
    
    参数
    
    parent - 此频道的母公司。 null如果没有父母。
  - AbstractChannel
```
protected AbstractChannel(Channel parent,
                          ChannelId id)
```
    创建一个新的实例。
    
    参数
    
    parent - 此频道的母公司。 null如果没有父母。
- 方法详细信息
  - id
```
public final ChannelId id()
```
    从接口Channel复制的描述
    
    返回此Channel的全局唯一标识符。
    
    Specified by:
    
    id ，界面 Channel
  - newId
```
protected ChannelId newId()
```
    返回一个新的DefaultChannelId实例。子类可以重写此方法来指定自定义ChannelId s到Channel个使用的S AbstractChannel(Channel)构造。
  - newChannelPipeline
```
protected DefaultChannelPipeline newChannelPipeline()
```
    返回一个新的DefaultChannelPipeline实例。
  - isWritable
```
public boolean isWritable()
```
    从接口Channel复制的描述
    
    当且仅当I / O线程将立即执行请求的写入操作时才返回true 。当此方法返回false时发出的任何写入请求false排队，直到I / O线程准备好处理排队的写入请求。
    
    Specified by:
    
    isWritable在界面 Channel
  - bytesBeforeUnwritable
```
public long bytesBeforeUnwritable()
```
    从接口复制的描述： Channel
    
    获取可以写入多少个字节，直到Channel.isWritable()返回false 。这个数量永远是非负的。如果Channel.isWritable()是false 0。
    
    Specified by:
    
    bytesBeforeUnwritable ，界面 Channel
  - bytesBeforeWritable
```
public long bytesBeforeWritable()
```
    从接口Channel复制的描述
    
    从Channel.isWritable()返回true之前，必须从底层缓冲区中清除多少个字节。这个数量永远是非负的。如果Channel.isWritable()是true 0。
    
    Specified by:
    
    bytesBeforeWritable在界面 Channel
  - parent
```
public Channel parent()
```
    从界面复制的描述： Channel
    
    返回此频道的父级。
    
    Specified by:
    
    parent在界面 Channel
    
    结果
    
    父频道。 null如果此频道没有父频道。
  - pipeline
```
public ChannelPipeline pipeline()
```
    从接口Channel复制的描述
    
    返回指定的ChannelPipeline 。
    
    Specified by:
    
    pipeline在界面 Channel
  - alloc
```
public ByteBufAllocator alloc()
```
    从接口Channel复制的描述
    
    返回分配的ByteBufAllocator这将被用于分配ByteBuf秒。
    
    Specified by:
    
    alloc在界面 Channel
  - eventLoop
```
public EventLoop eventLoop()
```
    从接口Channel复制的描述
    
    返回EventLoop这Channel已注册。
    
    Specified by:
    
    eventLoop在界面 Channel
  - localAddress
```
public java.net.SocketAddress localAddress()
```
    从界面复制的描述： Channel
    
    返回此通道绑定的本地地址。返回的SocketAddress应该被下调为更具体的类型，例如InetSocketAddress以检索详细信息。
    
    Specified by:
    
    localAddress ，界面 Channel
    
    结果
    
    这个频道的本地地址。 null如果此通道未绑定。
  - invalidateLocalAddress
```
@Deprecated
protected void invalidateLocalAddress()
```
    已过时。没有这个用例。
  - remoteAddress
```
public java.net.SocketAddress remoteAddress()
```
    从界面复制而来的描述： Channel
    
    返回此通道连接到的远程地址。返回的SocketAddress应该被放入更具体的类型，例如InetSocketAddress以检索详细信息。
    
    Specified by:
    
    remoteAddress在界面 Channel
    
    结果
    
    该频道的远程地址。 null如果此通道未连接。如果此通道未连接，但它可以接收来自任意远程地址的消息（例如DatagramChannel ，请使用DefaultAddressedEnvelope.recipient()来确定收到消息的来源，因为此方法将返回null 。
  - invalidateRemoteAddress
```
@Deprecated
protected void invalidateRemoteAddress()
```
    已过时。没有这个用例。
  - isRegistered
```
public boolean isRegistered()
```
    从接口Channel复制的描述
    
    如果Channel已注册true则返回true 。
    
    Specified by:
    
    isRegistered在界面 Channel
  - bind
```
public ChannelFuture bind(java.net.SocketAddress localAddress)
```
    从接口复制的描述： ChannelOutboundInvoker
    
    请求绑定到给定的SocketAddress并在操作完成后通知ChannelFuture ，因为操作成功或错误。
    这将导致在具有ChannelOutboundHandler.bind(ChannelHandlerContext, SocketAddress, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    bind在界面 ChannelOutboundInvoker
  - connect
```
public ChannelFuture connect(java.net.SocketAddress remoteAddress)
```
    从接口ChannelOutboundInvoker复制的描述
    
    请求连接到给定的SocketAddress并在操作完成后通知ChannelFuture ，无论是因为操作成功还是由于错误。
    如果由于连接超时而导致连接失败，则ChannelFuture将失败，并显示ConnectTimeoutException 。如果因连接拒绝而失败，将使用ConnectException 。
    
    这将导致在具有ChannelOutboundHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    connect ，界面 ChannelOutboundInvoker
  - connect
```
public ChannelFuture connect(java.net.SocketAddress remoteAddress,
                             java.net.SocketAddress localAddress)
```
    从接口ChannelOutboundInvoker复制的描述
    
    请求连接到给定的SocketAddress同时绑定到localAddress，并在操作完成后通知ChannelFuture ，无论是因为操作成功还是由于错误。
    这将导致在具有ChannelOutboundHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    connect在界面 ChannelOutboundInvoker
  - disconnect
```
public ChannelFuture disconnect()
```
    从界面复制的描述： ChannelOutboundInvoker
    
    请求从远程对等方断开连接，并在操作完成后通知ChannelFuture ，可能是因为操作成功或者由于错误。
    这将导致在具有ChannelOutboundHandler.disconnect(ChannelHandlerContext, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    disconnect ，界面 ChannelOutboundInvoker
  - close
```
public ChannelFuture close()
```
    从接口复制的描述： ChannelOutboundInvoker
    
    请求关闭Channel，并在操作完成后通知ChannelFuture ，无论是因为操作成功还是由于错误。关闭后不可能再次使用它。
    这将导致在具有ChannelOutboundHandler.close(ChannelHandlerContext, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    close在界面 ChannelOutboundInvoker
  - deregister
```
public ChannelFuture deregister()
```
    从接口ChannelOutboundInvoker复制的描述
    
    请求注销以前分配的EventExecutor，并在操作完成后通知ChannelFuture ，无论是因为操作成功还是由于错误。
    这将导致在具有ChannelOutboundHandler.deregister(ChannelHandlerContext, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    deregister在界面 ChannelOutboundInvoker
  - flush
```
public Channel flush()
```
    从界面复制的描述： ChannelOutboundInvoker
    
    请求通过此ChannelOutboundInvoker清除所有未决消息。
    
    Specified by:
    
    flush ，界面 Channel
    
    Specified by:
    
    flush在界面 ChannelOutboundInvoker
  - bind
```
public ChannelFuture bind(java.net.SocketAddress localAddress,
                          ChannelPromise promise)
```
    从界面复制的描述： ChannelOutboundInvoker
    
    请求绑定到给定的SocketAddress并在操作完成后通知ChannelFuture ，这可能是因为操作成功或者由于错误。给定的ChannelPromise将被通知。
    这将导致在具有ChannelOutboundHandler.bind(ChannelHandlerContext, SocketAddress, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    bind在界面 ChannelOutboundInvoker
  - connect
```
public ChannelFuture connect(java.net.SocketAddress remoteAddress,
                             ChannelPromise promise)
```
    从界面复制的描述： ChannelOutboundInvoker
    
    请求连接到给定的SocketAddress并在操作完成后通知ChannelFuture ，这可能是因为操作成功或错误。给定的ChannelFuture将被通知。
    如果由于连接超时而导致连接失败，则ChannelFuture将失败，并显示ConnectTimeoutException 。如果因连接拒绝而失败，将使用ConnectException 。
    
    这将导致在具有ChannelOutboundHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    connect在界面 ChannelOutboundInvoker
  - connect
```
public ChannelFuture connect(java.net.SocketAddress remoteAddress,
                             java.net.SocketAddress localAddress,
                             ChannelPromise promise)
```
    从接口复制的描述： ChannelOutboundInvoker
    
    请求连接到给定的SocketAddress同时绑定到localAddress，并在操作完成后通知ChannelFuture ，无论是因为操作成功还是由于错误。给定的ChannelPromise将被通知并且返回。
    这将导致在具有ChannelOutboundHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    connect在界面 ChannelOutboundInvoker
  - disconnect
```
public ChannelFuture disconnect(ChannelPromise promise)
```
    从接口ChannelOutboundInvoker复制的描述
    
    请求从远程对等方断开连接，并在操作完成后通知ChannelFuture ，无论是因为操作成功还是由于错误。给定的ChannelPromise将被通知。
    这将导致在具有ChannelOutboundHandler.disconnect(ChannelHandlerContext, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    disconnect在界面 ChannelOutboundInvoker
  - close
```
public ChannelFuture close(ChannelPromise promise)
```
    从接口ChannelOutboundInvoker复制的描述
    
    请求关闭Channel，并在操作完成后通知ChannelFuture ，无论是因为操作成功还是由于错误。关闭后不可能再次使用它。给定的ChannelPromise将被通知。
    这将导致在具有ChannelOutboundHandler.close(ChannelHandlerContext, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    close在界面 ChannelOutboundInvoker
  - deregister
```
public ChannelFuture deregister(ChannelPromise promise)
```
    从接口ChannelOutboundInvoker复制的描述
    
    请求注销以前分配的EventExecutor，并在操作完成后通知ChannelFuture ，无论是因为操作成功还是由于错误。给定的ChannelPromise将被通知。
    这将导致在具有ChannelOutboundHandler.deregister(ChannelHandlerContext, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    deregister ，界面 ChannelOutboundInvoker
  - read
```
public Channel read()
```
    从接口ChannelOutboundInvoker复制的描述
    
    请求将数据从Channel读入第一个入站缓冲区，如果读取数据，则触发ChannelInboundHandler.channelRead(ChannelHandlerContext, Object)事件，并触发channelReadComplete事件，以便处理程序可以决定继续读取数据。如果已经有待处理的读取操作，则此方法不执行任何操作。
    这将导致在具有ChannelOutboundHandler.read(ChannelHandlerContext)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    read ，界面 Channel
    
    Specified by:
    
    read ，界面 ChannelOutboundInvoker
  - write
```
public ChannelFuture write(java.lang.Object msg)
```
    从界面复制的描述： ChannelOutboundInvoker
    
    要求通过ChannelHandlerContext通过ChannelPipeline写一条消息。此方法不会请求实际刷新，所以一旦您要请求将所有待处理数据清除到实际传输，请务必调用ChannelOutboundInvoker.flush() 。
    
    Specified by:
    
    write在界面 ChannelOutboundInvoker
  - write
```
public ChannelFuture write(java.lang.Object msg,
                           ChannelPromise promise)
```
    从接口ChannelOutboundInvoker复制的描述
    
    要求通过ChannelHandlerContext通过ChannelPipeline写一条消息。此方法不会请求实际刷新，因此，一旦要请求将所有待处理数据清除到实际传输，请务必调用ChannelOutboundInvoker.flush() 。
    
    Specified by:
    
    write在界面 ChannelOutboundInvoker
  - writeAndFlush
```
public ChannelFuture writeAndFlush(java.lang.Object msg)
```
    从接口ChannelOutboundInvoker复制的描述
    
    快捷方式请致电 ChannelOutboundInvoker.write(Object)和 ChannelOutboundInvoker.flush() 。
    
    Specified by:
    
    writeAndFlush ，界面 ChannelOutboundInvoker
  - writeAndFlush
```
public ChannelFuture writeAndFlush(java.lang.Object msg,
                                   ChannelPromise promise)
```
    从接口ChannelOutboundInvoker复制的描述
    
    致电 ChannelOutboundInvoker.write(Object, ChannelPromise)和 ChannelOutboundInvoker.flush()的快捷方式。
    
    Specified by:
    
    writeAndFlush接口 ChannelOutboundInvoker
  - newPromise
```
public ChannelPromise newPromise()
```
    从接口ChannelOutboundInvoker复制的描述
    
    返回一个新的ChannelPromise 。
    
    Specified by:
    
    newPromise在界面 ChannelOutboundInvoker
  - newProgressivePromise
```
public ChannelProgressivePromise newProgressivePromise()
```
    从界面复制的描述： ChannelOutboundInvoker
    
    返回一个新的ChannelProgressivePromise
    
    Specified by:
    
    newProgressivePromise接口 ChannelOutboundInvoker
  - newSucceededFuture
```
public ChannelFuture newSucceededFuture()
```
    从接口ChannelOutboundInvoker复制的描述
    
    创建一个新的标记为已成功的ChannelFuture 。所以Future.isSuccess()将返回true 。所有FutureListener添加到它将直接通知。同样，每个阻塞方法的调用都会返回而不会阻塞。
    
    Specified by:
    
    newSucceededFuture在界面 ChannelOutboundInvoker
  - newFailedFuture
```
public ChannelFuture newFailedFuture(java.lang.Throwable cause)
```
    从接口ChannelOutboundInvoker复制的描述
    
    创建一个新的已被标记为失败的ChannelFuture 。所以Future.isSuccess()将返回false 。所有FutureListener添加到它将直接通知。同样，每个阻塞方法的调用都会返回而不会阻塞。
    
    Specified by:
    
    newFailedFuture ，界面 ChannelOutboundInvoker
  - closeFuture
```
public ChannelFuture closeFuture()
```
    从接口Channel复制的描述
    
    返回此通道关闭时将通知的ChannelFuture 。此方法始终返回相同的未来实例。
    
    Specified by:
    
    closeFuture ，界面 Channel
  - unsafe
```
public Channel.Unsafe unsafe()
```
    从接口Channel复制的描述
    
    返回提供不安全操作 的仅供内部使用的对象。
    
    Specified by:
    
    unsafe ，界面 Channel
  - newUnsafe
```
protected abstract AbstractChannel.AbstractUnsafe newUnsafe()
```
    创建一个新的AbstractChannel.AbstractUnsafe实例，该实例将用于Channel的生命周期
  - hashCode
```
public final int hashCode()
```
    返回此频道的ID。
    
    重写：
    
    hashCode在课堂 java.lang.Object
  - equals
```
public final boolean equals(java.lang.Object o)
```
    当且仅当指定的对象与此通道相同（即： this == o ）时返回 true 。
    
    重写：
    
    equals在课程 java.lang.Object
  - compareTo
```
public final int compareTo(Channel o)
```
    Specified by:
    
    compareTo ，界面 java.lang.Comparable<Channel>
  - toString
```
public java.lang.String toString()
```
    返回此频道的String表示形式。返回的字符串包含ID ， local address和remote address这个渠道更容易识别。
    
    重写：
    
    toString在课程 java.lang.Object
  - voidPromise
```
public final ChannelPromise voidPromise()
```
    从界面复制而来的描述： ChannelOutboundInvoker
    
    返回一个特殊的ChannelPromise，可用于不同的操作。
    它仅支持将其用于ChannelOutboundInvoker.write(Object, ChannelPromise) 。
    
    请注意，返回的ChannelPromise不支持大多数操作，只应在您希望为每个写入操作保存对象分配时使用。您将无法检测操作是否完成，仅当它失败时才会检测操作是否完成，因为在这种情况下实现将调用ChannelPipeline.fireExceptionCaught(Throwable) 。
    请注意，这是一项专家功能，应谨慎使用！
    
    Specified by:
    
    voidPromise在界面 ChannelOutboundInvoker
  - isCompatible
```
protected abstract boolean isCompatible(EventLoop loop)
```
    如果给定的EventLoop与此实例兼容，则返回true 。
  - localAddress0
```
protected abstract java.net.SocketAddress localAddress0()
```
    返回本地绑定的 SocketAddress 。
  - remoteAddress0
```
protected abstract java.net.SocketAddress remoteAddress0()
```
    返回SocketAddress其中Channel被连接到。
  - doRegister
```
protected void doRegister()
                   throws java.lang.Exception
```
    之后，被称为Channel与其注册EventLoop作为注册过程的一部分。子类可能会覆盖此方法
    
    异常
    
    java.lang.Exception
  - doBind
```
protected abstract void doBind(java.net.SocketAddress localAddress)
                        throws java.lang.Exception
```
    将Channel绑定到SocketAddress
    
    异常
    
    java.lang.Exception
  - doDisconnect
```
protected abstract void doDisconnect()
                              throws java.lang.Exception
```
    将此Channel从其远程对等端断开
    
    异常
    
    java.lang.Exception
  - doClose
```
protected abstract void doClose()
                         throws java.lang.Exception
```
    关闭Channel
    
    异常
    
    java.lang.Exception
  - doShutdownOutput
```
@UnstableApi
protected void doShutdownOutput()
                                      throws java.lang.Exception
```
    当条件证明关闭通道的输出部分时调用。如果写入操作抛出异常，则可能会发生这种情况。
    
    异常
    
    java.lang.Exception
  - doDeregister
```
protected void doDeregister()
                     throws java.lang.Exception
```
    注销Channel从EventLoop 。子类可能会覆盖此方法
    
    异常
    
    java.lang.Exception
  - doBeginRead
```
protected abstract void doBeginRead()
                             throws java.lang.Exception
```
    安排读取操作。
    
    异常
    
    java.lang.Exception
  - doWrite
```
protected abstract void doWrite(ChannelOutboundBuffer in)
                         throws java.lang.Exception
```
    将给定缓冲区的内容刷新到远程对等体。
    
    异常
    
    java.lang.Exception
  - filterOutboundMessage
```
protected java.lang.Object filterOutboundMessage(java.lang.Object msg)
                                          throws java.lang.Exception
```
    当新消息添加到AbstractChannel的ChannelOutboundBuffer中时调用，以便Channel实现将消息转换为另一个消息。（例如堆缓冲区 - >直接缓冲区）
    
    异常
    
    java.lang.Exception

Class AbstractChannel

Nested Class Summary

Nested classes/interfaces inherited from interface io.netty.channel.Channel

构造方法摘要

方法摘要

Methods inherited from class io.netty.util.DefaultAttributeMap

Methods inherited from class java.lang.Object

Methods inherited from interface io.netty.channel.Channel

Methods inherited from interface io.netty.util.AttributeMap

构造方法详细信息

AbstractChannel

AbstractChannel

方法详细信息

id

newId

newChannelPipeline

isWritable

bytesBeforeUnwritable

bytesBeforeWritable

parent

pipeline

alloc

eventLoop

localAddress

invalidateLocalAddress

remoteAddress

invalidateRemoteAddress

isRegistered

bind

connect

connect

disconnect

close

deregister

flush

bind

connect

connect

disconnect

close

deregister

read

write

write

writeAndFlush

writeAndFlush

newPromise

newProgressivePromise

newSucceededFuture

newFailedFuture

closeFuture

unsafe

newUnsafe

hashCode

equals

compareTo

toString

voidPromise

isCompatible

localAddress0

remoteAddress0

doRegister

doBind

doDisconnect

doClose

doShutdownOutput

doDeregister

doBeginRead

doWrite

filterOutboundMessage