Chinaunix首页 | 论坛 | 博客

代码路上

首页　| 　博文目录　| 　关于我

hibean2014

  • 博客访问： 31028
  • 博文数量： 6
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 91
  • 用 户 组： 普通用户
  • 注册时间： 2014-10-19 20:11
文章分类

全部博文（6）

文章存档

2016年（1）

2014年（5）

我的朋友
最近访客
推荐博文
相关博文
HSQLDB源码阅读 （二）通信协议的处理

分类： Java

2014-10-20 21:48:24

上篇，我们对HSQLDB的入口，Server.java做了分析。Server主要工作就是启动Tcp监听，等待客户端来进行连接。
我们知道，在计算机中，不能是数据也好，逻辑也好，最终都是通过二进制来进行存储、传输的。
一段数据，以二进制形式从一台计算机，通过网络，传输到另外一台计算机，必然需要双方遵守一些约定，以确保接收方做的事情与发送方的要求是一致的——这就是通信协议，如我们常见的http就是一种通信协议。


上篇结尾中说到，Server接收到请求之后，就转到ServerConnection来处理，ServerConnection就负责了对通信协议的解析，将不同的指令，转到相应的函数中处理。
HSQLDB支持3种协议：odbc、hsql_stream_protocal和http。下面通过源码来分析，这些协议在Hsqldb中是如何处理的，如果你清楚二进制协议是怎么回事，你大概可以略过这篇文章。

我们先看构造函数：

点击(此处)折叠或打开

  1. ServerConnection(Socket socket, Server server) {

  3.         RowOutputBinary rowOutTemp = new RowOutputBinary(mainBuffer);

  5.         rowIn = new RowInputBinary(rowOutTemp);
  6.         rowOut = rowOutTemp;

  8.         //
  9.         Thread runnerThread;

  11.         this.socket = socket;
  12.         this.server = server;
  13.         mThread = mCurrentThread.getAndIncrement();

  15.         synchronized (server.serverConnSet) {
  16.             server.serverConnSet.add(this);
  17.         }
  18.     }
其中的rowIn, rowOut，是用来读写数据的。
将socket对象和server对象都保存起来，并将客户端连接数增加1。

ServerConnection本身是实现了Runnable接口，也就是说ServerConnection的入口函数就是run方法

点击(此处)折叠或打开

  1. public void run() {

  3.         int msgType;

  5.         init();

  7.         if (session != null) {
  8.             try {
  9.                 while (keepAlive) {
  10.                     msgType = dataInput.readByte();

  12.                     if (msgType < ResultConstants.MODE_UPPER_LIMIT) {
  13.                         receiveResult(msgType);
  14.                     } else {
  15.                         receiveOdbcPacket((char) msgType);
  16.                     }
  17.                 }
  18.             } catch (CleanExit ce) {
  19.                 keepAlive = false;
  20.             } catch (IOException e) {

  22.                 // fredt - is thrown when connection drops
  23.                 server.printWithThread(mThread + ":disconnected " + user);
  24.             } catch (HsqlException e) {

  26.                 // fredt - is thrown in unforeseen circumstances
  27.                 if (keepAlive) {
  28.                     server.printStackTrace(e);
  29.                 }
  30.             } catch (Throwable e) {

  32.                 // fredt - is thrown in unforeseen circumstances
  33.                 if (keepAlive) {
  34.                     server.printStackTrace(e);
  35.                 }
  36.             }
  37.         }

  39.         close();
  40.     }
在这里，先是初始化init，然后一直处理客户端的数据receiveResult。我们先来看init，然后再看receiveResult。（知道init是怎样一个流程，则发现receiveResult也是差不多的）

点击(此处)折叠或打开

  1. private void init() {

  3.         runnerThread = Thread.currentThread();
  4.         keepAlive = true;

  6.         try {
  7.             socket.setTcpNoDelay(true);

  9.             dataInput = new DataInputStream(
  10.                 new BufferedInputStream(socket.getInputStream()));
  11.             dataOutput = new DataOutputStream(socket.getOutputStream());

  13.             int firstInt = handshake();

  15.             switch (streamProtocol) {

  17.                 case HSQL_STREAM_PROTOCOL :
  18.                     if (firstInt
  19.                             != ClientConnection
  20.                                 .NETWORK_COMPATIBILITY_VERSION_INT) {
  21.                         if (firstInt == -1900000) {
  22.                             firstInt = -2000000;
  23.                         }

  25.                         String verString =
  26.                             ClientConnection.toNetCompVersionString(firstInt);

  28.                         throw Error.error(
  29.                             null, ErrorCode.SERVER_VERSIONS_INCOMPATIBLE, 0,
  30.                             new String[] {
  31.                             verString, HsqlDatabaseProperties.THIS_VERSION
  32.                         });
  33.                     }

  35.                     Result resultIn = Result.newResult(dataInput, rowIn);

  37.                     resultIn.readAdditionalResults(session, dataInput, rowIn);

  39.                     Result resultOut;

  41.                     resultOut = setDatabase(resultIn);

  43.                     resultOut.write(session, dataOutput, rowOut);
  44.                     break;

  46.                 case ODBC_STREAM_PROTOCOL :
  47.                     odbcConnect(firstInt);
  48.                     break;

  50.                 default :

  52.                     // Protocol detection failures should already have been
  53.                     // handled.
  54.                     keepAlive = false;
  55.             }
  56.         } catch (Exception e) {

  58.             // Only "unexpected" failures are caught here.
  59.             // Expected failures will have been handled (by sending feedback
  60.             // to user-- with an output Result for normal protocols), then
  61.             // continuing.
  62.             StringBuffer sb = new StringBuffer(mThread
  63.                                                + ":Failed to connect client.");

  65.             if (user != null) {
  66.                 sb.append(" User '" + user + "'.");
  67.             }

  69.             server.printWithThread(sb.toString() + " Stack trace follows.");
  70.             server.printStackTrace(e);
  71.         }
  72.     }
通过在handshake函数中，读到的第一个字节的信息,取出了当前的通信协议，ServerConnection支持两种协议：odbc和HSQL_STREAM_PROTOCOL，值得注意的是，当使用HSQL_STREAM_PROTOCOL时，第一个字节值为当前协议版本号。
下面，我们将仅对HSQL_STREAM_PROTOCOL进行分析，因为odbc也是大同小异的。

当HSQL_STREAM_PROTOCOL版本号没有问题，程序中使用Result对客户端与服务端的数据进行抽象，也就是客户端请求为一个Result，服务端响应也是一个Result。对于客户端发来的数据，在服务端就是read操作，要发往客户端的数据，就是write操作。

点击(此处)折叠或打开

  1. Result resultIn = Result.newResult(dataInput, rowIn);

  3. resultIn.readAdditionalResults(session, dataInput, rowIn);

  5. Result resultOut;

  7. resultOut = setDatabase(resultIn);

  9. resultOut.write(session, dataOutput, rowOut);
先初始化Result对象，我们知道一个协议中包含很多命令（也就是很多种请求），如：连接、断开连接、执行sql语句，每个命令还包含相应的参数，如执行sql语句，就要把sql语句传过来）。我们接下来就看newResult中是怎么处理的：


点击(此处)折叠或打开

  1. private static Result newResult(Session session, DataInput dataInput,
  2.                                     RowInputBinary in,
  3.                                     int mode)
  4.                                     throws IOException, HsqlException {

  6.         Result result = newResult(mode);
  7.         int length = dataInput.readInt();

  9.         in.resetRow(0, length);

  11.         byte[] byteArray = in.getBuffer();
  12.         final int offset = 4;

  14.         dataInput.readFully(byteArray, offset, length - offset);

  16.         switch (mode) {

  18.             case ResultConstants.GETSESSIONATTR :
  19.                 result.statementReturnType = in.readByte();
  20.                 break;

  22.             case ResultConstants.DISCONNECT :
  23.             case ResultConstants.RESETSESSION :
  24.             case ResultConstants.STARTTRAN :
  25.                 break;

  27.             case ResultConstants.PREPARE :
  28.                 result.setStatementType(in.readByte());

  30.                 result.mainString = in.readString();
  31.                 result.rsProperties = in.readByte();
  32.                 result.generateKeys = in.readByte();

  34.                 if (result.generateKeys == ResultConstants
  35.                         .RETURN_GENERATED_KEYS_COL_NAMES || result
  36.                         .generateKeys == ResultConstants
  37.                         .RETURN_GENERATED_KEYS_COL_INDEXES) {
  38.                     result.generatedMetaData = new ResultMetaData(in);
  39.                 }
  40.                 break;

  42.             case ResultConstants.CLOSE_RESULT :
  43.                 result.id = in.readLong();
  44.                 break;

  46.             case ResultConstants.FREESTMT :
  47.                 result.statementID = in.readLong();
  48.                 break;

  50.             case ResultConstants.EXECDIRECT :
  51.                 result.updateCount = in.readInt();
  52.                 result.fetchSize = in.readInt();
  53.                 result.statementReturnType = in.readByte();
  54.                 result.mainString = in.readString();
  55.                 result.rsProperties = in.readByte();
  56.                 result.queryTimeout = in.readShort();
  57.                 result.generateKeys = in.readByte();

  59.                 if (result.generateKeys == ResultConstants
  60.                         .RETURN_GENERATED_KEYS_COL_NAMES || result
  61.                         .generateKeys == ResultConstants
  62.                         .RETURN_GENERATED_KEYS_COL_INDEXES) {
  63.                     result.generatedMetaData = new ResultMetaData(in);
  64.                 }
  65.                 break;

  67.             case ResultConstants.CONNECT :
  68.                 result.databaseName = in.readString();
  69.                 result.mainString = in.readString();
  70.                 result.subString = in.readString();
  71.                 result.zoneString = in.readString();
  72.                 result.updateCount = in.readInt();
  73.                 break;

  75.             case ResultConstants.ERROR :
  76.             case ResultConstants.WARNING :
  77.                 result.mainString = in.readString();
  78.                 result.subString = in.readString();
  79.                 result.errorCode = in.readInt();
  80.                 break;

  82.             case ResultConstants.CONNECTACKNOWLEDGE :
  83.                 result.databaseID = in.readInt();
  84.                 result.sessionID = in.readLong();
  85.                 result.databaseName = in.readString();
  86.                 result.mainString = in.readString();
  87.                 break;

  89.             case ResultConstants.UPDATECOUNT :
  90.                 result.updateCount = in.readInt();
  91.                 break;

  93.             case ResultConstants.ENDTRAN : {
  94.                 int type = in.readInt();

  96.                 result.setActionType(type); // endtran type

  98.                 switch (type) {

  100.                     case ResultConstants.TX_SAVEPOINT_NAME_RELEASE :
  101.                     case ResultConstants.TX_SAVEPOINT_NAME_ROLLBACK :
  102.                         result.mainString = in.readString(); // savepoint name
  103.                         break;

  105.                     case ResultConstants.TX_COMMIT :
  106.                     case ResultConstants.TX_ROLLBACK :
  107.                     case ResultConstants.TX_COMMIT_AND_CHAIN :
  108.                     case ResultConstants.TX_ROLLBACK_AND_CHAIN :
  109.                     case ResultConstants.PREPARECOMMIT :
  110.                         break;

  112.                     default :
  113.                         throw Error.runtimeError(ErrorCode.U_S0500, "Result");
  114.                 }

  116.                 break;
  117.             }
  118.             case ResultConstants.SETCONNECTATTR : {
  119.                 int type = in.readInt(); // attr type

  121.                 result.setConnectionAttrType(type);

  123.                 switch (type) {

  125.                     case ResultConstants.SQL_ATTR_SAVEPOINT_NAME :
  126.                         result.mainString = in.readString(); // savepoint name
  127.                         break;

  129.                     // case ResultConstants.SQL_ATTR_AUTO_IPD :
  130.                     // - always true
  131.                     // default: throw - case never happens
  132.                     default :
  133.                         throw Error.runtimeError(ErrorCode.U_S0500, "Result");
  134.                 }

  136.                 break;
  137.             }
  138.             case ResultConstants.PREPARE_ACK :
  139.                 result.statementReturnType = in.readByte();
  140.                 result.statementID = in.readLong();
  141.                 result.rsProperties = in.readByte();
  142.                 result.metaData = new ResultMetaData(in);
  143.                 result.parameterMetaData = new ResultMetaData(in);
  144.                 break;

  146.             case ResultConstants.CALL_RESPONSE :
  147.                 result.updateCount = in.readInt();
  148.                 result.fetchSize = in.readInt();
  149.                 result.statementID = in.readLong();
  150.                 result.statementReturnType = in.readByte();
  151.                 result.rsProperties = in.readByte();
  152.                 result.metaData = new ResultMetaData(in);
  153.                 result.valueData = readSimple(in, result.metaData);
  154.                 break;

  156.             case ResultConstants.EXECUTE :
  157.                 result.updateCount = in.readInt();
  158.                 result.fetchSize = in.readInt();
  159.                 result.statementID = in.readLong();
  160.                 result.rsProperties = in.readByte();
  161.                 result.queryTimeout = in.readShort();

  163.                 Statement statement =
  164.                     session.statementManager.getStatement(session,
  165.                         result.statementID);

  167.                 if (statement == null) {

  169.                     // invalid statement
  170.                     result.mode = ResultConstants.EXECUTE_INVALID;
  171.                     result.valueData = ValuePool.emptyObjectArray;

  173.                     break;
  174.                 }

  176.                 result.statement = statement;
  177.                 result.metaData = result.statement.getParametersMetaData();
  178.                 result.valueData = readSimple(in, result.metaData);
  179.                 break;

  181.             case ResultConstants.UPDATE_RESULT : {
  182.                 result.id = in.readLong();

  184.                 int type = in.readInt();

  186.                 result.setActionType(type);

  188.                 result.metaData = new ResultMetaData(in);
  189.                 result.valueData = readSimple(in, result.metaData);

  191.                 break;
  192.             }
  193.             case ResultConstants.BATCHEXECRESPONSE :
  194.             case ResultConstants.BATCHEXECUTE :
  195.             case ResultConstants.BATCHEXECDIRECT :
  196.             case ResultConstants.SETSESSIONATTR : {
  197.                 result.updateCount = in.readInt();
  198.                 result.fetchSize = in.readInt();
  199.                 result.statementID = in.readLong();
  200.                 result.queryTimeout = in.readShort();
  201.                 result.metaData = new ResultMetaData(in);

  203.                 result.navigator.readSimple(in, result.metaData);

  205.                 break;
  206.             }
  207.             case ResultConstants.PARAM_METADATA : {
  208.                 result.metaData = new ResultMetaData(in);

  210.                 result.navigator.read(in, result.metaData);

  212.                 break;
  213.             }
  214.             case ResultConstants.REQUESTDATA : {
  215.                 result.id = in.readLong();
  216.                 result.updateCount = in.readInt();
  217.                 result.fetchSize = in.readInt();

  219.                 break;
  220.             }
  221.             case ResultConstants.DATAHEAD :
  222.             case ResultConstants.DATA :
  223.             case ResultConstants.GENERATED : {
  224.                 result.id = in.readLong();
  225.                 result.updateCount = in.readInt();
  226.                 result.fetchSize = in.readInt();
  227.                 result.rsProperties = in.readByte();
  228.                 result.metaData = new ResultMetaData(in);
  229.                 result.navigator = new RowSetNavigatorClient();

  231.                 result.navigator.read(in, result.metaData);

  233.                 break;
  234.             }
  235.             case ResultConstants.DATAROWS : {
  236.                 result.metaData = new ResultMetaData(in);
  237.                 result.navigator = new RowSetNavigatorClient();

  239.                 result.navigator.read(in, result.metaData);

  241.                 break;
  242.             }
  243.             default :
  244.                 throw Error.runtimeError(ErrorCode.U_S0500, "Result");
  245.         }

  247.         return result;
  248.     }
在一个二进制内容的协议中，字节摆放的先后顺序是严格要求的，这点与一些字符串协议有着区别（如http中，"url?p1=&p2="，与"url?p2=&p1=" 在服务器上的处理并无任何区别)
在不同的命令（请求）中，协议严格规定了字节的先后摆放顺序，以prepare命令来说

点击(此处)折叠或打开

  1. case ResultConstants.PREPARE :
  2.                 result.setStatementType(in.readByte());

  4.                 result.mainString = in.readString();
  5.                 result.rsProperties = in.readByte();
  6.                 result.generateKeys = in.readByte();

  8.                 if (result.generateKeys == ResultConstants
  9.                         .RETURN_GENERATED_KEYS_COL_NAMES || result
  10.                         .generateKeys == ResultConstants
  11.                         .RETURN_GENERATED_KEYS_COL_INDEXES) {
  12.                     result.generatedMetaData = new ResultMetaData(in);
  13.                 }
  14.                 break;
在命令标识字节之后，第1个字节为statementType, 第2段为执行的sql语句，sql语句之后为rsProperties，后面依此类推。
in.readByte之类的，都很平常，不过是InputStream往前读了一个字节。
我们感兴趣的是readString，我们知道一个sql语句是不定长的，那么in.readString怎么知道该读多长的内容作为字符串呢？
进入到readString方法中一窥究竟

点击(此处)折叠或打开

  1. public String readString() throws IOException {

  3.         int length = readInt();
  4.         String s = StringConverter.readUTF(buffer, pos, length);

  6.         s = ValuePool.getString(s);
  7.         pos += length;

  9.         return s;
  10.     }
原来，对于每一个字符串，在其开头部分，先是放置一个int，告知后面字符串长度，然后接下来这么长的内容是字符串的内容。这在二进制协议中，对于不定长数据通常的一个手法。
这里还有一个ValuePool.getString方法，进入之后好像是做缓存计数器，具体做什么用，我还不清楚。

现在我们再回到上面init函数部分，看看

点击(此处)折叠或打开

  1. Result resultOut;

  3.                     resultOut = setDatabase(resultIn);

  5.                     resultOut.write(session, dataOutput, rowOut);
setDatabase是服务器端的处理，我们这里先略过，在这篇文章里，我们关注的是数据如何解析（上面已经知道），数据是如何返回的。
write函数如下：

点击(此处)折叠或打开

  1. public void write(SessionInterface session, DataOutputStream dataOut,
  2.                       RowOutputInterface rowOut)
  3.                       throws IOException, HsqlException {

  5.         rowOut.reset();
  6.         rowOut.writeByte(mode);

  8.         int startPos = rowOut.size();

  10.         rowOut.writeSize(0);

  12.         switch (mode) {

  14.             case ResultConstants.GETSESSIONATTR :
  15.                 rowOut.writeByte(statementReturnType);
  16.                 break;

  18.             case ResultConstants.DISCONNECT :
  19.             case ResultConstants.RESETSESSION :
  20.             case ResultConstants.STARTTRAN :
  21.                 break;

  23.             case ResultConstants.PREPARE :
  24.                 rowOut.writeByte(statementReturnType);
  25.                 rowOut.writeString(mainString);
  26.                 rowOut.writeByte(rsProperties);
  27.                 rowOut.writeByte(generateKeys);

  29.                 if (generateKeys == ResultConstants
  30.                         .RETURN_GENERATED_KEYS_COL_NAMES || generateKeys == ResultConstants
  31.                         .RETURN_GENERATED_KEYS_COL_INDEXES) {
  32.                     generatedMetaData.write(rowOut);
  33.                 }
  34.                 break;

  36.             case ResultConstants.FREESTMT :
  37.                 rowOut.writeLong(statementID);
  38.                 break;

  40.             case ResultConstants.CLOSE_RESULT :
  41.                 rowOut.writeLong(id);
  42.                 break;

  44.             case ResultConstants.EXECDIRECT :
  45.                 rowOut.writeInt(updateCount);
  46.                 rowOut.writeInt(fetchSize);
  47.                 rowOut.writeByte(statementReturnType);
  48.                 rowOut.writeString(mainString);
  49.                 rowOut.writeByte(rsProperties);
  50.                 rowOut.writeShort(queryTimeout);
  51.                 rowOut.writeByte(generateKeys);

  53.                 if (generateKeys == ResultConstants
  54.                         .RETURN_GENERATED_KEYS_COL_NAMES || generateKeys == ResultConstants
  55.                         .RETURN_GENERATED_KEYS_COL_INDEXES) {
  56.                     generatedMetaData.write(rowOut);
  57.                 }
  58.                 break;

  60.             case ResultConstants.CONNECT :
  61.                 rowOut.writeString(databaseName);
  62.                 rowOut.writeString(mainString);
  63.                 rowOut.writeString(subString);
  64.                 rowOut.writeString(zoneString);
  65.                 rowOut.writeInt(updateCount);
  66.                 break;

  68.             case ResultConstants.ERROR :
  69.             case ResultConstants.WARNING :
  70.                 rowOut.writeString(mainString);
  71.                 rowOut.writeString(subString);
  72.                 rowOut.writeInt(errorCode);
  73.                 break;

  75.             case ResultConstants.CONNECTACKNOWLEDGE :
  76.                 rowOut.writeInt(databaseID);
  77.                 rowOut.writeLong(sessionID);
  78.                 rowOut.writeString(databaseName);
  79.                 rowOut.writeString(mainString);
  80.                 break;

  82.             case ResultConstants.UPDATECOUNT :
  83.                 rowOut.writeInt(updateCount);
  84.                 break;

  86.             case ResultConstants.ENDTRAN : {
  87.                 int type = getActionType();

  89.                 rowOut.writeInt(type); // endtran type

  91.                 switch (type) {

  93.                     case ResultConstants.TX_SAVEPOINT_NAME_RELEASE :
  94.                     case ResultConstants.TX_SAVEPOINT_NAME_ROLLBACK :
  95.                         rowOut.writeString(mainString); // savepoint name
  96.                         break;

  98.                     case ResultConstants.TX_COMMIT :
  99.                     case ResultConstants.TX_ROLLBACK :
  100.                     case ResultConstants.TX_COMMIT_AND_CHAIN :
  101.                     case ResultConstants.TX_ROLLBACK_AND_CHAIN :
  102.                     case ResultConstants.PREPARECOMMIT :
  103.                         break;

  105.                     default :
  106.                         throw Error.runtimeError(ErrorCode.U_S0500, "Result");
  107.                 }

  109.                 break;
  110.             }
  111.             case ResultConstants.PREPARE_ACK :
  112.                 rowOut.writeByte(statementReturnType);
  113.                 rowOut.writeLong(statementID);
  114.                 rowOut.writeByte(rsProperties);
  115.                 metaData.write(rowOut);
  116.                 parameterMetaData.write(rowOut);
  117.                 break;

  119.             case ResultConstants.CALL_RESPONSE :
  120.                 rowOut.writeInt(updateCount);
  121.                 rowOut.writeInt(fetchSize);
  122.                 rowOut.writeLong(statementID);
  123.                 rowOut.writeByte(statementReturnType);
  124.                 rowOut.writeByte(rsProperties);
  125.                 metaData.write(rowOut);
  126.                 writeSimple(rowOut, metaData, (Object[]) valueData);
  127.                 break;

  129.             case ResultConstants.EXECUTE :
  130.                 rowOut.writeInt(updateCount);
  131.                 rowOut.writeInt(fetchSize);
  132.                 rowOut.writeLong(statementID);
  133.                 rowOut.writeByte(rsProperties);
  134.                 rowOut.writeShort(queryTimeout);
  135.                 writeSimple(rowOut, metaData, (Object[]) valueData);
  136.                 break;

  138.             case ResultConstants.UPDATE_RESULT :
  139.                 rowOut.writeLong(id);
  140.                 rowOut.writeInt(getActionType());
  141.                 metaData.write(rowOut);
  142.                 writeSimple(rowOut, metaData, (Object[]) valueData);
  143.                 break;

  145.             case ResultConstants.BATCHEXECRESPONSE :
  146.             case ResultConstants.BATCHEXECUTE :
  147.             case ResultConstants.BATCHEXECDIRECT :
  148.             case ResultConstants.SETSESSIONATTR : {
  149.                 rowOut.writeInt(updateCount);
  150.                 rowOut.writeInt(fetchSize);
  151.                 rowOut.writeLong(statementID);
  152.                 rowOut.writeShort(queryTimeout);
  153.                 metaData.write(rowOut);
  154.                 navigator.writeSimple(rowOut, metaData);

  156.                 break;
  157.             }
  158.             case ResultConstants.PARAM_METADATA : {
  159.                 metaData.write(rowOut);
  160.                 navigator.write(rowOut, metaData);

  162.                 break;
  163.             }
  164.             case ResultConstants.SETCONNECTATTR : {
  165.                 int type = getConnectionAttrType();

  167.                 rowOut.writeInt(type); // attr type / updateCount

  169.                 switch (type) {

  171.                     case ResultConstants.SQL_ATTR_SAVEPOINT_NAME :
  172.                         rowOut.writeString(mainString); // savepoint name
  173.                         break;

  175.                     // case ResultConstants.SQL_ATTR_AUTO_IPD // always true
  176.                     // default: // throw, but case never happens
  177.                     default :
  178.                         throw Error.runtimeError(ErrorCode.U_S0500, "Result");
  179.                 }

  181.                 break;
  182.             }
  183.             case ResultConstants.REQUESTDATA : {
  184.                 rowOut.writeLong(id);
  185.                 rowOut.writeInt(updateCount);
  186.                 rowOut.writeInt(fetchSize);

  188.                 break;
  189.             }
  190.             case ResultConstants.DATAROWS :
  191.                 metaData.write(rowOut);
  192.                 navigator.write(rowOut, metaData);
  193.                 break;

  195.             case ResultConstants.DATAHEAD :
  196.             case ResultConstants.DATA :
  197.             case ResultConstants.GENERATED :
  198.                 rowOut.writeLong(id);
  199.                 rowOut.writeInt(updateCount);
  200.                 rowOut.writeInt(fetchSize);
  201.                 rowOut.writeByte(rsProperties);
  202.                 metaData.write(rowOut);
  203.                 navigator.write(rowOut, metaData);
  204.                 break;

  206.             default :
  207.                 throw Error.runtimeError(ErrorCode.U_S0500, "Result");
  208.         }

  210.         rowOut.writeIntData(rowOut.size() - startPos, startPos);
  211.         dataOut.write(rowOut.getOutputStream().getBuffer(), 0, rowOut.size());

  213.         int count = getLobCount();
  214.         Result current = this;

  216.         for (int i = 0; i < count; i++) {
  217.             ResultLob lob = current.lobResults;

  219.             lob.writeBody(session, dataOut);

  221.             current = current.lobResults;
  222.         }

  224.         if (chainedResult == null) {
  225.             dataOut.writeByte(ResultConstants.NONE);
  226.         } else {
  227.             chainedResult.write(session, dataOut, rowOut);
  228.         }

  230.         dataOut.flush();
  231.     }
与newResult差不多，之前是逐个位置的读数据，现在是逐个位置的写入数据。跟不同的命令/请求需要用不同的读方法一样，写入内容时，也是根据命令/请求内容的不同，写入不同的数据。
writeByte之类的比较容易理解，我们这里同样关注一下writeString


点击(此处)折叠或打开

  1. public void writeString(String s) {

  3.         int temp = count;

  5.         writeInt(0);

  7.         if (s != null && s.length() != 0) {
  8.             StringConverter.stringToUTFBytes(s, this);
  9.             writeIntData(count - temp - INT_STORE_SIZE, temp);
  10.         }
  11.     }
这里先writeInt(0), 这个位置其实起到占位作用，因为这个位置本身需要写入字符串的长度。然后再写入字符串内容，之后再返回到长度的写入位置，写入真实的长度。

[总结]
至此，我们通过分析ServerConnection和Result，得知了HSQL_Stream_Protocol的解析和返回过程。作为二进制协议，在写代码之前是应该有文档规定的，文档的内容就是什么内容，存在协议的什么位置。当然，通过源代码，我们也可以逆推出文档。

协议解析出来了，处理之后也返回回去了，在它们之间存在一个处理过程，在下一篇文章中将对处理过程进行分析。

[相关源码文件]
ServerConnection.java
WebServerConnection.java
result目录（Result.java在此目录中）
rowio目录（字节读写就靠这个）

[思考]
命令/请求与回复/响应，都在Result里，是因为各种命令的参数信息、响应的返回的内容，基本类似，如果各种命令的参数差别极大（比如一个命令有100项参数信息，另一个命令只有1项参数），这样的情况下，都放在Result里还合适吗？或者，阅读源码，在Result能找到处理办法吗？
阅读(4198) | 评论(0) | 转发(0) |
0

上一篇：没有了

下一篇：HSQLDB源码阅读 （三）命令的处理

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6