ZeroMQ（java）中对IO的封装（StreamEngine）

哎，各种各样杂七杂八的事情。。。好久没有看代码了，其实要搞明白一个与IO相关的框架，最好的办法就是把它的I/0的读写两个过程搞清楚。。。例如在netty中，如果能将eventLoop的运行原理搞清楚，然后摸清楚整个I/O读写两个过程，那么也就差不太多了。。。。

这次来看看ZeroMQ（java）中如何来处理I/O的，先来看看一个类型的定义，IOObject类型，这个类型应该扮演的是工具类的形象，前面看过在ZeroMQ中所谓的IO线程的定义，那么IOObject就是用于直接与IO线程交互的，或者说的更直接的一点就是它是与IO线程里的poller对象交互的。。。

那么先来看看IOObject的类图吧：

这张图应该将IOObject与IOThread以及Poller之间的关系表现的很清楚了吧。。。。IOObject实现了IPollEvents接口，那么也就代表它可以响应IO事件。。。不过其实它并不直接实现这些IO事件，而是将其委托给内部的一个IPollEvents对象。。只不过是做了一层代理而已。。。

好了，接下来来看看IOObject的代码吧，先来看看它的属性申明：

 private Poller poller;   //poller对象
 private IPollEvents handler;   //用于执行事件回调的handler

这个poller就是从IO线程里面获取过来的，handler就是刚刚提到的事件回调的处理对象。。。IOObject不过是对其进行了一层包装而已。。。

那么接下来来看看重要的方法定义：

 //在将一个IO对象加入到一个IO线程的时候，要注意确定当前IO对象之前没有加入到任何IO线程或者已经从别的IO线程上面退下来了
 //将当前这个IO对象加入到IO线程上面去，说白了主要是获取这个IO线程的poller对象
 public void plug(IOThread io_thread_) {
     assert (io_thread_ != null);
     assert (poller == null);
     poller = io_thread_.get_poller ();      //获取这个线程的poller对象
 }

这个方法用于将当前这个IO对象加入到一个IO线程，其实主要的是要获取这个IO线程的Poller对象。。好了，接下来再来看看如何注册channel以及事件吧：

 //在poller里面移除channel
 public final void rm_fd(SelectableChannel handle) {
     poller.rm_fd(handle);
 }
 //给这个channel注册读取的事件
 public final void set_pollin (SelectableChannel handle_) {
     poller.set_pollin (handle_);
 }
 //在这个channel上面注册写事件
 public final void set_pollout (SelectableChannel handle_) {
     poller.set_pollout (handle_);
 }
 //注册链接事件
 public final void set_pollconnect(SelectableChannel handle) {
     poller.set_pollconnect(handle);
 }
 //注册accept事件
 public final void set_pollaccept(SelectableChannel handle) {
     poller.set_pollaccept(handle);
 }
 //取消读取事件的注册
 public final void reset_pollin(SelectableChannel handle) {
     poller.reset_pollin (handle);
 }

 //取消写事件的注册
 public final void reset_pollout(SelectableChannel handle) {
     poller.reset_pollout (handle);
 }

这部分代码应该很简单吧，而且应该对IOObject的用处比较的清楚了，然后至于说IOObject对象如何响应in_event什么的，前面已经说过了，其实是委托给了handler对象来处理。。。好啦，IOObject的分析就算差不多了。。接下来来看看StreamEngine类型的实现吧，还是先来看看它初略的类图吧：

其实觉得看一个类的类图，基本上就能看出这个类的很多情况，好了，不说闲话了，来看看它的属性的定义吧：

 private static final int GREETING_SIZE = 12;   //问候msg的大小，12个字节  （10字节的头，1字节的版本，1字节的socket类型）

 //  True iff we are registered with an I/O poller.
 private boolean io_enabled;   //如果是true的话，表示当前已经注册到了poller上面去

 private SocketChannel handle;   //真正底层用于通信的socketChannel

 private ByteBuffer inbuf;  //接收数据的buf
 private int insize;   //记录接收的数据的大小
 private DecoderBase decoder;  //decoder

 private Transfer outbuf;   //outbuf
 private int outsize;   //outbuf的大小
 private EncoderBase encoder;  //encoder

 //  When true, we are still trying to determine whether
 //  the peer is using versioned protocol, and if so, which
 //  version.  When false, normal message flow has started.
 private boolean handshaking;  //是否是在握手中，当值为false的时候代表握手已经完成了

 //  The receive buffer holding the greeting message
 //  that we are receiving from the peer.
 private final ByteBuffer greeting;  //用于接收问候msg的buf

 //  The send buffer holding the greeting message
 //  that we are sending to the peer.
 private final ByteBuffer greeting_output_buffer;  //用于发送问候msg的buf

 private SessionBase session;    //所属的session


 private Options options;  //选项配置

 // String representation of endpoint
 private String endpoint;   //这里一般是地址信息

 private boolean plugged;   //是否已经加入了
 private boolean terminating;  //是否已经停止了

 // Socket
 private SocketBase socket;  //所属的socket

 private IOObject io_object;    //拥有的IO对象

这里面有很多重要的属性，例如handler是SocketChannel类型的，可以知道它才是实际上底层用于通信的，然后又inbuf以及outbuf，这两个东西是干嘛用的应该一眼就看出来了吧，然后还有encoder和decoder，呵呵，可以猜到，读取到的数据先要经过decoder的处理才提交给上层，发送出去的数据也会通过encoder处理成二进制再发送出去。。。然后还有一个io_objcet对象。。。

接下来来看看构造方法吧：

 //构造函数，第一个参数是底层的channel，
 public StreamEngine (SocketChannel fd_, final Options options_, final String endpoint_)
 {
     handle = fd_;
     inbuf = null;
     insize = 0;
     io_enabled = false;
     outbuf = null;
     outsize = 0;
     handshaking = true;  //初始化为ture，表示还没有完成握手
     session = null;
     options = options_;
     plugged = false;
     terminating = false;
     endpoint = endpoint_;
     socket = null;
     greeting = ByteBuffer.allocate (GREETING_SIZE);  //创建用于接收问候msg的buf
     greeting_output_buffer = ByteBuffer.allocate (GREETING_SIZE);   //创建用于发送握手信息的buf
     encoder = null;
     decoder = null;


     try {
         Utils.unblock_socket (handle);  //将底层的channel设置为非阻塞的
         if (options.sndbuf != 0) {  //设置底层的socket的发送缓冲大小
             handle.socket().setSendBufferSize((int)options.sndbuf);
         }
         if (options.rcvbuf != 0) {  //设置底层的socket的接收缓冲大小
             handle.socket().setReceiveBufferSize((int)options.rcvbuf);
         }

     } catch (IOException e) {
         throw new ZError.IOException(e);
     }

 }

这个比较有意思的就是将channel设置为了非阻塞的模式，然后设置了底层socket的发送以及接受缓冲的大小。。其余的就没啥意思了。。。

 //将当前engine加入到IO线程以及session，其实这里最主要的事情是将channel注册到poller上面去
 public void plug (IOThread io_thread_,
         SessionBase session_)  {
     assert (!plugged);
     plugged = true;  //标志位

     //  Connect to session object.
     assert (session == null);
     assert (session_ != null);
     session = session_;    //当前所属的session
     socket = session.get_soket ();  //获取所属的scoekt，这个是ZMQ的socket

     io_object = new IOObject(null);  //创建IO对象，
     io_object.set_handler(this);  //设置IO对象的事件回调
     //  Connect to I/O threads poller object.
     io_object.plug (io_thread_);  // 将IO对象搞到这个IO线程上面去，其实最主要的就是获取这个IO线程的poller对象
     io_object.add_fd (handle);   //将底层的channel加入
     io_enabled = true; //表示已经加入了

     //  Send the 'length' and 'flags' fields of the identity message.
     //  The 'length' field is encoded in the long format.
     //设置发送的问候msg的信息
     greeting_output_buffer.put ((byte) 0xff);
     greeting_output_buffer.putLong (options.identity_size + 1);
     greeting_output_buffer.put ((byte) 0x7f);

     io_object.set_pollin (handle);  //注册当前channel的读事件
     //  When there's a raw custom encoder, we don't send 10 bytes frame
     boolean custom = false;
     try {
         custom = options.encoder != null && options.encoder.getDeclaredField ("RAW_ENCODER") != null;
     } catch (SecurityException e) {
     } catch (NoSuchFieldException e) {
     }

     if (!custom) {
         outsize = greeting_output_buffer.position ();
         outbuf = new Transfer.ByteBufferTransfer ((ByteBuffer) greeting_output_buffer.flip ());  //设置需要发送的buf，将问候信息发送出去
         io_object.set_pollout (handle);
     }

     //  Flush all the data that may have been already received downstream.
     in_event ();  //看是否有数据读取了
 }

这个方法用于将当前IO对象注册到IO线程上面去，并且还要管理session，可以看到这里主要是利用IOObject对象，用于在poller对象上面注册channel，以及读写事件。。。另外还有对握手信息的处理。。。好了，握手这部分的内容，因为现在还没有看，不知道具体的流程是啥样的，就先放一下。。。再来看两个重要的方法定义吧：

 //当底层的chanel有数据可以读取的时候的回调方法
 public void in_event ()  {
     if (handshaking)
         if (!handshake ())
             return;

     assert (decoder != null);
     boolean disconnection = false;

     //  If there's no data to process in the buffer...
     if (insize == 0) {  //如果inbuf里面没有数据需要处理

         //  Retrieve the buffer and read as much data as possible.
         //  Note that buffer can be arbitrarily large. However, we assume
         //  the underlying TCP layer has fixed buffer size and thus the
         //  number of bytes read will be always limited.
         inbuf = decoder.get_buffer ();  //从解码器里面获取buf，用于写入读取的数据，因为在已经设置了底层socket的TCP接收缓冲区的大小
         insize = read (inbuf);  //用于将发送过来的数据写到buf中去，并记录大小
         inbuf.flip();  //这里准备从buf里面读取数据了

         //  Check whether the peer has closed the connection.
         if (insize == -1) {  //如果是-1的话，表示底层的socket连接已经出现了问题
             insize = 0;
             disconnection = true;
         }
     }

     //  Push the data to the decoder.
     int processed = decoder.process_buffer (inbuf, insize);  //解析这些读取到的数据

     if (processed == -1) {
         disconnection = true;
     } else {

         //  Stop polling for input if we got stuck.
         if (processed < insize)  //如果处理的数据居然还没有读到的数据多，那么取消读取事件的注册
             io_object.reset_pollin (handle);

         //  Adjust the buffer.
         insize -= processed;  //还剩下没有处理的数据的大小
     }

     //  Flush all messages the decoder may have produced.
     session.flush ();  //将decoder解析出来的数据交给session

     //  An input error has occurred. If the last decoded message
     //  has already been accepted, we terminate the engine immediately.
     //  Otherwise, we stop waiting for socket events and postpone
     //  the termination until after the message is accepted.
     if (disconnection) {   //表示已经断开了连接，那么需要处理一下
         if (decoder.stalled ()) {
             io_object.rm_fd (handle);
             io_enabled = false;
         } else
             error ();
     }

 }

 //表示可以写数据了
 public void out_event ()   {
     //  If write buffer is empty, try to read new data from the encoder.
     if (outsize == 0) {  //需要写的数据量为0

         //  Even when we stop polling as soon as there is no
         //  data to send, the poller may invoke out_event one
         //  more time due to 'speculative write' optimisation.
         if (encoder == null) {
              assert (handshaking);
              return;
         }

         outbuf = encoder.get_data (null);  //从encoder里面获取数据
         outsize = outbuf.remaining();
         //  If there is no data to send, stop polling for output.
         if (outbuf.remaining() == 0) {   //如果确实没有数据要写，那么取消写事件的注册
             io_object.reset_pollout (handle);

             // when we use custom encoder, we might want to close
             if (encoder.is_error()) {
                 error();
             }

             return;
         }
     }

     //  If there are any data to write in write buffer, write as much as
     //  possible to the socket. Note that amount of data to write can be
     //  arbitratily large. However, we assume that underlying TCP layer has
     //  limited transmission buffer and thus the actual number of bytes
     //  written should be reasonably modest.
     int nbytes = write (outbuf);  //写数据

     //  IO error has occurred. We stop waiting for output events.
     //  The engine is not terminated until we detect input error;
     //  this is necessary to prevent losing incomming messages.
     if (nbytes == -1) {  //如果-1，那么表示底层用到的socket其实已经出现了问题
         io_object.reset_pollout (handle);  //取消写事件的注册

         if (terminating)
             terminate ();

         return;
     }

     outsize -= nbytes;  //这里更新需要写的数据的数量

     //  If we are still handshaking and there are no data
     //  to send, stop polling for output.
     if (handshaking)
         if (outsize == 0)
             io_object.reset_pollout (handle);

     // when we use custom encoder, we might want to close after sending a response
     if (outsize == 0) {
         if (encoder != null && encoder.is_error ()) {
             error();
             return;
         }
         if (terminating)
             terminate ();
     }

 }

这两个方法是用于相应IO事件的，前面提到的IOObject将IO事件其实委托给了内部的handler来处理，其实这个handler对象就是SteamEngine对象，也就是底层的channel有数据可以读写的时候，将会用上面的两个方法来处理。这里就可以看到读写事件最原始的处理流程了，而且也看到了encoder以及decoder的用处。。。这里代码应该还算是比较的简单，由于这部分还涉及到与上层的session对象之间的交互，这个还要等到以后来分析。。。

好了，那么到这里ZeroMQ中IO的处理流程也就算是有了基本的了解了。。。。