Netty Channel 接口名词理解

1.Channel 
channel 是负责数据读，写的对象，有点类似于老的io里面的stream。它和stream的区别，channel是双向的，既可以write 也可以read，而stream要分outstream和inputstream。而且在NIO中用户不应该直接从channel中读写数据，而是应该通过buffer，通过buffer再将数据读写到channel中。 
一个channel 可以提供给用户下面几个信息 
(1)channel的当前状态，比如open 还是closed 
(2)ChannelConfig对象，表示channel的一些参数，比如bufferSize

(3)channel支持的所有i/o操作（比如read,write,connect.bind）以及ChannelPipeLine（下面解释）

2.ChannelConfig 
channel的参数，以Map 数据结构来存储

3.ChannelEvent 
ChannelEvent广义的认为Channel相关的事件，它是否分Upstream events和downstream events两大块，这里需要注意的，若是以server为主体的话，从client的数据到server的过程是Upstream；而server到client的数据传输过程叫downstream；而如果以client为主体的话，从server到client的过程对client来说是Upstream，而client到server的过程对client来说就是downstream。 
Upstream events包括： 
messageReceived：信息被接受时 ---MessageEvent 
exceptionCaught：产生异常时 ---ExceptionEvent 
channelOpen：channel被开启时 ---ChannelStateEvent 
channelClosed：channel被关闭时 ---ChannelStateEvent 
channelBound：channel被开启并准备去连接但还未连接上的时候 ---ChannelStateEvent 
channelUnbound：channel被开启不准备去连接时候 ---ChannelStateEvent 
channelConnected：channel被连接上的时候 ---ChannelStateEvent 
channelDisconnected:channel连接断开的时候 ---ChannelStateEvent 
channelInterestChanged:Channel的interestOps被改变的时候 ------ChannelStateEvent 
writeComplete:写到远程端完成的时候 --WriteCompletionEvent

Downstream events包括： 
write：发送信息给channel的时候 --MessageEvent 
bind：绑定一个channel到指定的本地地址 --ChannelStateEvent 
unbind：解除当前本地端口的绑定--ChannelStateEvent 
connect：将channel连接到远程的机 --ChannelStateEvent 
disconnect：将channel与远程的机连接断开 --ChannelStateEvent 
close：关闭channel --ChannelStateEvent

需要注意的是，这里没有open event，这是因为当一个channel被channelFactory创建的话，channel总是已经被打开了。

此外还有两个事件类型是当父channel存在子channel的情况 
childChannelOpen：子channel被打开 ---ChannelStateEvent 
childChannelClosed：子channel被关闭 ---ChannelStateEvent

4.ChannelHandler 
channel是负责传送数据的载体，那么数据肯定需要根据要求进行加工处理，那么这个时候就用到ChannelHandler
不同的加工可以构建不同的ChannelHandler，然后放入ChannelPipeline中 
此外需要有ChannelEvent触发后才能到达ChannelHandler，因此根据event不同有下面两种的sub接口ChannelUpstreamHandler 
和ChannelDownstreamHandler。 
一个ChannelHandler通常需要存储一些状态信息作为判断信息，常用做法定义一个变量 
比如

public class DataServerHandler extends {@link SimpleChannelHandler} { 
* 
* <b>private boolean loggedIn;</b> 
* 
* {@code @Override} 
* public void messageReceived({@link ChannelHandlerContext} ctx, {@link MessageEvent} e) { 
* {@link Channel} ch = e.getChannel(); 
* Object o = e.getMessage(); 
* if (o instanceof LoginMessage) { 
* authenticate((LoginMessage) o); 
* <b>loggedIn = true;</b> 
* } else (o instanceof GetDataMessage) { 
* if (<b>loggedIn</b>) { 
* ch.write(fetchSecret((GetDataMessage) o)); 
* } else { 
* fail(); 
* } 
* } 
* } 
* ... 
* }

// Create a new handler instance per channel. 
* // See {@link Bootstrap#setPipelineFactory(ChannelPipelineFactory)}. 
* public class DataServerPipelineFactory implements {@link ChannelPipelineFactory} { 
* public {@link ChannelPipeline} getPipeline() { 
* return {@link Channels}.pipeline(<b>new DataServerHandler()</b>); 
* } 
* }

除了这种，每个ChannelHandler都可以从ChannelHandlerContext中获取或设置数据，那么下面的做法就是利用ChannelHandlerContext 
设置变量

* {@code @Sharable} 
* public class DataServerHandler extends {@link SimpleChannelHandler} { 
* 
* {@code @Override} 
* public void messageReceived({@link ChannelHandlerContext} ctx, {@link MessageEvent} e) { 
* {@link Channel} ch = e.getChannel(); 
* Object o = e.getMessage(); 
* if (o instanceof LoginMessage) { 
* authenticate((LoginMessage) o); 
* <b>ctx.setAttachment(true)</b>; 
* } else (o instanceof GetDataMessage) { 
* if (<b>Boolean.TRUE.equals(ctx.getAttachment())</b>) { 
* ch.write(fetchSecret((GetDataMessage) o)); 
* } else { 
* fail(); 
* } 
* } 
* } 
* ... 
* }

* public class DataServerPipelineFactory implements {@link ChannelPipelineFactory} { 
* 
* private static final DataServerHandler <b>SHARED</b> = new DataServerHandler(); 
* 
* public {@link ChannelPipeline} getPipeline() { 
* return {@link Channels}.pipeline(<b>SHARED</b>); 
* } 
* } 
这两种做法还是有区别的，上面的变量做法,每个new的handler 对象，变量是不共享的，而下面的ChannelHandlerContext是共享的

如果需要不同的handler之间共享数据，那怎么办，那就用ChannelLocal 
例子： 
public final class DataServerState { 
* 
* <b>public static final {@link ChannelLocal}&lt;Boolean&gt; loggedIn = new {@link ChannelLocal}&lt;Boolean&gt;() { 
* protected Boolean initialValue(Channel channel) { 
* return false; 
* } 
* }</b> 
* ... 
* } 
* 
* {@code @Sharable} 
* public class DataServerHandler extends {@link SimpleChannelHandler} { 
* 
* {@code @Override} 
* public void messageReceived({@link ChannelHandlerContext} ctx, {@link MessageEvent} e) { 
* Channel ch = e.getChannel(); 
* Object o = e.getMessage(); 
* if (o instanceof LoginMessage) { 
* authenticate((LoginMessage) o); 
* <b>DataServerState.loggedIn.set(ch, true);</b> 
* } else (o instanceof GetDataMessage) { 
* if (<b>DataServerState.loggedIn.get(ch)</b>) { 
* ctx.getChannel().write(fetchSecret((GetDataMessage) o)); 
* } else { 
* fail(); 
* } 
* } 
* } 
* ... 
* } 
* 
* // Print the remote addresses of the authenticated clients: 
* {@link ChannelGroup} allClientChannels = ...; 
* for ({@link Channel} ch: allClientChannels) { 
* if (<b>DataServerState.loggedIn.get(ch)</b>) { 
* System.out.println(ch.getRemoteAddress()); 
* } 
* } 
* </pre>

5.ChannelPipeline 
channelPipeline是一系列channelHandler的集合，他参照J2ee中的Intercepting Filter模式来实现的，让用户完全掌握如果在一个handler中处理事件，同时让pipeline里面的多个handler可以相互交互。

Intercepting Filter：http://java.sun.com/blueprints/corej2eepatterns/Patterns/InterceptingFilter.html 对于每一个channel都需要有相应的channelPipeline,当为channel设置了channelPipeline后就不能再为channel重新设置channelPipeline。此外建议的做法的通过Channels 这个帮助类来生成ChannelPipeline 而不是自己去构建ChannelPipeline

通常pipeLine 添加多个handler，是基于业务逻辑的

比如下面 
{@link ChannelPipeline} p = {@link Channels}.pipeline(); 
* p.addLast("1", new UpstreamHandlerA()); 
* p.addLast("2", new UpstreamHandlerB()); 
* p.addLast("3", new DownstreamHandlerA()); 
* p.addLast("4", new DownstreamHandlerB()); 
* p.addLast("5", new SimpleChannelHandler()); 
upstream event 执行的handler按顺序应该是 125 
downstream event 执行的handler按顺序应该是 543 
SimpleChannelHandler 是同时实现了 ChannelUpstreamHandler和ChannelDownstreamHandler的类 
上面只是具有逻辑，如果数据需要通过格式来进行编码的话，那需要这些写 
* {@link ChannelPipeline} pipeline = {@link Channels#pipeline() Channels.pipeline()}; 
* pipeline.addLast("decoder", new MyProtocolDecoder()); 
* pipeline.addLast("encoder", new MyProtocolEncoder()); 
* pipeline.addLast("executor", new {@link ExecutionHandler}(new {@link OrderedMemoryAwareThreadPoolExecutor}(16, 1048576, 1048576))); 
* pipeline.addLast("handler", new MyBusinessLogicHandler()); 
其中： 
Protocol Decoder - 将binary转换为java对象 
Protocol Encoder - 将java对象转换为binary 
ExecutionHandler - applies a thread model. 
Business Logic Handler - performs the actual business logic(e.g. database access) 
虽然不能为channel重新设置channelPipeline，但是channelPipeline本身是thread-safe，因此你可以在任何时候为channelPipeline添加删除channelHandler

需要注意的是,下面的代码写法不能达到预期的效果 
* public class FirstHandler extends {@link SimpleChannelUpstreamHandler} { 
* 
* {@code @Override} 
* public void messageReceived({@link ChannelHandlerContext} ctx, {@link MessageEvent} e) { 
* // Remove this handler from the pipeline, 
* ctx.getPipeline().remove(this); 
* // And let SecondHandler handle the current event. 
* ctx.getPipeline().addLast("2nd", new SecondHandler()); 
* ctx.sendUpstream(e); 
* } 
* } 
前提现在Pipeline只有最后一个FirstHandler， 
上面明显是想把FirstHandler从Pipeline中移除，然后添加SecondHandler。而pipeline需要有一个Handler,因此如果想到到达这个效果，那么可以 
先添加SecondHandler，然后在移除FirstHandler。

6.ChannelFactory 
channel的工厂类，也就是用来生成channel的类，ChannelFactory根据指定的通信和网络来生成相应的channel，比如 
NioServerSocketChannelFactory生成的channel是基于NIO server socket的。 
当一个channel创建后，ChannelPipeline将作为参数附属给该channel。 
对于channelFactory的关闭，需要做两步操作 
第一，关闭所有该factory产生的channel包括子channel。通常调用ChannelGroup#close()。 
第二，释放channelFactory的资源，调用releaseExternalResources()

7.ChannelGroup 
channel的组集合，他包含一个或多个open的channel，closed channel会自动从group中移除，一个channel可以在一个或者多个channelGroup 
如果想将一个消息广播给多个channel，可以利用group来实现 
比如： 
{@link ChannelGroup} recipients = new {@link DefaultChannelGroup}() 
recipients.add(channelA); 
recipients.add(channelB); 
recipients.write(ChannelBuffers.copiedBuffer("Service will shut down for maintenance in 5 minutes.",CharsetUtil.UTF_8));

当ServerChannel和非ServerChannel同时都在channelGroup中的时候，任何io请求的操作都是先在ServerChannel中执行再在其他Channel中执行。 
这个规则对关闭一个server非常适用。

8.ChannelFuture 
在netty中，所有的io传输都是异步，所有那么在传送的时候需要数据+状态来确定是否全部传送成功，而这个载体就是ChannelFuture。

9.ChannelGroupFuture 
针对一次ChannelGroup异步操作的结果，他和ChannelFuture一样，包括数据和状态。不同的是他由channelGroup里面channel的所有channelFuture 组成。

10.ChannelGroupFutureListener 
针对ChannelGroupFuture的监听器，同样建议使用ChannelGroupFutureListener而不是await();

11.ChannelFutureListener 
ChannelFuture监听器，监听channelFuture的结果。

12.ChannelFutureProgressListener 
监听ChannelFuture处理过程，比如一个大文件的传送。而ChannelFutureListener只监听ChannelFuture完成未完成

13.ChannelHandlerContext 
如何让handler和他的pipeLine以及pipeLine中的其他handler交换，那么就要用到ChannelHandlerContext，ChannelHandler可以通过ChannelHandlerContext的sendXXXstream(ChannelEvent)将event传给最近的handler ，可以通过ChannelHandlerContext的getPipeline来得到Pipeline，并修改他，ChannelHandlerContext还可以存放一下状态信息attments。 
一个ChannelHandler实例可以有一个或者多个ChannelHandlerContext

14.ChannelPipelineFactory 
产生ChannelPipe的工厂类

15.ChannelState 
记载channel状态常量

时间： 2024-08-11 05:35:55

Netty Channel 接口名词理解的相关文章

接口的理解

这个是自己的理解,因为我也是刚开始编程的菜鸟,所以会有很多错误,欢迎大家指导! 首先按我的理解来说一个例子(这个例子被很多人提过,下面的这个是按我自己的理解来说的): 小王是一个苦逼(酷毙)程序员,他要开发一个程序,其中要实现一个功能:连接到一个数据库,要对数据库进行一些操作.实现功能首先需要有一个数据库,在开发的时候他使用的A厂家的数据库.假设A厂家提供的类库中实现小王需要的功能的类是DataA,小王创建一个DataA实例,然后调用DataA类中的方法.假设DataA类连接数据库的方法为Con

关于Java中继承和接口的理解

关于Java中继承和接口的理解 Java语言中,为了实现代码重用,设计了继承这一机制,但是,其设计成单继承,这样设计是有原因的,如下图: Figure1:deadly diamond of death 此图问题称为菱形问题(diamond problem),就是说,当A的子类B和C同时实现了A中的方法,则同时继承了B和C的子类D在调用该方法时会出现混乱,无法得知该调用哪一个方法. 既然不能实现多继承,我们就会考虑把很多方法就写在父类里,或者继承抽象类,实现其方法,但是,这样会导致一个问题,比如说

【转】C#中对IDisposable接口的理解

IDisposable接口定义:定义一种释放分配的资源的方法. .NET 平台在内存管理方面提供了GC(Garbage Collection),负责自动释放托管资源和内存回收的工作,但它无法对非托管资源进行释放,这时我们必须自己提供方法来释放对象内分配的非托管资源,比如你在对象的实现代码中使用了一个COM对象 最简单的办法可以通过实现Finalize()来释放非托管资源,因为GC在释放对象时会检查该对象是否实现了 Finalize() 方法. 有一种更好的,那就是通过实现一个接口显式的提供给客户

C#中对IDisposable接口的理解

http://blog.sina.com.cn/s/blog_8abeac5b01019u19.html 本人最近接触一个项目,在这个项目里面看到很多类实现了IDisposable接口.在我以前的项目中都很少用过这个接口,只知道它是用来手动释放资源的.这么多地方用应该有它的好处,为此自己想对它有进一步的了解,但这个过程远没有我想象中的简单. IDisposable接口定义:定义一种释放分配的资源的方法. .NET 平台在内存管理方面提供了GC(Garbage Collection),负责自动释放

tair中对get/get_range接口的理解及为get_range添加命令行测试接口

经过这段时间对淘宝开源K/V缓存系统tair基础接口put/get/get_range等源码的详细剖析后,按自己的理解简单总结下tair中我较关心的get和get_range这两个接口的基本实现流程.由于get_range接口是最新几个版本才加入的功能,因此以前的tair Java客户端及最新版本安装后的命令行测试中都没有加入get_range测试接口,这无疑给需要专门优化get_range接口的我带来了不便,因此本文最后给出了在tair中实现get_range命令行测试的方法和示例. 1 ta

netty报错：io.netty.channel.ChannelPipelineException

1.九月 23, 2018 8:35:02 下午 io.netty.channel.ChannelInitializer channelRegistered警告: Failed to initialize a channel. Closing: [id: 0xa09c718b, /127.0.0.1:50509 => /127.0.0.1:9999]io.netty.channel.ChannelPipelineException: com.sxt.netty.first.Server4Hell

netty io.netty.channel 简介1

Interface AddressedEnvelope<M,A extends SocketAddress> 此接口将一个消息.发送地址和接收地址封装到了一起 Interface Channel 此接口表示到网络socket或者组件(component)的一个连接,其提供了IO操作的一些功能,比如read, write, connect, and bind.一个channel可以给用户提供如下功能:1.当前channel的状态(open.connected等).2.channel的配置参数(如

netty io.netty.channel介绍2

Interface ChannelHandlerContext 上下文对象使得当前channelhandler可以与其所属的channelpipeline以及其他handler进行交互,可以通知所属channelpipeline中的下一个handler,也可动态修改其所属的channelpipeline,具体功能如下: 通知.通过调用channelhandlercontext提供的方法可以调用同一个channelpipeline中的相邻的下一个channelhandler,详情可以参照chann

Netty:Channel

Channel是客户端和服务端得以传输信息的通道,它维护这套接字或者可进行IO操作的组件. 下面我们以客户端及NioSocketChannel为例,看看他是怎么和socket发生联系的. 当客户端初始化时,首先要进行这样的操作 Bootstrap b = new Bootstrap(); ...... b.channel(NioSocketChannel.class).option(ChannelOption.TCP_NODELAY, true); 通过channel方法去创建通道,流程如下: