Le flux d'octets d'entrée de socket est-il enveloppé dans deux types de flux différents?

Question

Je suis en train de mettre en œuvre un tel protocole:

 
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] 

côté client, je fais quelque chose comme ça (blocs de programme en ligne, marquée par « !!! »):

/** 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(); 
    } 
} 

Le côté serveur agit sur un client en miroir.

La question à propos de la ligne, marquée par "!!!": est-il possible d'encapsuler le flux d'octets du socket avec deux flux différents à haut levier et de les lire/écrire tour à tour (un par un)? Ai-je tort? Il y a mon erreur ou mon malentendu?

Answer 1

Buffering a tendance à faire en utilisant différentes chaînes de décorateurs au mieux difficiles. Vous ne voulez vraiment pas mélanger du texte et des données binaires sur le même flux. Je suggère d'écrire du texte dans le même format que vous utilisez pour les données binaires.

Answer 2

code côté serveur est de Ici, juste au cas où:

/** 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; 
}