xSocket 教程

Connection-Oriented网络应用教程

这是一个使用xSocket2.0编写connection-oriented网络应用的初学者教程。 如果您需要更多的帮助，不要犹豫，使用 xSocket的支持论坛 。[e-mail]

核心功能
主要的抽象，以支持面向流的沟通是 连接 。 读取数据，并书面使用 IBlockingConnection 或 INonblockingConnection 对象。 一个连接对象提供了多种方便的方法来读取和写入批量模式在一个特定的数据类型记录或。

一个方面，还实现了 GatheringByteChannel 和 WritableByteChannel 包接口的java.nio中。 如果一个InputStream或OutputStream的是一个要求，java.nio.Channels.newInputStream（<readableChannel>）和 java.nio.Channels.newOutputStream（<writeableChannel>）方法可以用来包裹的通道。 由于经典的小溪有阻止行为只有阻塞通道 IBlockingConnection 应该被映射到一个典型的InputStream。

提供的方法，其它类型的方法来控制连接行为和方法，以检索有关该连接的状态信息。 例如远程端点的地址可以检索或连接的冲洗行为可以被控制。 这两个连接类的方法不是线程安全的。


在违反IBlockingConnection，立即返回了INonBlockingConnection通过调用Read方法。 要通知有关新一IDataHandler可以被分配到一个INonBlockingConnection传入的数据。 处理程序的回调方法，如果将执行相应的事件发生。 除了存在像IConnectHandler IDataHandler额外的处理程序。
关于INonblockingConnection服务器端处理工程传入的连接。

1。 一个以"/"为分隔符的简单TCP服务器示例
首先，定义一个handler类，并implements相关接口，如IDataHandler，IConnectHandler，IIdleTimeoutHandler或IConnectionTimeoutHandler。 连接成功并收到数据后，这个handler将被调用。

class EchoHandler implements IDataHandler {

  public boolean onData(INonBlockingConnection nbc)
           throws IOException,
           BufferUnderflowException,
           MaxReadSizeExceededException {

     String data = nbc.readStringByDelimiter("\r\n");
     nbc.write(data + "\r\n");
     return true;
  }
}

创建一个服务器实例，并指定上述处理程序

// creates the server by passing over the port number & handler
IServer srv = new Server(8090, new EchoHandler());

// run it within the current thread.
srv.run();  // the call will not return

// ... or start it by using a dedicated thread
srv.start(); // returns after the server has been started

... 这样就写好了

有两个方法启动服务，分别是run()和start()，start()会创建一个专用的线程来运行服务器，阻塞直到服务器内部已经启动。这是首选的方法。

要关闭服务器，使用server的close()方法。 像大多数connection-oriented框架一样，server类实现了java.io.Closeable接口。

2。 定义DataHandler的方法

如果数据已经收到，接口IDataHandler的onData回调方法将立即被调用。需要注意的是，网络上的数据可以被水平分割成若干段的TCP以及捆绑成一个TCP段。 例如在客户端使用connection.write发送“你好这是我的。我所要说的是在客户端..."，并不意味着以一个TCP片段发到服务器。 这个网络现象xSocket封装了方法处理，对调用者是透明的。 获得更多有关TCP协议信息请看 TCP / IP协议详解卷1：协议 。

该数据碎片的原因，每个NonBlockingConnection read 方法将抛出一个BufferUnderflowException，如果没有足够的数据可用。 网络根据不同的执行模式没有进一步的数据将接收网络上的水平之内挂起昂达方法内部调用（通过使用NONTHREADED模式xSocket的I / O线程执行onDataMethod，因此无法读取网络水平更上的数据在同一时间。参见本章有关更多信息，执行和同步）。

这是一种不常见的模式来处理BufferUnderflowException。 xSocket会吞下这一类型的异常被抛出时，BufferUnderflowException昂达调用返回。

class EchoHandler implements IDataHandler {

    // this method will be called each time when data fragments have been received
    public boolean onData(INonBlockingConnection nbc)
             throws IOException,
             ClosedChannelException,
             BufferUnderflowException,
             MaxReadSizeExceededException {

        // don't handle the BufferUnderflowException, xSocket will swallow it
        byte[] bytes = nbc.readBytesByLength(500);
        //...
       
        return true;
    }
}

该方法将被调用昂达只要再为未读数据在xSocket的内部读缓冲区中可用。 这意味着，昂达方法也被称为没有收到新的网络数据包，只要xSocket的内部读缓冲区不空。 只有在这个循环停止内部读缓冲区emtpy或当没有数据是由昂达方法实现读取。 xSocket检查内部读缓冲区的修改（新的网络数据已被添加或数据已被读取）在每次调用昂达昂达方式决定是否应再次调用。

该昂达也将被调用，如果连接已关闭。 到缓冲区下溢处理它等于就是一个常见的模式不办理的操作ClosedChannelException和执行IDisconnectHandler接口检测连接断开。

3。 编写客户端阻塞
对于客户端一IBlockingConnection可用于简化插座处理。 与此相反的NonBlockingConnection一BlockingConnection不支持回调处理程序。

IBlockingConnection bc = new BlockingConnection(host, port);

String req = "Hello server";
bc.write(req + "\r\n");

// read the whole logical part by waiting (blocking) until
// the required data have been received
String res = bc.readStringByDelimiter("\r\n");

assert (req.equals(res));


4。 编写一个非阻塞客户端
通过执行一个BlockingConnection的阅读方法，直到数据块的方法调用已收到超时或已经发生。 为了避免这种封锁行为的onBlockingConnection可以使用客户端。 要做到这一点，客户端处理程序加以界定，如果将通知网络事件发生（它实现IDataHandler和/或DisconnectHandler和/或...）


// defining the client handler (here as a anonymous inner class)IDataHandler clientHandler = new IDataHandler() {     public boolean onData(INonBlockingConnection nbc)              throws IOException,              BufferUnderflowException,              MaxReadSizeExceededException {       // read the whole logical part or throwing a BufferUnderflowException      String res = nbc.readStringByDelimiter("\r\n");      //...      return true;   }}; // opening the connectionINonBlockingConnection nbc = new NonBlockingConnection(host, port, clientHandler);nbc.write("Hello"); // do something else. Receiving data causes that the client // handler's onData method will be called (within a dedicated thread)//...


5。 包裹由一个连接阻塞非阻塞的连接
xSocket的实现在内部使用的BlockingConnection一个INonBlockingConnection实例。 这意味着，一个BlockingConnection是一个包装这在读方法阻塞的行为出现。 基于这个原因，NonBlockingConnection可以成为一个在任何时候BlockingConnection。


INonBlockingConnection nbc = ... // wrapping an existing non-blocking connection by a BlockingConnectionIBlockingConnection bc = new BlockingConnection(nbc);bc.readInt();//...


6。 裹在服务器端非阻塞的连接

在大多数情况下NonblockingConnections将用于在服务器端。 如果BlockingConnection是在服务器端的要求，将创建一个BlockingConnection通过包装NonblockingConnection。 包装一NonblockingConnection线索，所分配的处理程序，以非阻塞连接将获得在BlockingConnection内部处理程序中删除。 通常情况下，onConnect（）方法将被用于创建一个在服务器端BlockingConnection。


...class ConnectHandler implements IConnectHandler {   public boolean onConnect(INonBlockingConnection nbc) throws IOException {      IBlockingConnection bc = new BlockingConnection(nbc);       //       return true;   }     ...

7。 处理就可以

通过实施 IConnectHandler 接口，onConnect回调方法将被立即执行，如果一个新的连接建立。 这个方法将被调用仅一次。 通常这种回调方法将被用于执行（安全）检查连接的基础上，新的，modifiy连接属性，准备资源，设立后端连接或写邮件问候。 这是罕见中的数据读onConnect（）方法，因为它是不可预测的数据已经收到。


class Handler implements IDataHandler, IConnectHandler {     public boolean onConnect(INonBlockingConnection nbc) throws IOException {        //... e.g. open resources        return true;    }     public boolean onData(INonBlockingConnection nbc) throws IOException {        //...        return true;    }}


8。 处理断开
如果处理程序实现了 IDisconnectHandler 接口，onDisconnect回调方法将被执行时，连接已经终止（独立，如果当前进程终止或远程对等连接）。 即使连接将通过操作的调用onDisconnect处理方法修改/写无法执行，因为连接已经关闭。

一个断开发生在三个方面：

    * 客户端主动发起断开关闭连接。 在这种情况下，onDisconnect方法将被立即调用
    * 连接断开休息或同行不当和Java虚拟机检测到断开的连接。 在这种情况下，onDisconnect方法将被调用，当检测到断开的连接
    * 连接断开休息或同行不当和JavaVM 没有 检测到断开的连接。 在这种情况下，onDisconnect方法将 不会 被调用。 处理这种情况的处理程序应执行IIdleTimeoutHandler和/或IConnectionTimeoutHandler接口。


class Handler implements IDataHandler, IDisconnectHandler {     public boolean onDisconnect(INonBlockingConnection nbc) throws IOException {        //... e.g. closing open resources        return true;    }     public boolean onData(INonBlockingConnection nbc) throws IOException         ByteBuffer[] data = connection.readByteBufferByDelimiter("\r\n");       // print out the received data          ByteBuffer[] copy = new ByteBuffer[data.length];       for (int i = 0; i < data.length; i++) {          copy[i] = data[i].duplicate();       }       System.out.println(DataConverter.toString(copy));       //...       return true;    }}



在这样一个断开 IDataHandler 处理器也被称为（前执行IDisconnectHandler）。 类似的本地套接字读取INonBlockingConnection的available（）方法将返回-1，如果连接已关闭。 执行一个读方法导致操作ClosedChannelException，这将是xSocket吞噬如果处理。


9。 异步连接

一般情况下创建一个新的BlockingConnection或NonBlockingConnection是一个同步操作。 这意味着写或读连接后立即创建的方法才能被调用。 只是，在一些构造 客户端 NonBlockingConnection包括参数waitForConnect。 如果这个参数设置为false时，构造函数会立即返回而不等待，直到建立连接。 下面的清单显示了如何连接可以设置异步。 该处理器还实现了 IConnectExceptionHandler 处理一个连接异常（连接失败，超时异常，...).


class Handler implements IConnectHandler, IDataHandler, IConnectExceptionHandler {    public boolean onConnect(INonBlockingConnection nbc) throws IOException {      nbc.write("hello server\r\n");       //...      return true;   }        public boolean onConnectException(INonBlockingConnection nbc, IOException ioe) throws IOException {      //...      return true;   }            public boolean onData(INonBlockingConnection nbc) throws IOException {      //...        return true;   }} Handler hdl = new Handler(); INonBlockingConnection nbc = new NonBlockingConnection(InetAddress.getByName(host), port, hdl, false, 2000); //...// write operations are only valid after the connection has been established which is indicated by the onConect() callback
       


如果你调用一个写后，从NonBlockingConnection构造方法立即返回，种族状况的存在是因为它是不可预测的，如果连接已建立。 回调方法onConnect（）表示连接已建立。

10。 处理超时的
xSocket支持连接超时检测和闲置超时。 连接超时定义了连接最大寿命。 独立的交通连接将被关闭，超过了连接超时。 空闲超时定义的最大闲置时间在没有数据已经收到。 如果闲置时间已超过连接将被关闭。 为了避免资源浪费连接等待造成的非反应，这是 强烈建议设置一个适当的空闲时间了 。 默认情况下，空闲超时设置的最大值（?24天）。


连接和空闲超时，也可以由用户处理。 通过实施IIdleTimeoutHandler或IConnectionTimeoutHandler，拨回电话的方法onConnectionTimeout或onIdleTimeout将被调用一次。 如果方法返回true，这表明该事件已处理，该连接不会被关闭xSocket。 如果为false将被退回，xSocket关闭连接。

连接和空闲超时时间可以设置连接的特定的setConnectionTimeoutSec (...)和setIdleTimeoutSec (...)方法。 （重新）设置这个超时（重新）启动超时计数器。 例如，如果超时将被设置在一个超时回调方法，并返回真，其行为就像一个超时事件从未发生。

对服务器端的连接的默认超时行为可以设置服务器的超时设置方法。


// the handlerclass Handler implements IDataHandler, IIdleTimeoutHandler, IConnectionTimeoutHandler {     public boolean onConnectionTimeout(INonBlockingConnection nbc) throws IOException {        nbc.write("bye bye");        nbc.close();         return true;  // prevent, that xSocket also closes the connection    }      public boolean onIdleTimeout(INonBlockingConnection nbc) throws IOException {        nbc.write("What's going on? Why don't you send data?");         nbc.setIdleTimeoutMillis(30 * 1000); // resets the timeout counter        return true;  // prevent, that xSocket closes the connection    }      public boolean onData(INonBlockingConnection nbc) throws IOException {        //...         return true;    }}  // and the serverIServer server = new Server(8090, new Handler());server.setIdleTimeoutMillis(30 * 1000);    // set the default idle timeout for server-side connectionsserver.run();



11。 同步回调方法

的回调方法，如onConnect昂达(...) (...)或将同步执行的连接为基础。 这种对同一连接的executioba长时间运行或在您的onConnect永无止境方法的任务的手段，昂达（）为相同的连接方法永远不会被调用。

类处理程序实现IConnectHandler，IDataHandler {公共布尔onConnect（INonBlockingConnection美国全国广播公司）抛出IOException异常{nbc.write（“你好服务器\ ? \ ?”）; //... / /不要这么做！ / /这个原因，昂达（）将永远不会被调用，因为/ /执行回调方法是同步的，而连接上的（真）{{Thread.slepp尝试（1000）;}捕捉（InterruptedException的忽略）{} nbc.write （“我还活着\ ? \ ?”）;} / /你可以定义一个TimerTask和运行在一个计时器（线程）它/ /执行的“活着”的问题返回true;}公共布尔昂达（INonBlockingConnection美国全国广播公司）抛出IOException异常{string信息= nbc.readStringByDelimiter（“\ ? \ ?”）; //... 返回true;}} 

12。 定义一个连接范围内的处理程序
默认情况下处理程序实例的范围。 这意味着，同样的处理程序实例将用于每个连接新的传入。 处理程序成为连接的范围通过实现IConnectionScoped接口。 这个接口需要一个 克隆 方法，将用于创建新的连接给每一个专门的处理程序实例。 为了避免副作用，克隆方法应该进行 深刻的克隆。


class Handler implements IConnectHandler, IDataHandler {    public boolean onConnect(INonBlockingConnection nbc) throws IOException {      nbc.write("hello server\r\n");       //...      // DO NOT DO THIS!      // this causes that onData() will never be called because executing of       // callback methods is synchronized based on the connection      while (true) {          try {             Thread.slepp(1000);          } catch (InterruptedException ignore) {  }          nbc.write("I am alive\r\n");       }      // You could define a TimerTask and run it within a Timer (thread)       // to implement the "alive" issue      return true;   }            public boolean onData(INonBlockingConnection nbc) throws IOException {      String msg = nbc.readStringByDelimiter("\r\n");      //...        return true;   }}



通过声明一个作为连接范围内的处理程序，该处理的变量自动成为连接特定的（如深克隆支持）。 除了这个附加数据到一个隐含的方式连接方式也明确支持附件的方法。

13。 附加会话特有的数据连接
另一种方法来分配会议的日期到数据连接附加。 通常这是首选方法。 一个连接支持数据附加特定会话的连接 setAttachment（对象） ， getAttachment（） 方法。

类SmtpHandler实现IConnectHandler，IDataHandler {公共布尔onConnect（INonBlockingConnection美国全国广播公司）抛出IOException异常{nbc.setAttachment（新SessionData（））;返回true;}公共布尔昂达（INonBlockingConnection美国全国广播公司）抛出IOException异常{SessionData sessionData =（SessionData）nbc.getAttachment （）; //... 返回true;}}

14。 在运行时更换处理

xSocket支持替换在运行时的处理程序。 这可为特定连接或-处理器连接-所有新进入的一方案件服务器。 如果连接已经存在，这个处理器将被替换调用 <connection>。setHandler（...） 方法。 这将取代该处理的 电流 连接。

类ServerHandlerA实现IDataHandler {公共布尔昂达（INonBlockingConnection美国全国广播公司）throws IOException在加利福尼亚= {弦乐nbc.readStringByDelimiter（“\ ? \ N”的），如果（cmd.equals（“开关”））{nbc.setHandler（新ServerHandlerB（） ）;}否则{nbc.write（“甲”+加利福尼亚+“\ ? \ ?”）;}返回true;}}

在服务器端处理程序分配给服务器。 此处理程序（或克隆- >“连接范围的处理）将被分配到一个新的接受它传入的连接的。 你可以通过调用替换处理服务器的 <服务器。setHandler（...） 方法。 该服务器将被注入，如果你将它注释。

类ServerSideHandler实现IDataHandler {@私人服务器的服务器资源，公共布尔昂达（INonBlockingConnection连接）throws IOException在加利福尼亚= connection.readStringByDelimiter {字符串（“\ ? \ N”的），如果（cmd.equals（“开关”））{服务器。 setHandler（新ServerHandlerB（））; connection.write（“切换\ ? \ ?”）;}否则{connection.write（“甲”+加利福尼亚+“\ ? \ ?”）;}返回true;}}

15。 例如：一个简单的长度域为基础的处理器
要应用领域的通信模式的长度，连接的标记支持都可以使用。 在这种情况下，客户会先写一个“空”的长度字段。 写完内容数据，写指针将被移回长度字段，要覆盖长度字段。

IBlockingConnection公元前=新BlockingConnection（主机，端口）; bc.setAutoflush（假）; / /标记支持需要停用autoflush！ bc.markWritePosition（）; / /标记当前位置bc.write（（诠释）0）; / /写“emtpy”的长度字段诠释书面= bc.write（“你好世界”）;书面+ = bc.write（“真的很高兴在这里“）; //... bc.resetToWriteMark（）/ /返回长度领域的地位bc.write（书面）; / /和更新bc.flush（）; / /刷新（标记将被删除隐）


16。 ... 和服务器
对于服务器端的ConnectionUtils工具方法都可以使用。

公共布尔昂达（INonBlockingConnection美国全国广播公司）抛出IOException异常，BufferUnderflowException {/ /验证了足够的数据可用（如果/ /不是一个BufferUnderflowException将抛出）诠释长度= ConnectionUtils.validateSufficientDatasizeByIntLengthField（全国广播公司）;字符串文字= nbc.readStringByLength（长） ; nbc.write（全文）;返回true;}



17。 一个更复杂的例子：multitpart数据

通常，一个数据记录由多个部分组成。 例如，一个数据记录就可以开始与一些头数据数据之后的内容领域。 典型的头还包含一个内容长度字段。

IBlockingConnection公元前=新BlockingConnection（主机，端口）; bc.setAutoflush（假）; bc.write（RECORD_TYPE_A）/ /记录类型bc.write（（诠释）2）; / /版本bc.write（签订）; / /签名bc.write（长）; / /数据长度bc.flush（）; bc.write（数据）; / /数据bc.flush（）;字符串的状态= bc.readStringByDelimiter（“\ ? \ ?”）; //...


18。 ... 和服务器（“交易”阅读和动态处理器替换）

如上所述，数据将在网络上水平分割。 如果昂达（）方法被调用，它是不可预测的多少字节将被接受。 如通过调用的readInt（）或readStringByDelimiter（）可能会出现一个BufferUnderflowException读法。 为了解决这个问题，读标记支持都可以使用。

类ProtocolHandler实现IDataHandler {公共布尔昂达（INonBlockingConnection连接）抛出IOException异常{byte类型= -1;; int版本= -1;诠释签名= -1;诠释dataLength = 0 //////////// / /“交易”开始/ / / /标记读取位置connection.markReadPosition（）;尝试{类型= connection.readByte（）;版本= connection.readInt（）;签名= connection.readInt（）; dataLength = connection.readInt （）; connection.removeReadMark（）;}捕捉（BufferUnderflowException布埃）{connection.resetToReadMark（）返回true;} / / / /“交易”结束///////////////如果（类型== 1）{connection.setHandler（新ContentHandler的（这一点，dataLength，签名））;} {//...其他 }返回true;}} {类的ContentHandler实现IDataHandler私人诠释其余= 0;私人ProtocolHandler高密度脂蛋白= 0;公众的ContentHandler（ProtocolHandler高密度脂蛋白，诠释dataLength，诠释签名）{this.hdl =高密度脂蛋白;其余= dataLength; / / .. 。 }公共布尔昂达（INonBlockingConnection美国全国广播公司）抛出IOException异常{诠释可用= nbc.available（）;诠释lengthToRead =剩余;如果（可用<剩余）{lengthToRead =可用;}的ByteBuffer [] = nbc.readByteBufferByLength缓冲区（lengthToRead）;其余-= lengthToRead; / /处理的数据/ / ... 如果（剩余== 0）{nbc.setAttachment（HDL）的; nbc.write（“接受\ ? \ ?”）;}返回true;}}

这个清单上显示了一个简单的多重协议。 如果数据被接收后，昂达（）方法将被调用。 读位置参考点，以内部读取缓冲区头。

MarkSupport_1.gif

通过执行markReadPosition（）方法将当前读取的位置标示。 通过标记读取位置后所有读取操作的结果数据将被复制和缓冲由读标记内部缓冲区。
MarkSupport_2.gif

通过调用读取读取位置将被移动到下一个未读数据的方法。
MarkSupport_3.gif

如果没有足够的数据可以通过执行一个读法，一BufferUnderflowException将被抛出。
MarkSupport_4.gif

在这个例子中的代码将被逮住这个例外，读位置将被重置为已读标记和昂达（）方法将被退出。

MarkSupport_5.gif

如果有更多的数据recevied时，昂达（）方法将被再次调用。

MarkSupport_5_5.gif

在他昂达（）方法读取方法将被执行一次。
MarkSupport_6.gif

通过删除已读标记的“交易”完成。 该removeReadMark（）方法清除缓冲区的读标记。
MarkSupport_7.gif

读马克支持可以被用来实现一个轻量级的“交易”（读取所有或没有）的支持。 读标记的支持不是必需的，如果只有一个读操作将在inData调用的方法。

在下面的例子将一个专门的处理程序要使用的阅读内容的数据。 要做到这一点，目前的协议处理器在运行时将被替换的专用内容处理器。

19。 未读的支持

另一种方法来标记是未读的支持。 未读的基础上支持可撤消的操作进行一读。 通过执行 未读（...） 方法的数据将被推迟到缓冲区顶部内部读。

IBlockingConnection浓度=新BlockingConnection（主机，端口）;字符串txt的= con.readStringByLength（15）; / /检查记录是新的AA型，如果（！txt.indexOf（“类型=机管局”）= -1）诠释的长度= con.readInt（）; / / ... / / .. 不，比它必须是一个旧CA纪录}否则{/ /未读，并检查执行型Ca con.unread（txt）的; / /读取CA的记录字符串caHeader =如果（con.readStringByDelimiter (":");！ caHeader.equalsIgnoreCase（“CA的记录”））{/ /错误} / / .. }

20。 并发访问的连接线以外的回调

访问内螺纹连接的回调是线程安全的。 如果该连接将被线程访问的回调外并发的方式，访问必须同步。 类 ConnectionUtil 支持 synchronizedConnection (...)方法，通过一个同步的包装类委托者。 这样一个线程安全的包装类同步基础连接，每一个方法的基础上。

公共类ServerHandler实现IConnectHandler，IDataHandler，IDisconnectHandler {私人最后定时器定时器=新的Timer（真），公共布尔onConnect（INonBlockingConnection连接）抛出IOException异常{= ConnectionUtils.synchronizedConnection连接（连接）; TimeNotifier通知=新TimeNotifier（连接），定时器。时间表（发出通知，10，10）; connection.setAttachment（通知）;返回true;}公共布尔onDisconnect（INonBlockingConnection连接）抛出IOException异常{= ConnectionUtils.synchronizedConnection连接（连接）; TimeNotifier发出通知=（TimeNotifier）connection.getAttachment（ ），如果（通知=空）{notifier.cancel（）;}！返回true;}公共布尔昂达（INonBlockingConnection连接）抛出IOException异常{= ConnectionUtils.synchronizedConnection连接（连接）;字符串加利福尼亚= connection.readStringByDelimiter（“\ ? \ N“的）; connection.write（加利福尼亚+”：4545 \ ? \ ?“）;返回true;}} public类TimeNotifier扩展TimerTask的{私人最后INonBlockingConnection连接，公共TimeNotifier（INonBlockingConnection连接）{this.connection = ConnectionUtils。 synchronizedConnection（连接）;} @凌驾公众无效的run（）{{connection.write尝试（“CMD_TIME：”+ System.currentTimeMillis的（）+“\ ? \ ?”）;}赶上（例外五）{/ / .. 。 }}}服务器服务器=新服务器（新ServerHandler（））; server.start（）;    

21。 连同春季使用xSocket
该xSocket文物是纯Java类。 基于这个原因，它是非常容易使用Spring xSocket在一起。 本人下面将创建一个服务器，它侦听端口8787，并使用申报EchoHandler例子。

<？XML版本=“1.0”编码=“的UTF - 8”？> <豆xmlns =“http://www.springframework.org/schema/beans”xmlns：XSI的=“http://www.w3.org / 2001/XMLSchema-instance“的xsi：的schemaLocation =”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd“> <豆编号=“服务器”级=“org.xsocket.connection.Server”范围=“单身”> <constructor-arg type="int" value="8787"/> <构造函数参数类型=“org.xsocket.connection 。IHandler“号=”处理程序“/> </豆> <bean id="Handler" class="org.xsocket.connection.EchoHandler" scope="prototype"/> </豆>
       

服务器bean可以检索标准的Spring的做法。

BeanFactory的新XmlBeanFactory中的BeanFactory =（新FileSystemResource（文件））; IServer服务器=（IServer）beanFactory.getBean（“服务器”）; server.start（）; //...

Spring配置自动启动该服务器内的Spring bean的属性 初始化方法 和 销毁，方法 都可以使用。

... <bean id="server" class="org.xsocket.connection.Server" scope="singleton" init-method="start" destroy-method="close"> <构造函数参数类型=“整数”值=“ 8787“/> <constructor-arg type="org.xsocket.connection.IHandler" ref="Handler"/> </豆> ...       

在这种情况下，服务器已经开始通过检索它。

BeanFactory的新XmlBeanFactory中的BeanFactory =（新FileSystemResource（文件））; IServer服务器=（IServer）beanFactory.getBean（“服务器”）/ /服务器已经启动
       

22。 脚本支持
xSocket也进行了测试与喜欢的JRuby，Groovy或Jython脚本语言。 已知的限制（由环境造成的脚本语言）：

    * JRuby的 ：版本1.0和1.1要求xSocket JRubyHandlerAdapter，即可以下载 在这里 。 该适配器地图JRuby的提高异常放回原生的Java异常。 参见bug报告 的JRuby - 1300 。 Java注释是既不支持也不是JRuby的1.0版的JRuby 1.1。
    * Jython的 ：Java注释是不支持的Jython 2.2
    * Groovy的 ：没有已知的限制


例如代码见下表。
descritpion     语言的具体实例
一个简单的 BlockingClient 它执行一个GET请求和响应代码验证     的Java ， Groovy中 ， JRuby的 ， Jython的
一个简单的高可扩展NonBlockingClient它执行一个GET请求

并验证响应代码。 此外，连接事件将被处理
    的Java ， Groovy中 ， JRuby的 ， Jython的
一个简单的高可伸缩的无阻塞 EchoServer 收益收到的

数据（它也包含了使用处理程序链一个例子）
    的Java ， Groovy中 ， JRuby的 ， Jython的
一个简单的高可伸缩的无阻塞的 代理 服务器，服务的要求

通过转发请求到致力于服务器
    的Java ， Groovy中 ， JRuby的 ， Jython的
一个简单的 ServerPush 的例子，将消息发送到客户端定期     的Java ， Groovy中 ， JRuby的 ， Jython的

另见文章 在Java平台的脚本 ，看看如何xSocket可以访问内部的脚本语言。

23。 连接池
客户端连接池可以提高通过避免重新连接的创作上的表现。 通常情况下，连接池将被用来在客户端，如果在同一台服务器（地址）连接将在一段时间内排序串行方式创建。 通过这种连接池的建立连接的开销将是可以避免的。
一个连接池类存在BlockingConnection以及NonblockingConnection。 两个池还支持SSL连接。

/ /创建一个有限的连接池BlockingConnectionPool池=新BlockingConnectionPool（）; pool.setMaxActive（10）; IBlockingConnection公元前= 0;尝试{/ /获取一个连接（如果没有连接/ /在池，一个新的人会被创建）公元前= pool.getBlockingConnection（主机，端口）; bc.write（“你好”）; //... / /总是关闭连接！ （连接将是/ /返回到连接池）bc.close（）;}捕捉（IOException异常雇主组织）{如果（公元前=空）{尝试{/ /如果连接是无效的 - >“毁了它/ /（它不会返回到池）pool.destroy（年）;}赶上（例外忽略）{}}}



24。 SSL支持（静态和点播）
要运行在一个SSL模式的服务器，只需拨SSLContext对象必须通过在构造函数了。 通过设置与真实的sslOn参数，服务器将启动在SSL模式。


服务器端的例子

的SSLContext的SSLContext = SSLContext.getDefault（）; / / getDefault是约翰内斯堡1.6方法IServer sslTestServer =新的服务器（端口，新EchoHandler（）的SSLContext，真实）; sslTestServer.start（）; / /手动SSL的激活（connection.activateSecuredMode ）没有必要！



客户端的例子

IBlockingConnection公元前=新BlockingConnection（主机，端口，的SSLContext，真实）; //...



如果SSL模式应该是起步较晚 - 上要求 - sslOn参数必须以虚假的设置。 这同样适用于客户端连接正确的。

客户端的例子（按需激活）

IBlockingConnection公元前=新BlockingConnection（主机，端口，的SSLContext，假）; //... bc.activateSecuredMode（）; //...



服务器端的例子（按需激活）

IServer sslTestServer =新的服务器（端口，新EchoHandler（）的SSLContext，假）; sslTestServer.start（）/ /处理程序的实现类EchoHandler实现IDataHandler {公共布尔昂达（INonBlockingConnection美国全国广播公司）抛出IOException异常{//... / /激活需求SSL模式（ - “只有必要的，如果/ /服务器旗假开始）nbc.activateSecuredMode（）; //... 返回true;}}



通常升级到安全模式是结合派出一个普通的响应消息证实，该连接将被升级。 在这种情况下，要确保没有邮件将发送平原之间确认消息，并启动安全模式接收。 要做到这一点，两种方法退出：

控制对用户级冲洗行为。

/ /安全使用用户级冲洗类MyHandler SSL的升级实现IDataHandler {公共布尔昂达（INonBlockingConnection美国全国广播公司）抛出IOException异常{nbc.write（SECURED_MODE_ACTIVATED）/ /（准备）发送确认消息nbc.activateSecuredMode平原（）; / / xSocket在纯模式下发送邮件，因为它已/ /被写入之前，安全模式已被激活nbc.flush（）返回true;}}


或暂停，恢复二读。

/ / SSL的安全升级，暂停和恢复（和默认autoflush）类MyHandler实现IDataHandler {公布尔昂达（INonBlockingConnection美国全国广播公司）抛出IOException异常{nbc.suspendRead（）; nbc.write（SECURED_MODE_ACTIVATED）; nbc.activateSecuredMode（）;的NBC。 resumeRead（）返回true;}}


25。 法拉盛
默认情况下，autoflush被激活。 这意味着调用Write方法将数据传输到底层的子系统（操作系统内部写socket缓冲区），立即。 通过调用连接的setAutoflush（假）方法，冲洗行为将手动控制。 对于服务器端处理这通常内完成onConnect回调方法或通过调用服务器的setAutoflush（假）方法。

Autoflush例子（默认行为）

/ /客户端IBlockingConnection公元前=新BlockingConnection（主机，端口）; bc.write（文本+“\ N”的）;字符串反应= bc.readStringByDelimiter（“\ ?”）; / /服务器端类ServerHandler实现IDataHandler {公共布尔昂达（INonBlockingConnection美国全国广播公司）抛出IOException异常{字符串文本= nbc.readStringByDelimiter（“\ N”的）; nbc.write（全文）; nbc.write（“\ ?”）;返回true;}}



用户管理的例子刷新

/ /客户端IBlockingConnection公元前=新BlockingConnection（主机，端口）; bc.setAutoflush（假）; bc.write（文本+“\ N”的）; bc.flush（）;字符串反应= bc.readStringByDelimiter（“\ N“的）; / /服务器端类ServerHandler实现IConnectHandler，IDataHandler {/ /设置假（这种行为也可以/ /被服务器设置控制）公共布尔onConnect autoflush（INonBlockingConnection美国全国广播公司）抛出IOException异常{nbc.setAutoflush（假）返回true;}公共布尔昂达（INonBlockingConnection美国全国广播公司）抛出IOException异常{字符串文本= nbc.readStringByDelimiter（“\ N”的）; //... nbc.write（全文）; nbc.write（“\ N”的）; //... nbc.flush（）返回true;}}



虽然自动刷新，自动刷新的数据写操作执行时， FlushMode 控制冲水的行为。 如果设置为异步FlushMode（默认是同步的），将数据传输到底层连接异步方式中。

通过使用 WritableByteChannel 接口的方法写（ByteBuffer的）和write（ByteBuffer的[]）的一些限制出口。 称这样的方法写在异步模式下，会导致缓冲区中的字节将被读取线程异步的内部I / O。 如果字节的缓冲区将被访问写方法（再用）调用后，会出现竞争条件。 写（ByteBuffer的）和write（ByteBuffer的[]）只在异步模式调用，如果字节缓冲区将不会被访问的写操作（重复使用）之后。 在下面的例子中的ByteBuffer一个将被重用serveral次复制数据。 在这种情况下，不能使用异步写入数据。 如果异步模式时，会出现竞争条件。

... 文件的文件=新的文件（文件名）; RandomAccessFile的英国皇家空军=新RandomAccessFile的（文件，“住宅”）; ReadableByteChannel功能界别= raf.getChannel（）; IBlockingConnection连接=新BlockingConnection（主机，端口）; / /使用一个复制缓冲区（其中将回用于读操作）/ /要求FlushMode同步是默认（写）！ ByteBuffer的copyBuffer = ByteBuffer.allocate（4096）;诠释读= 0;（阅读> = 0）{/ /读取通道读= fc.read（copyBuffer）; copyBuffer.flip（）;若（读> 0）{/ /写通道connection.write（copyBuffer），如果（copyBuffer.hasRemaining（））{copyBuffer.compact（）;} {copyBuffer.clear其他（）;}}} ...

通过使用FlushMode异步你必须确保的ByteBuffer将不会被修改或合格后，通过调用Write方法过来重复使用。

26。 性能的建议

[BlockingConnection＆NonBlockingConnection] 使用直接ByteBuffer传入套接字读取数据可以提高性能。 使用直接ByteBuffer将与激活属性设置系统usedirect 真 ：

    * org.xsocket.connection.client.readbuffer.usedirect =真
    * org.xsocket.connection.server.readbuffer.usedirect =真

默认情况下设置了这些属性与 假 ，因为一些虚拟机的实现缓冲区的问题似乎已经气相色谱直接。

[BlockingConnection＆NonBlockingConnection] 通过设置 autoflush 与false（默认为true），冲洗，可手动控制。 由于冲洗执行写操作的基础连接和同步上，刷新操作是昂贵的。 尤其是在多的情况下“写在一个”交易，用户管理的冲洗可以提高性能。 通过使用连接的写（ByteBuffer的）和write（ByteBuffer的[]）方法的一些限制出口。 请参阅更多信息的API文档。

IBlockingConnection公元前= ... bc.setAutoflush（假）; bc.write（头）; bc.write（片段1）; bc.write（fragement2）; //... bc.flush（）;


[NonBlockingConnection只有] 通过设置 刷新模式 和异步（默认是同步的）的数据将被转移到底层操作系统的内部套接字发送缓冲区以异步的方式。 通过设置模式和异步的刷新工作线程将不会同步与xSocket -内部I / O线程。 请 采取异步刷新模式设置照顾到 。 如果您访问写入缓冲区后，会出现竞争条件。

设置具有同步flushmode并不意味着，对端收到的数据。 它只是说，该数据已转移到操作系统内部的套接字发送缓冲区。 如果没有足够的空间可在操作系统内部套接字发送缓冲区和同步模式设置，刷新操作将阻塞，直到套接字缓冲区空间变得自由。 该操作系统将在网络上只写级别的数据，如果TCP流量控制系统（滑动窗口机制）信号的接收端能够接收更多的数据。

在异步模式下，即将卸任的数据将被缓冲使用（未绑定）xSocket内部写缓冲区。 这意味着，如果接收节点独立能够接收数据或者没有，刷新操作将不会阻碍在异步模式。

INonBlockingConnection NBC的= ... nbc.setFlushmode（FlushMode.ASYNC）;


该 FileChannel 支持性能优化和传输方法transferFrom (...) (...)该基地的transferTo冲洗隐含的同步。 通过文件通道传输数据的连接，连接的transferFrom (...)方法应该用来代替文件通道的的transferTo (...)方法。 根据目前的连接刷新模式的连接的transferFrom (...)方法如果文件决定内部通道的应该使用的transferTo (...)（flush模式=同步）或没有。 连接的transferFrom (...)方法将选择最好的方法。 一般来说，你得到一个更好的表现刷新模式通过使用异步。

INonBlockingConnection NBC的= ... FileChannel fc的= ... / /使用nbc.transferFrom（财委会）; / /而不是fc.transferTo（0，fc.size（），全国广播公司）;       


同样是真实的连接方法的transferTo (...)。 而不是使用文件通道的transferFrom (...)方法，连接的transferTo (...)方法应该被使用。 使用连接传输方式 ，而不是文件通道传输方法。 xSocket会选择当前连接设置内部最好的方法，基于。

INonBlockingConnection NBC的= ... FileChannel fc的= ... / /使用nbc.transferTo（财委会，长度）; / /而不是fc.transferFrom（全国广播公司，0，长度）;

选择适当的 工作池型 （绑定池，池绑定，...）和大小。 正确的工作池的大小取决于具体的处理程序实现。 如果处理程序执行长时间运行的类似文件阻塞调用的I / O或网络调用的消耗和闲置等待多少时间，较大的工作池的大小应设置。 如果工人已配置池大小小，并发连接回调的可能不是由线程等待自由工作者。 在这种情况下，效率很低，因为所采取的工作线程等待时间花费最多。 并行回调不能履行造成的CPU资源，如丢失工作线程和系统的部分闲置。 另一方面，如果劳动者池大小配置为高，作业系统会花很多时间线之间切换，而不是执行它们。

要配置由<IConnection>套接字参数。的SetOption (...)方法也见 增加在Linux套接字性能 。

27。 接收和发送缓冲区大小（网络流量控制）

作业系统使用Socket缓冲区（的SO_RCVBUF，将SO_SNDBUF），以缓冲传入和传出的网络数据。 这些缓冲区定义的TCP接收窗口，它指定的数据量，可以在不中断数据交换发送。 例如，如果在接收套接字缓冲区高水位到达，发送方将停止发送网络数据。 的机制，控制数据传输中断被称为流量控制。

套接字缓冲区的大小）取决于作业系统（配置，并可以在运行时修改了 IConnection的 setOption（）方法。 一般情况下，默认缓冲区大小为8KB。

buffers.gif

基于操作的系统级接收和发送缓冲区，第二层接收和发送应用程序的缓冲区退出。 如果接收数据，网络数据（参考）将被复制从作业系统的的SO_RCVBUF到xSocket的二级缓存的缓冲区。 默认情况下，secod级缓冲区是无限的。 在这种情况下，TCP流控制将永远不会停止接收来自发送者的数据。

为了避免被恶意攻击寄件人，第二级缓冲区可以是有限的 maxReceiveBufferThreshold 门槛“ - > setMaxReadBufferThreshold（大小）。 该阈值将复制后立即检查，一级的SO_RCVBUF接收缓冲区到应用程序。 如果应用程序级的接收缓冲区超过阈值时，网络读取操作将被暂停。 该网络读取的操作将自动恢复，如果应用水平成为maxReceiveBufferThreshold低于。

28。 为了避免进行大发送缓冲区

一个缓慢的接收端的输出数据将在xSocket的二级缓冲的发送缓冲区的原因。 为了避免大的二级发送缓冲区，由慢接收方造成的，同步刷新模式（这是默认值）可以使用。 在这种情况下，编写方法返回后的数据写入到操作系统级的SO_SNDBUF。

IBlockingConnection浓度=新BlockingConnection（主机，端口）; / /或/ / INonBlockingConnection浓度=新NonBlockingConnection（主机，端口）; / / con.setFlushmode（FlushMode.SYNC）;没有必要，因为它是默认RandomAccessFile的文件=新RandomAccessFile的（文件名，“住宅”）; FileChannel通道= file.getChannel（）;的ByteBuffer transferBuffer = ByteBuffer.allocate（4096）;诠释读= 0;做{transferBuffer.clear（）;读= channel.read（transferBuffer）; transferBuffer。翻转（），如果（读> 0）{/ /直到把数据块是操作系统级的将SO_SNDBUF con.write书面（transferBuffer）;}}而（阅读> 0）; channel.close（）; file.close（ ）; //...

这将避免大型二级发送缓冲区。 然而，由于TCP流控制的写（刷新）方法将被阻塞，直到接收方消耗的数据。 当前线程将暂停使用。 该INonBlockingConnection和IBlockingConnections还支持 IWriteCompletionHandler 这有助于避免阻塞线程。 该IWriteCompletionHandler defines出现回调方法将被调用，如果数据被写入到操作系统级的SO_SNDBUF外径如果一个错误。 一般情况下，IWriteCompletionHandler只用于连接的模式是异步刷新。 所造成的asnc刷新模式Write方法将立即返回。 是数据写入，或发生异常时，调用回调方法onWritten（...）或onException（...）会被调用。

下面的例子演示了如何自动曝光IWriteCompletionHandler可以被用来发送大量发送缓冲区，避免在同步模式下的数据。

IBlockingConnection浓度=新BlockingConnection（主机，端口）; / /或/ / INonBlockingConnection浓度=新NonBlockingConnection（主机，端口）; AsyncWriter asyncWriter =新AsyncWriter（文件名，体质）; asyncWriter.write（）; / / .. 类AsyncWriter民间最终实现IWriteCompletionHandler {INonBlockingConnection浓度;私人最后ReadableByteChannel通道;最后RandomAccessFile的私人文件，私人的AtomicBoolean实现再=新的AtomicBoolean（假），私营的ByteBuffer transferBuffer = ByteBuffer.allocate（4096），私人雇主组织IOException异常= 0; AsyncWriter（字串文件名，INonBlockingConnection浓度）抛出IOException异常{this.con =浓度; =新RandomAccessFile的文件（文件名，“住宅”）;通道= file.getChannel（）; con.setFlushmode（FlushMode.ASYNC）;}无效的write（）抛出IOException异常{writeChunk（）;}私人无效writeChunk（）throws IOException在{transferBuffer.clear（）;诠释读= channel.read（transferBuffer）; transferBuffer.flip（）;若（读> 0）{con.write（transferBuffer，这）;}否则{con.close（）; channel.close（）; file.close（）; isComplete.set（真）;}}公共无效onWritten（智力书面）抛出IOException异常{writeChunk（）;}公共无效onException （IOException异常雇主组织）{this.ioe =雇主组织; isComplete.set（真）;}布尔实现再（）throws IOException在{如果（国际雇主组织=空）{扔雇主组织;}返回isComplete.get（）;}}


29。 配置服务器

可能是你要配置。服务器 动态配置 参数可以通过调用setter方法拨款。

/ /定义超时，其中数据被接收srv.setIdleTimeoutMillis（2 * 60 * 1000）; / /定义为连接srv.setConnectionTimeoutMillis超时（30 * 60 * 1000）; / /设置默认autoflush行为在/ /服务器端创建的连接srv.setAutoflush（假）;


你也可以配置 工作池 。 工人池用于执行回调方法，如昂达处理程序的或onConnect。 看完后，从插座上的数据，该xSocket内部的 分派器 启动一个工作线程池来执行适当的回调方法。

分发器（I / O线程）负责执行套接字读取及写入I / O操作，并委托回调处理。 默认情况下 的CPU + 1个 调度员将被创建。 一个连接到一调度，必将在总生存期。

architecture.gif

xSocket使用工人池只执行处理程序的回调方法。 游泳池可通过调用相应的setter方法。 一个工作池已实施java.util.concurrent.Executor接口。 如果没有工人池将被设置，一 FixedThreadPool 使用（见 java.util.concurrent.Executors ）。

/ /设置一个有20个线程srv.setWorkerpool（Executors.newFixedThreadPool（20））固定工人池; //...



看到一个更深的研究多线程体系结构为 一个高度可扩展的体系结构基于NIO服务器

静态配置 参数将拨款设立的系统属性。 例如：

?：\应用程序> Java的Dorg.xsocket.connection.dispatcher.maxHandles = 60 org.xsocket.connection.EchoServer 9011

以下系统属性的支持：
系统属性     类型     描述
org.xsocket.connection.server.workerpoolSize     诠释     最大线程的默认WorkerPool的（自动调整大小工作者池）池的大小。 这WorkerPool的将被服务器如果没有自定义WorkerPool的设置。 默认是100。
org.xsocket.connection.server.workerpoolMinSize     诠释     最小的默认WorkerPool的线程池的大小。 默认为4
       
org.xsocket.connection.sendFlushTimeoutMillis     诠释     刷新（写）的超时。 此超时将被忽略使用FlushMode.ASYNC。 默认值是60000利斯。
       
org.xsocket.connection.dispatcher.initialCount     诠释     调度员（NIO的选择器）金额将被使用。 默认情况下2调度使用。
org.xsocket.connection.dispatcher.maxHandles     诠释     在其中将被连接到一个调度实例的最大通道数。 如果需要，额外的调度会自动启动xSocket。 默认情况下，通道的数量是无限的。
org.xsocket.connection.dispatcher.detachHandleOnNoOps     布尔     通过建立真正的通道将被分离，如果没有（NIO的的SelectionKey）操作设置。 该频道将自动复位。 默认为false。
       
org.xsocket.connection.client.readbuffer.defaultMaxReadBufferThreshold

org.xsocket.connection.server.readbuffer.defaultMaxReadBufferThreshold
    诠释     设置默认maxReadBuffer门槛。 此属性的默认值是无限的。
org.xsocket.connection.client.readbuffer.usedirect

org.xsocket.connection.server.readbuffer.usedirect
    布尔     通过建立真正的直接分配的缓冲区将被用于传入套接字读取数据。 默认为false。
org.xsocket.connection.client.readbuffer.preallocation.size

org.xsocket.connection.server.readbuffer.preallocation.size
    诠释     预分配的字节大小。 预分配的缓冲区将被用来读取数据的输入插座。 未使用的预分配缓冲区的读操作将被回收。 默认为65536。
org.xsocket.connection.client.readbuffer.preallocated.minSize

org.xsocket.connection.server.readbuffer.preallocated.minSize
    诠释     预分配的最小字节大小。 如果预先分配的缓冲区大小低于minSize瀑布，将预先分配新的缓冲区。 默认为64。


30。 执行和同步回调处理程序方法
回调处理程序的方法将被调用的一个 同步的范围内 。 调用方法将同步根据相关的连接。 这意味着，安德勒回调方法将永远是连接在同一个叫做序列化的方式的。 更进一步回调方法将始终以正确的顺序执行（onConnect，昂达，...，onDisconnect）。

默认情况下将使用辅助线程执行的回调方法。 通过注解执行模式处理程序与 NONTHREADED 处理程序回调方法将线程执行的xSocket -内部I / O。 这可以提高性能和可扩展性，因为非线程引起的环境switchs是必需的。 这样做是合理的，如果只是平常非阻塞 CPU绑定 操作将被执行的处理程序执行。 如果处理程序执行I / O操作，网络操作，如文件或当前线程可以悬挂在操作调用。 这意味着xSocket内部的单一I / O线程将暂停，并在服务器被封锁！ 请考虑，有些库调用执行I / O限制或同步操作含蓄。 例如，一个框架，它记录了日志输出到一个文件可以执行阻塞I / O操作的内部。

刷新模式应设置为异步如果执行模式NONTHREADED。 刷新模式的结合SYNC和执行模式NONTHREADED可能导致死锁。


xSocket并不能保证NONTHREADED注明的文物将永远受到xSocket的I / O线程执行。 在某些情况下xSocket可以决定通过使用一个工人线程NONTHREADED注明的人工制品。 这种情况可能发生通过使用一个处理程序类“混合级”注解..

执行模式可以设置处理程序类级别和/或在回调方法级。 默认情况下，执行模式设置与 多线程 。 一个方法级的执行模式的定义覆盖类级别的定义。

请注意，一NonBlockingConnection的方法（包括读取和写入方法）不计为一的“I / O”型方法如上所述。 这些操作使用内存中读取和写入读写数据缓冲区。 这不是为了创造一个新的连接实现。

@执行（Execution.NONTHREADED）类NonThreadedHandler实现IConnectHandler，IDataHandler {@执行（Execution.MULTITHREADED）/ /覆盖类级别化的公共布尔onConnect（INonBlockingConnection美国全国广播公司）throws IOException在公元前= {IBlockingConnection新BlockingConnection（主机，端口）; bc.write（“CMD_GET_CURRENT_RATE \ ? \ ?”）;诠释率= bc.readInt（）; / / ... 返回true;} / /继承类级别的模式NONTHREADED公共布尔昂达（INonBlockingConnection美国全国广播公司）抛出IOException异常{诠释为Y = nbc.readInt（）;诠释x = .... 计算没有我的东西/ O的nbc.write（十）返回true;}}



31。 故障排除（伐木，常见问题，...）

- 日志

xSocket使用内置的 日志记录 了Java SE的能力。 要配置logging.properties文件记录行为所看到 配置属性文件与记录器的默认值 。 您还可以设置日志配置编程。

/ /激活xSocket记录（名称空间org.xsocket.connection）记录器记录器= Logger.getLogger（“org.xsocket.connection”）; logger.setLevel（Level.FINE）; ConsoleHandler通道=新ConsoleHandler（）; ch.setLevel （Level.FINE）; logger.addHandler（瑞士）;



- 太多打开的文件

一个问题在共同 开启/关闭连接大量的 时间在短期内是打开的文件太多错误，系统所造成的（配置的）底层的操作。 在 打开的文件太多支持模式 描述了这一问题，以及如何处理它。 通过使用Windows又见 调整视窗


- 异步Flushmode

设置flushmode以异步可以提高性能。 然而，一些通过使用异步flushmode强烈限制出口。 上面讨论的限制。 采取设置flushmode以异步照顾。

- 线程安全

两个，NonBlockingConnection和BlockingConnection是 不是线程安全的 。 另请注意，使用该商标的支持改变一个应用程序级的内部状态的连接，这对进行同步。

/ /可以被称为私人无效SendMessage消息（string信息）{并发线程（INonBlockingConnection美国全国广播公司：连接）{/ /通过同步（美国全国广播公司）{nbc.markWritePosition（）的连接实例同步; / /标记当前位置nbc.write （（诠释）0）; / /写“emtpy”的长度字段诠释书面= bc.write（System.currentMillis（））; / /诠释书面+ = bc.write（味精）; nbc.resetToWriteMark（）; / /返回长度领域的地位nbc.write（书面）; / /和更新nbc.flush（）;}}}


32。 JMX支持
该ConnectionUtils类支持的方法来注册相关的MBean的 IServer 或 IConnectionPool MbeansServer执行情况

/ / JMX支持一台服务器IServer的SRV =新服务器（8090，新的处理程序（））/ /注册的平台MBeanServer ConnectionUtils.registerMBean（休闲车）服务器的MBean的; srv.start（）; / /支持JMX的一连接池BlockingConnectionPool池=新BlockingConnectionPool（）; / /注册的平台MBeanServer ConnectionUtils.registerMBean（池）池MBeans的;

通过注册服务器，xSocket创建也是指定的处理程序的MBean。 通过杜安这一点，所有的处理程序getter和setter方法将用于出口，这是不公开的。

注册后如JConsole的文物工具可用于监视
jconsole.gif

该 服务器
echoserver.gif

和 池
pool.gif

评论

1 楼 heping9574 2013-04-24  

你这都什么啊，直接通过翻译软件翻译过来就能网上

IBlockingConnection浓度=新BlockingConnection（主机，端口）;