EmbeddedChannel (Netty API Reference (4.1.22.Final))

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

All Implemented Interfaces:

Channel ， ChannelOutboundInvoker ， AttributeMap ，java.lang.Comparable的< Channel >
```
public class EmbeddedChannel
extends AbstractChannel
```
用于嵌入式时尚的Channel实现的基类。

Nested Class Summary
- Nested classes/interfaces inherited from class io.netty.channel.AbstractChannel
  AbstractChannel.AbstractUnsafe
- Nested classes/interfaces inherited from interface io.netty.channel.Channel
  Channel.Unsafe

构造方法摘要

构造方法
Constructor and Description
`EmbeddedChannel()` 用 `EmbeddedChannelId`和一个空管道创建一个新实例。
`EmbeddedChannel(boolean register, boolean hasDisconnect, ChannelHandler... handlers)` 使用指定的处理程序初始化管道创建一个新实例。
`EmbeddedChannel(boolean hasDisconnect, ChannelHandler... handlers)` 使用指定的处理程序初始化管道创建一个新实例。
`EmbeddedChannel(ChannelHandler... handlers)` 使用指定的处理程序初始化管道创建一个新实例。
`EmbeddedChannel(ChannelId channelId)` 使用指定的ID和空管道创建一个新实例。
`EmbeddedChannel(ChannelId channelId, boolean register, boolean hasDisconnect, ChannelHandler... handlers)` 创建一个新的实例，将通道ID设置为给定ID，并使用指定的处理程序初始化管道。
`EmbeddedChannel(ChannelId channelId, boolean hasDisconnect, ChannelConfig config, ChannelHandler... handlers)` 创建一个新的实例，将通道ID设置为给定ID，并使用指定的处理程序初始化管道。
`EmbeddedChannel(ChannelId channelId, boolean hasDisconnect, ChannelHandler... handlers)` 创建一个新的实例，将通道ID设置为给定ID，并使用指定的处理程序初始化管道。
`EmbeddedChannel(ChannelId channelId, ChannelHandler... handlers)` 创建一个新的实例，将通道ID设置为给定ID，并使用指定的处理程序初始化管道。

方法摘要

所有方法接口方法具体的方法弃用的方法
Modifier and Type	Method and Description
`void`	`checkException()` 检查是否收到任何 `Throwable` ，如果是这样重新抛出它。
`ChannelFuture`	`close()` 请求关闭`Channel`，并在操作完成后通知`ChannelFuture` ，无论是因为操作成功还是由于错误。
`ChannelFuture`	`close(ChannelPromise promise)` 请求关闭`Channel`，并在操作完成后通知`ChannelFuture` ，无论是因为操作成功还是由于错误。
`ChannelConfig`	`config()` 返回此频道的配置。
`ChannelFuture`	`disconnect()` 请求从远程对等方断开连接，并在操作完成后通知`ChannelFuture` ，因为操作成功或错误。
`ChannelFuture`	`disconnect(ChannelPromise promise)` 请求从远程对等方断开连接，并在操作完成后通知`ChannelFuture` ，无论是因为操作成功还是由于错误。
`protected void`	`doBeginRead()` 安排读取操作。
`protected void`	`doBind(java.net.SocketAddress localAddress)` 将`Channel`绑定到`SocketAddress`
`protected void`	`doClose()` 关闭`Channel`
`protected void`	`doDisconnect()` 将此`Channel`从其远程对等方断开
`protected void`	`doRegister()` 之后，被称为`Channel`与其注册`EventLoop`作为注册过程的一部分。
`protected void`	`doWrite(ChannelOutboundBuffer in)` 将给定缓冲区的内容刷新到远程对等体。
`protected void`	`ensureOpen()` 确保`Channel`已打开，并且不会抛出异常。
`boolean`	`finish()` 将此`Channel`标记为完成。
`boolean`	`finishAndReleaseAll()` 将此`Channel`标记为已完成，并释放入站和出站缓冲区中的所有待处理消息。
`EmbeddedChannel`	`flushInbound()` 刷新此`Channel`的入站。
`EmbeddedChannel`	`flushOutbound()` 刷新此`Channel`的出站。
`protected void`	`handleInboundMessage(java.lang.Object msg)` 针对每个入站消息进行调用。
`protected void`	`handleOutboundMessage(java.lang.Object msg)` 针对每个出站消息进行调用。
`java.util.Queue<java.lang.Object>`	`inboundMessages()` 返回`Queue` ，其中包含`Object`收到的所有Object 。
`boolean`	`isActive()` 如果`Channel`处于活动状态且已连接，则返回`true` 。
`protected boolean`	`isCompatible(EventLoop loop)` 如果给定的`EventLoop`与此实例兼容，则返回`true` 。
`boolean`	`isOpen()` 如果`Channel`已打开并且稍后可能会激活，则返回`true`
`java.util.Queue<java.lang.Object>`	`lastInboundBuffer()` 已过时。使用`inboundMessages()`
`java.util.Queue<java.lang.Object>`	`lastOutboundBuffer()` 已过时。使用`outboundMessages()`
`protected java.net.SocketAddress`	`localAddress0()` 返回本地绑定的 `SocketAddress` 。
`ChannelMetadata`	`metadata()` 返回`ChannelMetadata`的的`Channel`其描述的性质`Channel` 。
`protected DefaultChannelPipeline`	`newChannelPipeline()` 返回一个新的`DefaultChannelPipeline`实例。
`protected AbstractChannel.AbstractUnsafe`	`newUnsafe()` 创建一个新的`AbstractChannel.AbstractUnsafe`实例，该实例将用于`Channel`的生命周期
`java.util.Queue<java.lang.Object>`	`outboundMessages()` 返回`Queue` ，其中包含由`Object`编写的所有Object 。
`<T> T`	`readInbound()` 返回从`Channel`收到的数据
`<T> T`	`readOutbound()` 从出站读取数据。
`void`	`register()` 在`Channel`上注册这个Channel 。
`boolean`	`releaseInbound()` 释放所有缓存入站邮件，并返回 `true`如果任何人的入缓冲区， `false`其他。
`boolean`	`releaseOutbound()` 释放所有缓冲出站消息，并返回 `true`如果任何人在出站缓冲， `false`其他。
`protected java.net.SocketAddress`	`remoteAddress0()` 返回`SocketAddress`其中`Channel`被连接到。
`void`	`runPendingTasks()` 运行`EventLoop`中的所有未完成任务（其中还包括计划任务），用于此`Channel`
`long`	`runScheduledPendingTasks()` 在`EventLoop`中为`Channel`运行所有待处理的计划任务，并在下一个计划任务准备好运行时返回`nanoseconds` 。
`Channel.Unsafe`	`unsafe()` 返回提供不安全操作的仅供内部使用的对象。
`boolean`	`writeInbound(java.lang.Object... msgs)` 将消息写入此`Channel`的入站。
`ChannelFuture`	`writeOneInbound(java.lang.Object msg)` 向此`Channel`的入站写入一条消息，但不刷新它。
`ChannelFuture`	`writeOneInbound(java.lang.Object msg, ChannelPromise promise)` 向此`Channel`的入站写入一条消息，但不刷新它。
`ChannelFuture`	`writeOneOutbound(java.lang.Object msg)` 向此`Channel`的出站端写入一条消息，但不会刷新它。
`ChannelFuture`	`writeOneOutbound(java.lang.Object msg, ChannelPromise promise)` 向此`Channel`的出站端写入一条消息，但不刷新它。
`boolean`	`writeOutbound(java.lang.Object... msgs)` 将消息写入此`Channel`的出站。

Methods inherited from class io.netty.channel.AbstractChannel
alloc, bind, bind, bytesBeforeUnwritable, bytesBeforeWritable, closeFuture, compareTo, connect, connect, connect, connect, deregister, deregister, doDeregister, doShutdownOutput, equals, eventLoop, filterOutboundMessage, flush, hashCode, id, invalidateLocalAddress, invalidateRemoteAddress, isRegistered, isWritable, localAddress, newFailedFuture, newId, newProgressivePromise, newPromise, newSucceededFuture, parent, pipeline, read, remoteAddress, toString, voidPromise, write, write, writeAndFlush, writeAndFlush

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.util.AttributeMap
attr, hasAttr

- 构造方法详细信息
  - EmbeddedChannel
```
public EmbeddedChannel()
```
    用 EmbeddedChannelId和一个空管道创建一个新实例。
  - EmbeddedChannel
```
public EmbeddedChannel(ChannelId channelId)
```
    使用指定的ID和空管道创建一个新实例。
    
    参数
    
    channelId - 将用于识别此频道的ChannelId
  - EmbeddedChannel
```
public EmbeddedChannel(ChannelHandler... handlers)
```
    使用指定的处理程序初始化管道创建一个新实例。
    
    参数
    
    handlers - 将在ChannelPipeline中添加的ChannelHandler
  - EmbeddedChannel
```
public EmbeddedChannel(boolean hasDisconnect,
                       ChannelHandler... handlers)
```
    使用指定的处理程序初始化管道创建一个新实例。
    
    参数
    
    hasDisconnect - false ，如果这Channel将委托disconnect()至close() ， false其他。
    
    handlers - 将在ChannelPipeline中添加的ChannelHandler
  - EmbeddedChannel
```
public EmbeddedChannel(boolean register,
                       boolean hasDisconnect,
                       ChannelHandler... handlers)
```
    使用指定的处理程序初始化管道创建一个新实例。
    
    参数
    
    register - true如果此Channel已在构造函数中注册到EventLoop 。如果false用户需要拨打register() 。
    
    hasDisconnect - false ，如果这Channel将委托disconnect()至close() ， false其他。
    
    handlers - 将在ChannelPipeline中添加的ChannelHandler
  - EmbeddedChannel
```
public EmbeddedChannel(ChannelId channelId,
                       ChannelHandler... handlers)
```
    创建一个新的实例，将通道ID设置为给定ID，并使用指定的处理程序初始化管道。
    
    参数
    
    channelId - 将用于识别此频道的ChannelId
    
    handlers - 将在ChannelPipeline中添加的ChannelHandler
  - EmbeddedChannel
```
public EmbeddedChannel(ChannelId channelId,
                       boolean hasDisconnect,
                       ChannelHandler... handlers)
```
    创建一个新的实例，将通道ID设置为给定ID，并使用指定的处理程序初始化管道。
    
    参数
    
    channelId - 将用于识别此频道的ChannelId
    
    hasDisconnect - false如果这Channel将委托disconnect() close() ，否则false 。
    
    handlers - 将在ChannelPipeline中添加的ChannelHandler
  - EmbeddedChannel
```
public EmbeddedChannel(ChannelId channelId,
                       boolean register,
                       boolean hasDisconnect,
                       ChannelHandler... handlers)
```
    创建一个新的实例，将通道ID设置为给定ID，并使用指定的处理程序初始化管道。
    
    参数
    
    channelId - 将用于识别此频道的ChannelId
    
    register - true如果此Channel已在构造函数中注册到EventLoop 。如果false用户需要拨打register() 。
    
    hasDisconnect - false ，如果这Channel将委托disconnect()至close() ， false其他。
    
    handlers - 将在ChannelPipeline中添加的ChannelHandler
  - EmbeddedChannel
```
public EmbeddedChannel(ChannelId channelId,
                       boolean hasDisconnect,
                       ChannelConfig config,
                       ChannelHandler... handlers)
```
    创建一个新的实例，将通道ID设置为给定ID，并使用指定的处理程序初始化管道。
    
    参数
    
    channelId - 将用于识别此频道的ChannelId
    
    hasDisconnect - false ，如果这Channel将委托disconnect()至close() ， false其他。
    
    config - 将由config()返回的ChannelConfig 。
    
    handlers - 将在ChannelPipeline中添加的ChannelHandler
- 方法详细信息
  - register
```
public void register()
              throws java.lang.Exception
```
    在Channel上注册这个Channel 。
    
    异常
    
    java.lang.Exception
  - newChannelPipeline
```
protected final DefaultChannelPipeline newChannelPipeline()
```
    从类复制的描述： AbstractChannel
    
    返回一个新的DefaultChannelPipeline实例。
    
    重写：
    
    newChannelPipeline在课堂 AbstractChannel
  - metadata
```
public ChannelMetadata metadata()
```
    从接口Channel复制的描述
    
    返回ChannelMetadata的的Channel其描述的性质Channel 。
  - config
```
public ChannelConfig config()
```
    从接口Channel复制的描述
    
    返回此频道的配置。
  - isOpen
```
public boolean isOpen()
```
    从接口Channel复制的描述
    
    如果Channel已打开并且稍后可能会激活，则返回true
  - isActive
```
public boolean isActive()
```
    从接口Channel复制的描述
    
    如果Channel处于活动状态并已连接，则返回true 。
  - inboundMessages
```
public java.util.Queue<java.lang.Object> inboundMessages()
```
    返回Queue ，其中包含Object收到的所有Object 。
  - lastInboundBuffer
```
@Deprecated
public java.util.Queue<java.lang.Object> lastInboundBuffer()
```
    已过时。使用inboundMessages()
  - outboundMessages
```
public java.util.Queue<java.lang.Object> outboundMessages()
```
    返回Queue ，它包含由Object编写的所有Object 。
  - lastOutboundBuffer
```
@Deprecated
public java.util.Queue<java.lang.Object> lastOutboundBuffer()
```
    已过时。使用outboundMessages()
  - readInbound
```
public <T> T readInbound()
```
    返回从Channel收到的数据
  - readOutbound
```
public <T> T readOutbound()
```
    从出站读取数据。如果null读取，则可能会返回null 。
  - writeInbound
```
public boolean writeInbound(java.lang.Object... msgs)
```
    将消息写入此Channel的入站。
    
    参数
    
    msgs - 要写入的消息
    
    结果
    
    true如果写入操作确实向入站缓冲区添加了某些内容
  - writeOneInbound
```
public ChannelFuture writeOneInbound(java.lang.Object msg)
```
    向此Channel的入站写入一条消息，但不刷新它。该方法在概念上等同于AbstractChannel.write(Object) 。
    
    另请参见：
    
    writeOneOutbound(Object)
  - writeOneInbound
```
public ChannelFuture writeOneInbound(java.lang.Object msg,
                                     ChannelPromise promise)
```
    向此Channel的入站写入一条消息，但不刷新它。该方法在概念上等同于AbstractChannel.write(Object, ChannelPromise) 。
    
    另请参见：
    
    writeOneOutbound(Object, ChannelPromise)
  - flushInbound
```
public EmbeddedChannel flushInbound()
```
    刷新此Channel的入站。该方法在概念上等同于AbstractChannel.flush() 。
    
    另请参见：
    
    flushOutbound()
  - writeOutbound
```
public boolean writeOutbound(java.lang.Object... msgs)
```
    将消息写入此Channel的出站。
    
    参数
    
    msgs - 要写入的消息
    
    结果
    
    如果写入操作确实向出站缓冲区添加了某些内容，则bufferReadable返回 true
  - writeOneOutbound
```
public ChannelFuture writeOneOutbound(java.lang.Object msg)
```
    向此Channel的出站端写入一条消息，但不刷新它。该方法在概念上等同于AbstractChannel.write(Object) 。
    
    另请参见：
    
    writeOneInbound(Object)
  - writeOneOutbound
```
public ChannelFuture writeOneOutbound(java.lang.Object msg,
                                      ChannelPromise promise)
```
    向此Channel的出站端写入一条消息，但不刷新它。该方法在概念上等同于AbstractChannel.write(Object, ChannelPromise) 。
    
    另请参见：
    
    writeOneInbound(Object, ChannelPromise)
  - flushOutbound
```
public EmbeddedChannel flushOutbound()
```
    刷新此Channel的出站。该方法在概念上等同于AbstractChannel.flush() 。
    
    另请参见：
    
    flushInbound()
  - finish
```
public boolean finish()
```
    将此Channel标记为完成。进一步尝试写入数据将失败。
    
    结果
    
    如果任何使用的缓冲区有剩下可读的 true则bufferReadable返回 true
  - finishAndReleaseAll
```
public boolean finishAndReleaseAll()
```
    将此Channel标记为已完成，并释放入站和出站缓冲区中的所有待处理消息。进一步尝试写入数据将失败。
    
    结果
    
    如果任何使用的缓冲区有剩下可读的 true则bufferReadable返回 true
  - releaseInbound
```
public boolean releaseInbound()
```
    释放所有缓存入站邮件，并返回 true如果任何人的入缓冲区， false其他。
  - releaseOutbound
```
public boolean releaseOutbound()
```
    释放所有缓冲出站消息，并返回 true如果任何人在出站缓冲， false其他。
  - close
```
public final ChannelFuture close()
```
    从接口复制的描述： ChannelOutboundInvoker
    
    一旦操作完成，请求关闭Channel并通知ChannelFuture ，无论是因为操作成功还是由于错误。关闭后不可能再次使用它。
    这将导致在具有ChannelOutboundHandler.close(ChannelHandlerContext, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    close在界面 ChannelOutboundInvoker
    
    重写：
    
    close上课 AbstractChannel
  - disconnect
```
public final ChannelFuture disconnect()
```
    从界面复制的描述： ChannelOutboundInvoker
    
    请求从远程对等方断开连接，并在操作完成后通知ChannelFuture ，无论是因为操作成功还是由于错误。
    这将导致在具有ChannelOutboundHandler.disconnect(ChannelHandlerContext, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    disconnect在界面 ChannelOutboundInvoker
    
    重写：
    
    disconnect在课堂上 AbstractChannel
  - close
```
public final ChannelFuture close(ChannelPromise promise)
```
    从界面复制的描述： ChannelOutboundInvoker
    
    请求关闭Channel，并在操作完成后通知ChannelFuture ，无论是因为操作成功还是由于错误。关闭后不可能再次使用它。给定的ChannelPromise将被通知。
    这将导致在具有ChannelOutboundHandler.close(ChannelHandlerContext, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    close ，界面 ChannelOutboundInvoker
    
    重写：
    
    close在课堂上 AbstractChannel
  - disconnect
```
public final ChannelFuture disconnect(ChannelPromise promise)
```
    从接口复制的描述： ChannelOutboundInvoker
    
    请求断开与远程对等方的连接，并在操作完成后通知ChannelFuture ，无论是因为操作成功还是由于错误。给定的ChannelPromise将被通知。
    这将导致在具有ChannelOutboundHandler.disconnect(ChannelHandlerContext, ChannelPromise)方法称为下一个的ChannelOutboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    disconnect在界面 ChannelOutboundInvoker
    
    重写：
    
    disconnect在课堂上 AbstractChannel
  - runPendingTasks
```
public void runPendingTasks()
```
    运行所有任务（其中还包括计划任务），这些正待EventLoop这个Channel
  - runScheduledPendingTasks
```
public long runScheduledPendingTasks()
```
    运行在所有悬而未决的计划任务EventLoop这个Channel并返回nanoseconds下一个计划任务准备运行。如果没有安排其他任务，它将返回-1 。
  - checkException
```
public void checkException()
```
    检查是否有任何 Throwable收到，如果是这样重新抛出它。
  - ensureOpen
```
protected final void ensureOpen()
```
    确保Channel已打开，并且不会抛出异常。
  - isCompatible
```
protected boolean isCompatible(EventLoop loop)
```
    从类复制的描述： AbstractChannel
    
    如果给定的EventLoop与此实例兼容，则返回true 。
    
    Specified by:
    
    isCompatible ，班级 AbstractChannel
  - localAddress0
```
protected java.net.SocketAddress localAddress0()
```
    从类复制的描述： AbstractChannel
    
    返回本地绑定的 SocketAddress 。
    
    Specified by:
    
    localAddress0在课堂上 AbstractChannel
  - remoteAddress0
```
protected java.net.SocketAddress remoteAddress0()
```
    从类复制的描述： AbstractChannel
    
    返回SocketAddress其中Channel被连接到。
    
    Specified by:
    
    remoteAddress0 class AbstractChannel
  - doRegister
```
protected void doRegister()
                   throws java.lang.Exception
```
    从类复制的描述： AbstractChannel
    
    之后，被称为Channel与其注册EventLoop作为注册过程的一部分。子类可能会覆盖此方法
    
    重写：
    
    doRegister在课堂 AbstractChannel
    
    异常
    
    java.lang.Exception
  - doBind
```
protected void doBind(java.net.SocketAddress localAddress)
               throws java.lang.Exception
```
    从类复制的描述： AbstractChannel
    
    将Channel绑定到SocketAddress
    
    Specified by:
    
    doBind在课堂 AbstractChannel
    
    异常
    
    java.lang.Exception
  - doDisconnect
```
protected void doDisconnect()
                     throws java.lang.Exception
```
    从类复制的描述： AbstractChannel
    
    将此Channel从其远程对等方断开
    
    Specified by:
    
    doDisconnect在课堂上 AbstractChannel
    
    异常
    
    java.lang.Exception
  - doClose
```
protected void doClose()
                throws java.lang.Exception
```
    从类复制的描述： AbstractChannel
    
    关闭Channel
    
    Specified by:
    
    doClose在课堂上 AbstractChannel
    
    异常
    
    java.lang.Exception
  - doBeginRead
```
protected void doBeginRead()
                    throws java.lang.Exception
```
    从类复制的描述： AbstractChannel
    
    安排读取操作。
    
    Specified by:
    
    doBeginRead类 AbstractChannel
    
    异常
    
    java.lang.Exception
  - newUnsafe
```
protected AbstractChannel.AbstractUnsafe newUnsafe()
```
    从类复制的描述： AbstractChannel
    
    创建一个新的AbstractChannel.AbstractUnsafe实例，该实例将用于Channel的生命周期
    
    Specified by:
    
    newUnsafe在课堂上 AbstractChannel
  - unsafe
```
public Channel.Unsafe unsafe()
```
    从接口复制的描述： Channel
    
    返回提供不安全操作 的仅供内部使用的对象。
    
    Specified by:
    
    unsafe ，界面 Channel
    
    重写：
    
    unsafe在课堂上 AbstractChannel
  - doWrite
```
protected void doWrite(ChannelOutboundBuffer in)
                throws java.lang.Exception
```
    从类复制的描述： AbstractChannel
    
    将给定缓冲区的内容刷新到远程对等体。
    
    Specified by:
    
    doWrite在课堂上 AbstractChannel
    
    异常
    
    java.lang.Exception
  - handleOutboundMessage
```
protected void handleOutboundMessage(java.lang.Object msg)
```
    针对每个出站消息进行调用。
    
    另请参见：
    
    doWrite(ChannelOutboundBuffer)
  - handleInboundMessage
```
protected void handleInboundMessage(java.lang.Object msg)
```
    Called for each inbound message.

Class EmbeddedChannel

Nested Class Summary

Nested classes/interfaces inherited from class io.netty.channel.AbstractChannel

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

构造方法摘要

方法摘要

Methods inherited from class io.netty.channel.AbstractChannel

Methods inherited from class io.netty.util.DefaultAttributeMap

Methods inherited from class java.lang.Object

Methods inherited from interface io.netty.util.AttributeMap

构造方法详细信息

EmbeddedChannel

EmbeddedChannel

EmbeddedChannel

EmbeddedChannel

EmbeddedChannel

EmbeddedChannel

EmbeddedChannel

EmbeddedChannel

EmbeddedChannel

方法详细信息

register

newChannelPipeline

metadata

config

isOpen

isActive

inboundMessages

lastInboundBuffer

outboundMessages

lastOutboundBuffer

readInbound

readOutbound

writeInbound

writeOneInbound

writeOneInbound

flushInbound

writeOutbound

writeOneOutbound

writeOneOutbound

flushOutbound

finish

finishAndReleaseAll

releaseInbound

releaseOutbound

close

disconnect

close

disconnect

runPendingTasks

runScheduledPendingTasks

checkException

ensureOpen

isCompatible

localAddress0

remoteAddress0

doRegister

doBind

doDisconnect

doClose

doBeginRead

newUnsafe

unsafe

doWrite

handleOutboundMessage

handleInboundMessage