xSocket multiplexed介绍

最新推荐文章于 2019-11-04 09:04:19 发布

lizhi200404520

最新推荐文章于 2019-11-04 09:04:19 发布

阅读量2.2k

点赞数

分类专栏： xsocket 文章标签： header string network server byte java

xsocket 专栏收录该内容

7 篇文章

订阅专栏

xSocket是一个轻量级的基于nio的服务器框架，旨在提供高性能、可扩展性和多线程支持。通过xSocketMultiplexed模块，实现长连接和逻辑连接复用，简化客户端与服务器之间的通讯流程。本文详细介绍了同步客户端示例，包括如何建立连接、发送和接收数据，以及服务器端的处理逻辑。自定义Multiplexer实现提供了更灵活的数据传输控制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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();

// 建立一个客户端的 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;
}
}

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);

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

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还是非常轻巧实用的。