Netty3 源码分析 - AbstractChannel

最新推荐文章于 2022-12-07 08:44:32 发布
最新推荐文章于 2022-12-07 08:44:32 发布
阅读量1.5k 收藏
点赞数
分类专栏： Netty学习 Netty3 源码分析 文章标签： AbstractChannel bind Channels
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vonzhoufz/article/details/39159193
版权
Netty3 源码分析 - AbstractChannel


AbstractChannel 是Channel的部分实现，维护了一个通道相关的资源，如channel id, pipeline等；而且实现了对该套接字的IO操作，以及设置interestOps；这里还没有牵扯到底层的细节，只是这个框架的结构。（Channels中的具体实现有待分析）

源码能说明一切：
/**
 * A skeletal Channel implementation.
 */
public   abstract  class  AbstractChannel  implements
          org.jboss.netty.channel.Channel {

       static   final  ConcurrentMap<Integer, Channel>  allChannels  =  new  ConcurrentHashMap<Integer, Channel>();

       private   static   final  Random  random  =  new  Random();

       private   static  Integer allocateId(Channel channel) {
          Integer id =  random  .nextInt();
            for  (;;) {
                // 循环直到得到一个唯一的ID.
                // It should be found in one loop practically.
                if  ( allChannels  .putIfAbsent(id, channel) ==  null  ) {
                     // Successfully acquired.
                     return  id;
              }  else  {
                     // Taken by other channel at almost the same moment.
                   id = id.intValue() + 1;
              }
          }
     }

       private   final  Integer  id  ;
       private   final  Channel  parent  ;  //
       private   final  ChannelFactory  factory  ;
       private   final  ChannelPipeline  pipeline  ;
       //
       private   final  ChannelFuture  succeededFuture  =  new  SucceededChannelFuture(
                this  );
       private   final  ChannelCloseFuture  closeFuture  =  new  ChannelCloseFuture();
       private volatile int interestOps = OP_READ;

       /** Cache for the string representation of this channel */
       private   boolean   strValConnected  ;
       private  String  strVal ;
       private   volatile  Object  attachment  ;

       /**
      * 创建实例，注意各个参数的含义，特别是ChannelSink
      *
      *  @param  parent
      *            the parent of this channel. {@code null} if there's no parent.
      *  @param  factory
      *            the factory which created this channel
      *  @param  pipeline
      *            the pipeline which is going to be attached to this channel
      *  @param  sink
      *            the sink which will receive downstream events from the
      *            pipeline and send upstream events to the pipeline
      */
       protected  AbstractChannel(Channel parent, ChannelFactory factory,
              ChannelPipeline pipeline, ChannelSink sink) {

            this  . parent  = parent;
            this  . factory  = factory;
            this  . pipeline  = pipeline;

            id  = allocateId(  this );

          pipeline.attach(  this  , sink);
     }

       // (Internal use only) Creates a new temporary instance with the specified
       // ID.
       protected  AbstractChannel(Integer id, Channel parent,
              ChannelFactory factory, ChannelPipeline pipeline, ChannelSink sink) {

            this  . id  = id;
            this  . parent  = parent;
            this  . factory  = factory;
            this  . pipeline  = pipeline;
          pipeline.attach(  this  , sink);
     }

       public   final  Integer getId() {
            return   id  ;
     }

       public  Channel getParent() {
            return   parent  ;
     }

       public  ChannelFactory getFactory() {
            return   factory  ;
     }

       public  ChannelPipeline getPipeline() {
            return   pipeline  ;
     }

       /**
      * Returns the cached SucceededChannelFuture instance.
      */
       protected  ChannelFuture getSucceededFuture() {
            return   succeededFuture  ;
     }

       /**
      * Returns the FailedChannelFuture whose cause is an
      * UnsupportedOperationException.
      */
       protected  ChannelFuture getUnsupportedOperationFuture() {
            return   new  FailedChannelFuture(  this ,
                     new  UnsupportedOperationException());
     }

       /**
      * Returns the ID of this channel.
      */
       @Override
       public   final   int  hashCode() {
            return   id  ;
     }

       // 引用相等
       @Override
       public   final   boolean  equals(Object o) {
            return   this  == o;
     }

       // 用ID来比较
       public   final   int  compareTo(Channel o) {
            return  getId().compareTo(o.getId());
     }

       public   boolean  isOpen() {
            return  ! closeFuture  .isDone();
     }

       /**
      * Marks this channel as closed. This method is intended to be called by an
      * internal component  -  please do not call it unless you know what you are
      * doing.
      *
      *  @return  {@code true} if and only if this channel was not marked as closed
      *         yet
      */
       protected   boolean  setClosed() {
            // Deallocate the current channel's ID from allChannels so that other
            // new channels can use it.
            allChannels  .remove( id  );

            return   closeFuture  .setClosed();
     }

       // 下面都是调用辅助函数来完成套接字的基本操作逻辑
       public  ChannelFuture bind(SocketAddress localAddress) {
            return  Channels.bind(  this  , localAddress);
     }

       public  ChannelFuture unbind() {
            return  Channels.unbind(  this  );
     }

       public  ChannelFuture close() {
          ChannelFuture returnedCloseFuture = Channels.close(  this );
            assert   closeFuture  == returnedCloseFuture;
            return   closeFuture  ;
     }

       public  ChannelFuture getCloseFuture() {
            return   closeFuture  ;
     }

       public  ChannelFuture connect(SocketAddress remoteAddress) {
            return  Channels.connect(  this  , remoteAddress);
     }

       public  ChannelFuture disconnect() {
            return  Channels.disconnect(  this  );
     }

       public   int  getInterestOps() {
            return   interestOps  ;
     }

       public  ChannelFuture setInterestOps(  int  interestOps) {
            return  Channels.setInterestOps(  this  , interestOps);
     }

       /**
      * Sets the interestOps property of this channel immediately. This method is
      * intended to be called by an internal component  -  please do not call it
      * unless you know what you are doing. 直接改变的成员变量，而不是通过发送请求码到最后一个handler
      */
       protected   void  setInterestOpsNow(  int  interestOps) {
            this  . interestOps  = interestOps;
     }

       public   boolean  isReadable() {
            return  (getInterestOps() &  OP_READ ) != 0;
     }

       public   boolean  isWritable() {
            return  (getInterestOps() &  OP_WRITE ) == 0;
     }

       public  ChannelFuture setReadable(  boolean  readable) {
            if  (readable) {
                return  setInterestOps(getInterestOps() |  OP_READ  );
          }  else  {
                return  setInterestOps(getInterestOps() & ~ OP_READ  );
          }
     }

       public  ChannelFuture write(Object message) {
            return  Channels.write(  this  , message);
     }

       public  ChannelFuture write(Object message, SocketAddress remoteAddress) {
            return  Channels.write(  this  , message, remoteAddress);
     }

       public  Object getAttachment() {
            return   attachment  ;
     }

       public   void  setAttachment(Object attachment) {
            this  . attachment  = attachment;
     }

       /**
      * Returns the String representation of this channel. The returned string
      * contains the ID, local address, and remote address of this channel for
      * easier identification.
      */
       @Override
       public  String toString() {
            boolean  connected = isConnected();
            if  ( strValConnected  == connected &&  strVal  !=  null  ) {
                return   strVal  ;
          }

          StringBuilder buf =  new  StringBuilder(128);
          buf.append(  "[id: 0x"  );
          buf.append(getIdString());

          SocketAddress localAddress = getLocalAddress();
          SocketAddress remoteAddress = getRemoteAddress();
            if  (remoteAddress !=  null ) {
              buf.append(  ", "  );
                if  (getParent() ==  null ) {
                   buf.append(localAddress);
                   buf.append(connected ?  " => "  :  " :> " );
                   buf.append(remoteAddress);
              }  else  {
                   buf.append(remoteAddress);
                   buf.append(connected ?  " => "  :  " :> " );
                   buf.append(localAddress);
              }
          }  else   if  (localAddress !=  null ) {
              buf.append(  ", "  );
              buf.append(localAddress);
          }

          buf.append(  ']' );

          String strVal = buf.toString();
            this  . strVal  = strVal;
            strValConnected  = connected;
            return  strVal;
     }

       private  String getIdString() {
          String answer = Integer.toHexString(  id .intValue());
            switch  (answer.length()) {
            case  0:
              answer =  "00000000"  ;
                break  ;
            case  1:
              answer =  "0000000"  + answer;
                break  ;
            case  2:
              answer =  "000000"  + answer;
                break  ;
            case  3:
              answer =  "00000"  + answer;
                break  ;
            case  4:
              answer =  "0000"  + answer;
                break  ;
            case  5:
              answer =  "000"  + answer;
                break  ;
            case  6:
              answer =  "00"  + answer;
                break  ;
            case  7:
              answer =  '0'  + answer;
                break  ;
          }
            return  answer;
     }

       private   final   class  ChannelCloseFuture  extends  DefaultChannelFuture {

            public  ChannelCloseFuture() {
                super  (AbstractChannel.  this ,  false );
          }

            @Override
            public   boolean  setSuccess() {
                // User is not supposed to call this method - ignore silently.
                return   false  ;
          }

            @Override
            public   boolean  setFailure(Throwable cause) {
                // User is not supposed to call this method - ignore silently.
                return   false  ;
          }

            boolean  setClosed() {
                return   super  .setSuccess();
          }
     }
}
vonzhou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty3 源码分析 - NIO server接受连接请求过程分析
博观约取
09-19 2579
Netty3 源码分析 - NIO server接受连接请求过程分析      当服务器端的server Channel绑定某个端口之后，就可以处理来自客户端的连接请求，而且在构建 NioServerSocketChannelFactory 的时候已经生成了对应的 BossPool 和 WorkerPool，前者管理的 NioServerBoss 就是专门用来接受客户端连接的Sele
Netty---AbstractChannel
阿七
07-03 665
一，概述 Netty不直接使用java NIO的channel组件，而是封装了，支持多种通信协议，比如tcp,udp,sctp。而且它还把channel分为了nio非阻塞的，和olo(bio)阻塞的两种。 netty为什么不使用nio的channel呢？ 1.由于jdk的socketChannel和ServerSocketChannel主要职责是网络I/O操作，他们是SPI类接口，具体的实现由厂家自己来，难度很大，直接实现这两个的抽象类难度与实现spi接口工作量差...
java netty之AbstractNioChannel
fjs的专栏
06-24 2341
前面的文章分析了eventloopgroup以及eventloop的继承体系，在这篇文章主要分析以下netty对channel的封装，我只对nio感兴趣，那么就只分析对nio这一部分的封装。。。。 主要来分析以下的继承体系： channel是netty定义的顶层接口，其无非就是定义了一些基本的方法，例如返回当前channel所属的eventloop，判断channel是否已经打开，
05-Channel实现之AbstractChannel
my_momo_csdn的博客
10-25 891
文章目录Channel实现之AbstractChannel一、关键属性二、构造方法三、其他方法3.1 属性读取方法3.2 IO操作方法3.3 protected方法3.4 其他方法四、AbstractUnsafe4.1 AbstractUnsafe实现Unsafe4.2 AbstractUnsafe方法五、小结 Channel实现之AbstractChannel AbstractChannel是...
Netty（四）:AbstractChannel源码解析
weixin_33682790的博客
10-27 507
首先我们通过一张继承关系的图来认识下AbstractChannel在Netty中的位置。 除了Comaprable接口来自java自带的包，其他都是Netty包中提供的。 Comparable接口定义了Channel是可以比较的。 AttributeMap接口为Channel提供了绑定其他属性的能力。 这两个接口我们先不去深入了解，主要看ChannelOutboundInvoker。 ...
transport-netty3-client-5.5.1-API文档-中文版.zip
05-02
赠送jar包：transport-netty3-client-5.5.1.jar； 赠送原API文档：transport-netty3-client-5.5.1-javadoc.jar； 赠送源代码：transport-netty3-client-5.5.1-sources.jar； 赠送Maven依赖信息文件：transport-netty...
transport-netty3-client-5.5.1-API文档-中英对照版.zip
04-22
赠送jar包：transport-netty3-client-5.5.1.jar； 赠送原API文档：transport-netty3-client-5.5.1-javadoc.jar； 赠送源代码：transport-netty3-client-5.5.1-sources.jar； 赠送Maven依赖信息文件：transport-netty...
Netty源码教程-3
10-31
在本节"Netty源码教程-3"中，我们将深入探讨Netty这一高性能、异步事件驱动的网络应用程序框架。Netty广泛应用于各种分布式系统、服务器和客户端应用，尤其在处理高并发、低延迟的网络通信场景下，其优势尤为突出。...
Netty之源码下载-附件资源
03-02
Netty之源码下载-附件资源
reactor-netty-core-1.0.15-API文档-中文版.zip
05-09
赠送jar包：reactor-netty-core-1.0.15.jar； 赠送原API文档：reactor-netty-core-1.0.15-javadoc.jar； 赠送源代码：reactor-netty-core-1.0.15-sources.jar； 赠送Maven依赖信息文件：reactor-netty-core-1.0.15....
Netty 源码分析03 Channel 实现 AbstractChannel
郭传志的博客
09-30 366
注册方法 1.调用doRegister()方法进行注册，如果是NIO实现，如下 2.通过调用底层jdk的nio方法进行注册，本质上为放到channelArray this.channelArray[this.totalChannels] = var1; 3.注册后返回selectionKey，然后调用 pipeline.fireChannelRegistered(); 4....
Netty源码愫读（二）Channel相关源码学习
yuanwei1144的博客
11-20 483
io.netty.channel.Channel是Netty网络操作抽象类，它聚合了一组功能，包括但不限于网路的读，写，客户端发起连接，主动关闭连接，链路关闭，获取通信双方的网络地址等。它也包含了Netty框架相关的一些功能，包括获取该Channel的EventLoop，获取缓冲分配器ByteBufAllocator和pipeline等。 Unsafe是个内部接口，聚合在Chann...
Netty:ChannelPipeline
bdmh的专栏
11-24 4399
ChannelPipeline的作用以及如何维护handler
【Netty专题】Netty源码剖析_Channel通道
Coinker的博客
04-11 1714
首先我们来思考一个问题，什么是Channel？ Channel是Netty抽象出来的对网络I/O进行读/写的相关接口，与NIO中的Channel接口类似。 那么Channel有哪些主要功能？ 网络I/O的读/写 客户端发起连接 主动关闭连接、关闭链路 获取通信双方的地址 说明： Netty支持除了TCP以外的多种协议。不同协议、不同阻塞类型的连接会有所不同的Channel类型与之对应。 下面我们来看一下常见的几种Channel： 1. AbstractChannel 首先他有几个主要属性：
[netty核心类]--Channel和Unsafe类
惜暮
02-18 4097
主要内容： （1）Channel 功能说明 （2）Unsafe 功能说明 （3）Channel的主要实现子类源码分析 （4）Unsafe主要实现子类源码分析 1.Channel功能说明channel是netty网络IO操作抽象出来的一个接口，主要功能有：网络IO的读写，客户端发起连接、主动关闭连接，链路关闭，获取通信双方的网络地址等。下面分类进行介绍：网络IO操作 （1）C
Caused by: io.netty.channel.AbstractChannel$AnnotatedConnectException: Connection refused: no furthe
热门推荐
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
10-30 13万+
如下异常：   原因分析： 基本上是你的服务没起来 1.ping 通 2.启动服务    
netty5笔记-总体流程分析3-ChannelHandlerContext
youaremoon的专栏
01-02 1万+
上面一篇文章介绍了ChannelPipeline，它维护了一个有序的ChannelHandler列表，但并非是直接关联，而是通过维护ChannelHandlerContext进行关联。ChannelPipeline的每一个节点都是一个ChannelHandlerContext实例，不存在线程安全问题，而对应的ChannelHandler如果未标记Sharable也是新建的实例，也不存在线程安全问题
什么？MC服务器又遇到了io???!!!（io.netty.channel.AbstractChannel问题分析与解决）
最新发布
Dty903的博客
12-07 1万+
当我正在期待地打开我自己搭建的MC服务器时一点~！！！几十秒钟的等待后，出现了IO!当然这里并不是IO接口，而是我对他的简称:io.netty.channel.AbstractChannel$AnnotatedConnectException:Connection timed out:no further information这种错误我一看，我心都凉了。
netty源码分析(十四)Netty初始化流程总结及Channel与ChannelHandlerContext作用域分析
wzq6578702的专栏
10-29 1万+
我们回到ServerBootstrap的init方法，之前介绍过Attribute的设置，那么Attribute的具体设置是怎样的呢： void init(Channel channel) throws Exception { final Map<ChannelOption<?>, Object> options = options0(); synchroniz
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值