xSocket multiplexed介绍

关注

转载最新推荐文章于 2026-02-13 13:00:13 发布 1.2k 阅读 AI 写同款· GEO 优化 ›

xsocket源码和socket源码，文档 socket，xscoket技术详解，包括两个实例，服务端客户端相互收发信息，建立监听，建立连接等立即下载

xSocket是一个轻量级的基于nio的服务器框架用于开发高性能、可扩展、多线程的服务器。该框架封装了线程处理、异步读/写等方面。

相关socket介绍请看
xsocket documentation

xsocket Multiplexed是xSocket的一个扩展模块，xsocket Multiplexed的定义是支持一个物理TCP连接之上运行的多个逻辑连接。
说白了其实就是长连接的利用，所谓长连接就是Client方与Server方先建立通讯连接，连接建立后不断开，然后再进行报文发送和接收。对于点对点的通讯，比较适合。使用xsocket Multiplexed进行持久连接通讯，对业务开发更加友好。

下面是一个同步客户端的例子：

     Java代码 
     
    
   
 // 建立一个客户端的 multiplexed connection，   
 //这个连接里面套了一个NonBlockingConnection，后面所有的逻辑连接都通过这个连接传输数据   
 INonBlockingConnection nativeCon = NonBlockingConnection(hostname, 9011);    
 IMultiplexedConnection multiplexedCon = new MultiplexedConnection(nativeCon);     
  // 建立一个逻辑连接 pipeline，然后所做的事情就是，向服务端写了一个header，默认实现是写了18个字节。   
 //VERSION byte(1) ;  PIPELINE_OPENED byte(1) ; UUID(16)   
  //服务端收到header后就会调用注册handler的onPipelineOpend方法    
 String controlPipelineId = multiplexedCon.createPipeline();    
 IBlockingPipeline controlPipeline = multiplexedCon.getBlockingPipeline(controlPipelineId);   
   
   
 // 在发送数据时，会再向服务端写一个header    
 //VERSION byte(1) ;  PIPELINE_DATA byte(1) ; UUID(16)    
 //告诉服务端，我要写正文了，服务端会调用注册handler的onPipelineData方法，开始准备接收数据处理业务逻辑    
 //在处理过程中建立新的逻辑连接进行处理，多个逻辑连接之间不会有影响    
   
 controlPipeline.write("NEW_MESSAGE_PIPELINE\r\n");    
 String messagePipelineId = commandPipeline.readStringByDelimiter("\r\n");    
 IBlockingPipeline messagePipeline = multiplexedCon.getBlockingPipeline(messagePipelineId);   
 messagePipeline.write(messsagepart_1);    
 messagePipeline.write(messsagepart_2); ...     
 controlPipeline.write("CLOSE_MESSAGE_PIPELINE" + messagePipelineId + "\r\n");    
   
 //最后关闭业务连接，向服务端发送一个header    
 //VERSION byte(1) ;  PIPELINE_CLOSED byte(1) ; UUID(16)   
 //服务端收到后就会调用注册handler的onPipelineClosed方法进行后续清理   
 //这个关闭仅仅是逻辑链接的关闭，并非主连接的关闭。   
 messagePipeline.close();   

[java]view plaincopy 
    
 // 建立一个客户端的 multiplexed connection，  
 //这个连接里面套了一个NonBlockingConnection，后面所有的逻辑连接都通过这个连接传输数据  
 INonBlockingConnection nativeCon = NonBlockingConnection(hostname, 9011);   
 IMultiplexedConnection multiplexedCon = new MultiplexedConnection(nativeCon);    
  // 建立一个逻辑连接 pipeline，然后所做的事情就是，向服务端写了一个header，默认实现是写了18个字节。   
 //VERSION byte(1) ;  PIPELINE_OPENED byte(1) ; UUID(16)  
  //服务端收到header后就会调用注册handler的onPipelineOpend方法   
 String controlPipelineId = multiplexedCon.createPipeline();   
 IBlockingPipeline controlPipeline = multiplexedCon.getBlockingPipeline(controlPipelineId);  
   
   
 // 在发送数据时，会再向服务端写一个header   
 //VERSION byte(1) ;  PIPELINE_DATA byte(1) ; UUID(16)   
 //告诉服务端，我要写正文了，服务端会调用注册handler的onPipelineData方法，开始准备接收数据处理业务逻辑   
 //在处理过程中建立新的逻辑连接进行处理，多个逻辑连接之间不会有影响   
   
 controlPipeline.write("NEW_MESSAGE_PIPELINE\r\n");   
 String messagePipelineId = commandPipeline.readStringByDelimiter("\r\n");   
 IBlockingPipeline messagePipeline = multiplexedCon.getBlockingPipeline(messagePipelineId);  
 messagePipeline.write(messsagepart_1);   
 messagePipeline.write(messsagepart_2); ...    
 controlPipeline.write("CLOSE_MESSAGE_PIPELINE" + messagePipelineId + "\r\n");   
   
 //最后关闭业务连接，向服务端发送一个header   
 //VERSION byte(1) ;  PIPELINE_CLOSED byte(1) ; UUID(16)  
 //服务端收到后就会调用注册handler的onPipelineClosed方法进行后续清理  
 //这个关闭仅仅是逻辑链接的关闭，并非主连接的关闭。  
 messagePipeline.close();   

服务端的处理

对于一个新的IMultiplexedConnection服务端会调度到线程池执行，而对于IMultiplexedConnection的逻辑链接默认是在IMultiplexedConnection所在的线程中执行的，你也可以将逻辑链接中的业务处理自行调度到线程池中去执行。

     Java代码 
     
    
   
 IServer server = new Server(9011, new MultiplexedProtocolAdapter(new CommandPipelineHandler()));   
 ConnectionUtils.start(server);   
     
     
 // pipeline data handler which is assigned to each new pipeline   
 class CommandPipelineHandler implements IPipelineDataHandler {   
     
     public boolean onData(INonBlockingPipeline pipeline) throws IOException {   
         String cmd = pipeline.readStringByDelimiter("\r\n")   
     
         if (cmd.equals("NEW_MESSAGE_PIPELINE")) {   
             IMultiplexedConnection mplCon = pipeline.getMultiplexedConnection();   
     
             //这里定义了一个新的逻辑连接，并不和其他逻辑连接冲突   
             String msgPipelineId = mplCon.createPipeline();   
             INonBlockingPipeline msgPipeline = mplCon.getNonBlockingPipeline(msgPipelineId);   
     
             // replace the CommandPipelineHandler of the new pipeline   
             // 为新的逻辑连接指派一个handler，   
             // 和当前handler在一个线程中，即使设定@Execution(Execution.MULTITHREADED) 也是没用的   
             msgPipeline.setHandler(new DataHandler());   
             pipeline.write(msgPipelineId + "\r\n");   
   
             //耗时业务处理可以自行进行线程池调度，比如   
             pipeline.getWorkerpool().execute(task..);   
     
                
     
         } ...   
         ...   
     }   
 }   
     
 // A pipeline handler could also be a ordinary handler like IDataHandler   
 class DataHandler implements IDataHandler {   
     
     private FileChannel fc = null;   
     
     DataHandler() {   
         File file = ...   
         fc = new RandomAccessFile(file, "rw").getChannel();   
         ...   
     }   
     
     
     public boolean onData(INonBlockingConnection pipeline) throws IOException {   
         pipeline.transferTo(fc, pipeline.available());   
         ...   
         return true;   
     }   
 }  

[java]view plaincopy 
    
 IServer server = new Server(9011, new MultiplexedProtocolAdapter(new CommandPipelineHandler()));  
 ConnectionUtils.start(server);  
    
    
 // pipeline data handler which is assigned to each new pipeline  
 class CommandPipelineHandler implements IPipelineDataHandler {  
    
     public boolean onData(INonBlockingPipeline pipeline) throws IOException {  
         String cmd = pipeline.readStringByDelimiter("\r\n")  
    
         if (cmd.equals("NEW_MESSAGE_PIPELINE")) {  
             IMultiplexedConnection mplCon = pipeline.getMultiplexedConnection();  
    
             //这里定义了一个新的逻辑连接，并不和其他逻辑连接冲突  
             String msgPipelineId = mplCon.createPipeline();  
             INonBlockingPipeline msgPipeline = mplCon.getNonBlockingPipeline(msgPipelineId);  
    
             // replace the CommandPipelineHandler of the new pipeline  
             // 为新的逻辑连接指派一个handler，  
             // 和当前handler在一个线程中，即使设定@Execution(Execution.MULTITHREADED) 也是没用的  
             msgPipeline.setHandler(new DataHandler());  
             pipeline.write(msgPipelineId + "\r\n");  
   
             //耗时业务处理可以自行进行线程池调度，比如  
             pipeline.getWorkerpool().execute(task..);  
    
               
    
         } ...  
         ...  
     }  
 }  
    
 // A pipeline handler could also be a ordinary handler like IDataHandler  
 class DataHandler implements IDataHandler {  
    
     private FileChannel fc = null;  
    
     DataHandler() {  
         File file = ...  
         fc = new RandomAccessFile(file, "rw").getChannel();  
         ...  
     }  
    
    
     public boolean onData(INonBlockingConnection pipeline) throws IOException {  
         pipeline.transferTo(fc, pipeline.available());  
         ...  
         return true;  
     }  
 }  

Multiplexer的实现

在Multiplexer可以定义发送header及如何读取数据的的各项细节，参见默认的实现可以了解的更多，基本上一目了然了。

默认实现是org.xsocket.connection.multiplexed.multiplexer.SimpleMultiplexer

你可以自定义个Multiplexer：

     Java代码 
     
    
   
 // client-side custom multiplexed handling   
 IMultiplexedConnection multiplexedCon = new MultiplexedConnection(nativeCon, new MyMultiplexer());   
     
 // server-side custom multiplexed handling   
 IHandler adpater = new MultiplexedProtocolAdapter(new CommandPipelineHandler(), new MyMultiplexer()))   
 IServer server = new Server(9011, adpater);   

[java]view plaincopy 
    
 // client-side custom multiplexed handling  
 IMultiplexedConnection multiplexedCon = new MultiplexedConnection(nativeCon, new MyMultiplexer());  
    
 // server-side custom multiplexed handling  
 IHandler adpater = new MultiplexedProtocolAdapter(new CommandPipelineHandler(), new MyMultiplexer()))  
 IServer server = new Server(9011, adpater);   

     Java代码 
     
    
   
 class MyMultiplexer implements IMultiplexer {   
     
   
     //打开一个新的逻辑连接，向对端发送一个header   
     public String openPipeline(INonBlockingConnection nbc)    
              throws IOException,    
              ClosedException {   
   
         ... create a unique pipelineId   
         ... create a network packet   
         ... and send it to the peer   
     
         return pipelineId;   
     }   
     
     //关闭逻辑连接，向对端发送一个header   
     public void closePipeline(INonBlockingConnection nbc, String pipelineId)   
              throws IOException,    
              ClosedException {   
   
         ... create a network packet   
         ... and send it to the peer   
     }   
     
     //发送正文的之前执行，想对端发送一个header      
     public void multiplex(INonBlockingConnection nbc, String pipelineId, ByteBuffer[] dataToWrite)   
              throws IOException,    
              ClosedException {   
   
         ... create a network packet based on the pipeline data   
         ... and send it to the peer   
     }   
   
       
     public void multiplex(INonBlockingConnection nbc, String pipelineId, ByteBuffer[] dataToWrite, IWriteCompletionHandler completionHandler)   
              throws IOException,    
              ClosedChannelException {   
   
         ... create a network packet based on the pipeline data   
         ... and send it to the peer   
    }   
   
     
      //这个方法定义数据的接收处理   
     public void demultiplex(INonBlockingConnection nbc, IDemultiplexResultHandler rsltHdl)    
              throws IOException,    
              ClosedException {   
   
         ... read the network packet   
         ... notify the specific pipeline message   
   
             //默认实现是：   
            byte dataType = nbc.readByte();   
            ...   
         switch (dataType) {   
             case PIPELINE_DATA:...rsltHdl.onPipelineData(pipelineId, data);   
             case PIPELINE_OPENED:...rsltHdl.onPipelineOpend(pipelineId, data);   
             case PIPELINE_CLOSED:...rsltHdl.onPipelineClosed(pipelineId, data);   
                         default:...   
                 }   
            ...   
               
             
     }   
 }  

[java]view plaincopy 
    
 class MyMultiplexer implements IMultiplexer {  
    
   
     //打开一个新的逻辑连接，向对端发送一个header  
     public String openPipeline(INonBlockingConnection nbc)   
              throws IOException,   
              ClosedException {  
   
         ... create a unique pipelineId  
         ... create a network packet  
         ... and send it to the peer  
    
         return pipelineId;  
     }  
    
     //关闭逻辑连接，向对端发送一个header  
     public void closePipeline(INonBlockingConnection nbc, String pipelineId)  
              throws IOException,   
              ClosedException {  
   
         ... create a network packet  
         ... and send it to the peer  
     }  
    
     //发送正文的之前执行，想对端发送一个header     
     public void multiplex(INonBlockingConnection nbc, String pipelineId, ByteBuffer[] dataToWrite)  
              throws IOException,   
              ClosedException {  
   
         ... create a network packet based on the pipeline data  
         ... and send it to the peer  
     }  
   
      
     public void multiplex(INonBlockingConnection nbc, String pipelineId, ByteBuffer[] dataToWrite, IWriteCompletionHandler completionHandler)  
              throws IOException,   
              ClosedChannelException {  
   
         ... create a network packet based on the pipeline data  
         ... and send it to the peer  
    }  
   
    
      //这个方法定义数据的接收处理  
     public void demultiplex(INonBlockingConnection nbc, IDemultiplexResultHandler rsltHdl)   
              throws IOException,   
              ClosedException {  
   
         ... read the network packet  
         ... notify the specific pipeline message  
   
             //默认实现是：  
            byte dataType = nbc.readByte();  
            ...  
         switch (dataType) {  
             case PIPELINE_DATA:...rsltHdl.onPipelineData(pipelineId, data);  
             case PIPELINE_OPENED:...rsltHdl.onPipelineOpend(pipelineId, data);  
             case PIPELINE_CLOSED:...rsltHdl.onPipelineClosed(pipelineId, data);  
                         default:...  
                 }  
            ...  
              
            
     }  
 }  