Socket的輸入字節流包裝在兩種不同的流類型中？

Question

我想實現這樣的協議：

 
Client side: 
1) client sends  command (String) 
2) client sends  object 
3) client receives object or data [depends on command] 
Server side: 
1) server reads  command (String) 
2) server receives object   [type depends on command] 
3) server sends  object or data [depends on command] 

在客戶端，我在做這樣的事情（在線程序塊，上面標有「！」）：

/** Retrieves required wrapper streams */ 
private void getSocketStreams() { 
    try { 
     inputStream   = new DataInputStream(
            connection.getInputStream()); 

     /* !!! here is a problem: can I do next line's stuff? */ 
     inputObjectStream = new ObjectInputStream(
            connection.getInputStream()); 

     outputWriter  = new BufferedWriter(
           new OutputStreamWriter(
            connection.getOutputStream())); 
     outputObjectStream = new ObjectOutputStream(
            connection.getOutputStream()); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
} 

/** "put" command processor */ 
private int processCmdPut(OrderInfo orderInfo) { 

    /* Send command to peer */ 
    try { 
     outputWriter.write("put"); 
     outputWriter.newLine(); 
     outputWriter.flush(); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 

    /* Send inserted object to peer */ 
    sendObject(orderInfo); 

    /* Get from peer inserted info id */ 
    int id = -1; 
    try { 
     id = inputStream.readInt(); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
    return id; 
} 


/** 
* Sends object to peer. 
* @param obj object to send. 
*/ 
public void sendObject(Object obj){ 
    try { 
     outputObjectStream.writeObject(obj); 
     outputObjectStream.flush(); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
} 

服務器端操作鏡像客戶端。

有關線的問題，用「!!!」標記：是否可以用兩個不同的高槓杆流對套接字的字節流 進行包裝並逐個（逐個）讀/寫？ 我錯了嗎？有我的錯誤或誤解？

Answer 1

緩衝往往是在最好的使用不同的裝飾鏈很難做出。你真的不想在同一個流上混合文本和二進制數據。我建議用與二進制數據相同的格式編寫文本。

Answer 2

這裏是服務器端的代碼，以防萬一：

/** Retrieves required wrapper streams */ 
private void getSocketStreams() { 
    try { 
     inputReader   = new BufferedReader(
           new InputStreamReader(
            clientSocket.getInputStream())); 
     inputObjectStream = new ObjectInputStream(
            clientSocket.getInputStream()); 
     outputStream  = new DataOutputStream(
            clientSocket.getOutputStream()); 
     outputObjectStream = new ObjectOutputStream(
            clientSocket.getOutputStream()); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
} 

/** 
* Process distinct command from client. 
* @param cmd command to process 
* @return connection state flag. 
*/ 
private boolean processCmd(String cmd) { 
    if ("put".equals(cmd)) { 
     System.out.println(cmd); 
     processCmdPut(); 
    } else if ("bye".equals(cmd)) { 
     System.out.println(cmd); 
     return false; 
    } 
    return true; 
} 

/** "put" command processor */ 
private void processCmdPut() { 

    /* Reciever from a peer an object to put into data source */ 
    OrderInfo orderInfo = (OrderInfo) receiveObject(); 

    /* Put recieved object into a data source */ 
    int id = ordersService.put(orderInfo); 

    /* Send to peer inserted data id */ 
    try { 
     outputStream.writeInt(id); 
     outputStream.flush(); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
} 

/** 
* Recieves an object from peer. 
* @return recieved object, or <tt>null</tt> on error. 
*/ 
public Object receiveObject() { 
    Object res = null; 
    try { 
     res = inputObjectStream.readObject(); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } catch (ClassNotFoundException e) { 
     e.printStackTrace(); 
    } 
    return res; 
}