Netty学习之旅------Netty Channel 概述

最新推荐文章于 2024-05-24 02:30:00 发布

2401_83915450

最新推荐文章于 2024-05-24 02:30:00 发布

阅读量1k

点赞数 29

分类专栏：程序员文章标签：学习 java 前端

本文链接：https://blog.csdn.net/2401_83915450/article/details/137561683

版权

程序员专栏收录该内容

558 篇文章 0 订阅

订阅专栏

ChannelFuture newSucceededFuture();

/**

Create a new {@link ChannelFuture} which is marked as failed already. So {@link ChannelFuture#isSuccess()}
will return {@code false}. All {@link FutureListener} added to it will be notified directly. Also
every call of blocking methods will just return without blocking.

ChannelFuture newFailedFuture(Throwable cause);

/**

Return a special ChannelPromise which can be reused for different operations.
It’s only supported to use
it for {@link Channel#write(Object, ChannelPromise)}.
Be aware that the returned {@link ChannelPromise} will not support most operations and should only be used
if you want to save an object allocation for every write operation. You will not be able to detect if the
operation was complete, only if it failed as the implementation will call
{@link ChannelPipeline#fireExceptionCaught(Throwable)} in this case.
Be aware this is an expert feature and should be used with care!

ChannelPromise voidPromise();

/**

Request to bind to the given {@link SocketAddress} and notify the {@link ChannelFuture} once the operation
completes, either because the operation was successful or because of an error.
This will result in having the
{@link ChannelHandler#bind(ChannelHandlerContext, SocketAddress, ChannelPromise)} method
called of the next {@link ChannelHandler} contained in the {@link ChannelPipeline} of the
{@link Channel}.
绑定

ChannelFuture bind(SocketAddress localAddress);

/**

Request to connect to the given {@link SocketAddress} and notify the {@link ChannelFuture} 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 {@link ChannelFuture} will get failed with
a {@link ConnectTimeoutException}. If it fails because of connection refused a {@link ConnectException}
will be used.
This will result in having the
{@link ChannelHandler#connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise)}
method called of the next {@link ChannelHandler} contained in the {@link ChannelPipeline} of the
{@link Channel}.
连接

ChannelFuture connect(SocketAddress remoteAddress);

/**

Request to connect to the given {@link SocketAddress} while bind to the localAddress and notify the
{@link ChannelFuture} once the operation completes, either because the operation was successful or because of
an error.
This will result in having the
{@link ChannelHandler#connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise)}
method called of the next {@link ChannelHandler} contained in the {@link ChannelPipeline} of the
{@link Channel}.

ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress);

/**

Request to disconnect from the remote peer and notify the {@link ChannelFuture} once the operation completes,
either because the operation was successful or because of an error.
This will result in having the
{@link ChannelHandler#disconnect(ChannelHandlerContext, ChannelPromise)}
method called of the next {@link ChannelHandler} contained in the {@link ChannelPipeline} of the
{@link Channel}.
断开连接

ChannelFuture disconnect();

/**

Request to close this {@link Channel} and notify the {@link ChannelFuture} 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
{@link ChannelHandler#close(ChannelHandlerContext, ChannelPromise)}
method called of the next {@link ChannelHandler} contained in the {@link ChannelPipeline} of the
{@link Channel}.
关闭，释放通道资源

ChannelFuture close();

/**

Request to deregister this {@link Channel} from its assigned {@link EventLoop} and notify the
{@link ChannelFuture} once the operation completes, either because the operation was successful or because of
an error.
This will result in having the
{@link ChannelHandler#deregister(ChannelHandlerContext, ChannelPromise)}
method called of the next {@link ChannelHandler} contained in the {@link ChannelPipeline} of the
{@link Channel}.
After this method completes (not the {@link ChannelFuture}!) one can not submit new tasks to the
{@link Channel}'s {@link EventLoop} until the {@link Channel} is again registered with an {@link EventLoop}.
Any attempt to do so will result in a {@link RejectedExecutionException} being thrown.
Any tasks that were submitted before the call to {@link #deregister()} will finish before the
{@link ChannelFuture} completes. Furthermore, periodic and delayed tasks will not be executed until the
{@link Channel} is registered with an {@link EventLoop} again. Theses are tasks submitted
to the {@link EventLoop} via one of the methods declared by {@link ScheduledExecutorService}.
Please note that all of the above only applies to tasks created from within the deregistered {@link Channel}'s
{@link ChannelHandler}s.
It’s only safe to {@linkplain EventLoop#register(Channel)} the {@link Channel} with another (or the same)
{@link EventLoop} after the {@link ChannelFuture} has completed.

ChannelFuture deregister();

/**

Request to bind to the given {@link SocketAddress} and notify the {@link ChannelFuture} once the operation
completes, either because the operation was successful or because of an error.
The given {@link ChannelPromise} will be notified.
This will result in having the
{@link ChannelHandler#bind(ChannelHandlerContext, SocketAddress, ChannelPromise)} method
called of the next {@link ChannelHandler} contained in the {@link ChannelPipeline} of the
{@link Channel}.

ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise);

/**

Request to connect to the given {@link SocketAddress} and notify the {@link ChannelFuture} once the operation
completes, either because the operation was successful or because of an error.
The given {@link ChannelFuture} will be notified.
If the connection fails because of a connection timeout, the {@link ChannelFuture} will get failed with
a {@link ConnectTimeoutException}. If it fails because of connection refused a {@link ConnectException}
will be used.
This will result in having the
{@link ChannelHandler#connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise)}
method called of the next {@link ChannelHandler} contained in the {@link ChannelPipeline} of the
{@link Channel}.

ChannelFuture connect(SocketAddress remoteAddress, ChannelPromise promise);

/**

Request to connect to the given {@link SocketAddress} while bind to the localAddress and notify the
{@link ChannelFuture} once the operation completes, either because the operation was successful or because of
an error.
The given {@link ChannelPromise} will be notified and also returned.
This will result in having the
{@link ChannelHandler#connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise)}
method called of the next {@link ChannelHandler} contained in the {@link ChannelPipeline} of the
{@link Channel}.

ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise);

/**

Request to disconnect from the remote peer and notify the {@link ChannelFuture} once the operation completes,
either because the operation was successful or because of an error.
The given {@link ChannelPromise} will be notified.
This will result in having the
{@link ChannelHandler#disconnect(ChannelHandlerContext, ChannelPromise)}
method called of the next {@link ChannelHandler} contained in the {@link ChannelPipeline} of the
{@link Channel}.

ChannelFuture disconnect(ChannelPromise promise);

/**

Request to close this {@link Channel} and notify the {@link ChannelFuture} 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.
The given {@link ChannelPromise} will be notified.
This will result in having the
{@link ChannelHandler#close(ChannelHandlerContext, ChannelPromise)}
method called of the next {@link ChannelHandler} contained in the {@link ChannelPipeline} of the
{@link Channel}.

ChannelFuture close(ChannelPromise promise);

/**

Request to deregister this {@link Channel} from its assigned {@link EventLoop} and notify the
{@link ChannelPromise} once the operation completes, either because the operation was successful or because of
an error.
This will result in having the
{@link ChannelHandler#deregister(ChannelHandlerContext, ChannelPromise)}
method called of the next {@link ChannelHandler} contained in the {@link ChannelPipeline} of the
{@link Channel}.
After this method completes (not the {@link ChannelPromise}!) one can not submit new tasks to the
{@link Channel}'s {@link EventLoop} until the {@link Channel} is again registered with an {@link EventLoop}.
Any attempt to do so will result in a {@link RejectedExecutionException} being thrown.
Any tasks that were submitted before the call to {@link #deregister()} will finish before the
{@link ChannelPromise} completes. Furthermore, periodic and delayed tasks will not be executed until the
{@link Channel} is registered with an {@link EventLoop} again. Theses are tasks submitted
to the {@link EventLoop} via one of the methods declared by {@link ScheduledExecutorService}.
Please note that all of the above only applies to tasks created from within the deregistered {@link Channel}'s
{@link ChannelHandler}s.
It’s only safe to {@linkplain EventLoop#register(Channel)} the {@link Channel} with another (or the same)
{@link EventLoop} after the {@link ChannelPromise} has completed.

ChannelFuture deregister(ChannelPromise promise);

/**

Request to Read data from the {@link Channel} into the first inbound buffer, triggers an
{@link ChannelHandler#channelRead(ChannelHandlerContext, Object)} event if data was
read, and triggers a
{@link ChannelHandler#channelReadComplete(ChannelHandlerContext) 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
{@link ChannelHandler#read(ChannelHandlerContext)}
method called of the next {@link ChannelHandler} contained in the {@link ChannelPipeline} of the
{@link Channel}.

Channel read();

/**

Request to write a message via this {@link Channel} through the {@link ChannelPipeline}.
This method will not request to actual flush, so be sure to call {@link #flush()}
once you want to request to flush all pending data to the actual transport.

ChannelFuture write(Object msg);

/**

Request to write a message via this {@link Channel} through the {@link ChannelPipeline}.
This method will not request to actual flush, so be sure to call {@link #flush()}
once you want to request to flush all pending data to the actual transport.

ChannelFuture write(Object msg, ChannelPromise promise);

/**

Request to flush all pending messages.

Channel flush();

/**

Shortcut for call {@link #write(Object, ChannelPromise)} and {@link #flush()}.

ChannelFuture writeAndFlush(Object msg, ChannelPromise promise);

/**

Shortcut for call {@link #write(Object)} and {@link #flush()}.

ChannelFuture writeAndFlush(Object msg);

/**

Unsafe operations that should never be called from user-code. These methods
are only provided to implement the actual transport, and must be invoked from an I/O thread except for the
following methods:
{@link #invoker()}
{@link #localAddress()}
{@link #remoteAddress()}
{@link #closeForcibly()}
{@link #register(EventLoop, ChannelPromise)}
{@link #deregister(ChannelPromise)}
{@link #voidPromise()}

interface Unsafe {

/**

Return the assigned {@link RecvByteBufAllocator.Handle} which will be used to allocate {@link ByteBuf}'s when
receiving data.

RecvByteBufAllocator.Handle recvBufAllocHandle();

/**

Returns the {@link ChannelHandlerInvoker} which is used by default unless specified by a user.

ChannelHandlerInvoker invoker();

/**

Return the {@link SocketAddress} to which is bound local or
{@code null} if none.

SocketAddress localAddress();

/**

Return the {@link SocketAddress} to which is bound remote or
{@code null} if none is bound yet.

SocketAddress remoteAddress();

/**

Register the {@link Channel} of the {@link ChannelPromise} and notify
the {@link ChannelFuture} once the registration was complete.
It’s only safe to submit a new task to the {@link EventLoop} from within a
{@link ChannelHandler} once the {@link ChannelPromise} succeeded. Otherwise
the task may or may not be rejected.

void register(EventLoop eventLoop, ChannelPromise promise);

/**

Bind the {@link SocketAddress} to the {@link Channel} of the {@link ChannelPromise} and notify
it once its done.

void bind(SocketAddress localAddress, ChannelPromise promise);

/**

Connect the {@link Channel} of the given {@link ChannelFuture} with the given remote {@link SocketAddress}.
If a specific local {@link SocketAddress} should be used it need to be given as argument. Otherwise just
pass {@code null} to it.
The {@link ChannelPromise} will get notified once the connect operation was complete.

void connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise);

/**

Disconnect the {@link Channel} of the {@link ChannelFuture} and notify the {@link ChannelPromise} once the
operation was complete.

void disconnect(ChannelPromise promise);

/**

Close the {@link Channel} of the {@link ChannelPromise} and notify the {@link ChannelPromise} once the
operation was complete.

void close(ChannelPromise promise);

/**

Closes the {@link Channel} immediately without firing any events. Probably only useful
when registration attempt failed.

void closeForcibly();

/**

Deregister the {@link Channel} of the {@link ChannelPromise} from {@link EventLoop} and notify the
{@link ChannelPromise} once the operation was complete.

void deregister(ChannelPromise promise);

/**

Schedules a read operation that fills the inbound buffer of the first {@link ChannelHandler} in the
{@link ChannelPipeline}. If there’s already a pending read operation, this method does nothing.

void beginRead();

/**

Schedules a write operation.

void write(Object msg, ChannelPromise promise);

/**

Flush out all write operations scheduled via {@link #write(Object, ChannelPromise)}.

void flush();

/**

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

笔者福利

以下是小编自己针对马上即将到来的金九银十准备的一套“面试宝典”，不管是技术还是HR的问题都有针对性的回答。

有了这个，面试踩雷？不存在的！

回馈粉丝，诚意满满！！！

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
外链图片转存中…(img-791CiyQW-1712656376085)]