xSocket multiplexed介绍

来源：互联网发布：淘宝买家电靠谱吗编辑：程序博客网时间：2024/05/16 23:55

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:...  
                }  
           ...  
             
           
    }  
}  

总的来说这个api还是非常轻巧实用的。