/** 
 * 全局MVB數(shù)據(jù)緩沖區(qū) 占用 1M 內(nèi)存 
 */ 
private static ByteBuffer bbuf = ByteBuffer.allocate(10240); 
 
/** 
 * 線程安全的取得緩沖變量 
 */ 
public static synchronized ByteBuffer getByteBuffer() { 
  return bbuf; 
} 

public void run() { 
  Socket socket = GlobalClientKeep.mvbSocket; 
  if (null != socket) { 
    try { 
      // 獲得mvb連接引用 
      OutputStream ops = socket.getOutputStream(); 
      InputStream ips = socket.getInputStream(); 
      while (true) { 
        if (null != ops && null != ips) { 
          // 接收返回信息 
          byte[] bt = StreamTool.inputStreamToByte(ips); 
          ByteBuffer bbuf = GlobalCommonObjectKeep.getByteBuffer(); 
          // 設置到緩沖區(qū)中 
          bbuf.put(bt); 
          // //////////////////////////////////////////////////////////////////////// 
          // 拆包解析方法 
          splitByte(ops); 
          ops.flush(); 
        } 
      } 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
  } else { 
    // 如果連接存在問題，則必須重新建立 
    GlobalClientKeep.initMvbSocket(); 
  } 
} 

/** 
 * @說明 拆包解析方法 
 */ 
public static void splitByte(OutputStream ops) { 
  try { 
    ByteBuffer bbuf = GlobalCommonObjectKeep.getByteBuffer(); 
    int p = bbuf.position(); 
    int l = bbuf.limit(); 
    // 回繞緩沖區(qū) 一是將 curPointer 移到 0, 二是將 endPointer 移到有效數(shù)據(jù)結(jié)尾 
    bbuf.flip(); 
    byte[] byten = new byte[bbuf.limit()]; // 可用的字節(jié)數(shù)量 
    bbuf.get(byten, bbuf.position(), bbuf.limit()); // 得到目前為止緩沖區(qū)所有的數(shù)據(jù) 
    // 進行基本檢查，保證已經(jīng)包含了一組數(shù)據(jù) 
    if (checkByte(byten)) { 
      byte[] len = new byte[4]; 
      // 數(shù)組源，數(shù)組源拷貝的開始位子，目標，目標填寫的開始位子，拷貝的長度 
      System.arraycopy(byten, 0, len, 0, 4); 
      int length = StreamTool.bytesToInt(len); // 每個字節(jié)流的最開始肯定是定義本條數(shù)據(jù)的長度 
      byte[] deco = new byte[length]; // deco 就是這條數(shù)據(jù)體 
      System.arraycopy(byten, 0, deco, 0, length); 
      // 判斷消息類型，這個應該是從 deco 中解析了，但是下面具體的解析內(nèi)容不再啰嗦 
      int type = 0; 
      // 判斷類型分類操作 
      if (type == 1) { 
         
      } else if (type == 2) { 
         
      } else if (type == 3) { 
         
      } else { 
        System.out.println("未知的消息類型，解析結(jié)束！"); 
        // 清空緩存 
        bbuf.clear(); 
      } 
      // 如果字節(jié)流是多余一組數(shù)據(jù)則遞歸 
      if (byten.length > length) { 
        byte[] temp = new byte[bbuf.limit() - length]; 
        // 數(shù)組源，數(shù)組源拷貝的開始位子，目標，目標填寫的開始位子，拷貝的長度 
        System.arraycopy(byten, length, temp, 0, bbuf.limit() - length); 
        // 情況緩存 
        bbuf.clear(); 
        // 重新定義緩存 
        bbuf.put(temp); 
        // 遞歸回調(diào) 
        splitByte(ops); 
      }else if(byten.length == length){ // 如果只有一條數(shù)據(jù)，則直接重置緩沖就可以了 
        // 清空緩存 
        bbuf.clear(); 
      } 
    } else { 
      // 如果沒有符合格式包含數(shù)據(jù)，則還原緩沖變量屬性 
      bbuf.position(p); 
      bbuf.limit(l); 
    } 
  } catch (Exception e) { 
    e.printStackTrace(); 
  } 
} 

  /**
   * Flips this buffer. The limit is set to the current position and then
   * the position is set to zero. If the mark is defined then it is
   * discarded.
   *
   * <p> After a sequence of channel-read or <i>put</i> operations, invoke
   * this method to prepare for a sequence of channel-write or relative
   * <i>get</i> operations. For example:
   *
   * <blockquote><pre>
   * buf.put(magic);  // Prepend header
   * in.read(buf);   // Read data into rest of buffer
   * buf.flip();    // Flip buffer
   * out.write(buf);  // Write header + data to channel</pre></blockquote>
   *
   * <p> This method is often used in conjunction with the {@link
   * java.nio.ByteBuffer#compact compact} method when transferring data from
   * one place to another. </p>
   *
   * @return This buffer
   */
  public final Buffer flip() {
	limit = position;
	position = 0;
	mark = -1;
	return this;
  }