Netty学习之旅------Netty Channel 概述，2024年最新java分布式事物面试

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

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

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

*/

ChannelPipeline pipeline();

/**

• Return the assigned {@link ByteBufAllocator} which will be used to allocate {@link ByteBuf}s.

• 返回ByteBuf内存分配器

*/

ByteBufAllocator alloc();

/**

• Return a new {@link ChannelPromise}.

• 诸如newPromise,newSuccessedFuture()方法，就是返回一个凭证，用来保存通知结果的，是多线程编程一 * 中典型的设计模式

*/

ChannelPromise newPromise();

/**

• Return an new {@link ChannelProgressivePromise}

*/

ChannelProgressivePromise newProgressivePromise();

/**

• Create a new {@link ChannelFuture} which is marked as succeeded already. So {@link ChannelFuture#isSuccess()}

• will return {@code true}. All {@link FutureListener} added to it will be notified directly. Also

• every call of blocking methods will just return without blocking.

*/

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();

总结

面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。

我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。

面试题及解析总结

大厂面试场景

知识点总结

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
e(ChannelPromise promise);

/**

• Closes the {@link Channel} immediately without firing any events. Probably only useful

• when registration attempt failed.

*/

void closeForcibly();

总结

面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。

我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。

面试题及解析总结

[外链图片转存中…(img-w0qcKL6J-1713424011163)]

大厂面试场景

[外链图片转存中…(img-CWWWo0NH-1713424011163)]

知识点总结

[外链图片转存中…(img-g5E4brW8-1713424011164)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-QimisIuL-1713424011164)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！