Chi mi aiuta con i ServerSocket (JAVA)?

[pushermad]

Ciao a tutti.
Sto facendo esercitazione sui socket per l'università e non riesco a capire dove sta il problema...
Uso: ubuntu 12.04 x64, netbeans 7.0.1, e jdk 1.7
Ho implementato un server e un client con i socket stream (TCP) in java, la comunicazione permette l'invio di stringhe.
Il server usa i thread per poter accettare più connessioni contemporaneamente, ma anche nella versione semplice presenta lo stesso problema.
La comunicazione che voglio realizzare deve permettere l'invio di tre stringhe con le seguenti direzioni:
> Comunicazione 1: server-client
> Comunicazione 2: client-server
> Comunicazione 3: server-client
(NOTA: chiamo client-server un messaggio che va dal client al server. Mentre chiamo server-client se va dal server al client.)

IL PROBLEMA: essenzialmente, dopo una comunicazione client-server non riesco ad effettuare una comunicazione server-client; ed il client resta in attesa di una stringa.

MIEI TEST:
- se effettuo solo comunicazioni unidirezionali (solo client-server oppure solo server-client), tutto funziona.
- se effettuo prima delle comunicazioni server-client e dopo delle client-server (sempre nella stessa comunicazione), tutto funziona.
..... (per fare questo test, basta commentare nel codice le righe che effettuano la "Comunicazione 3" sia nel server che nel client).
- se effettuo il viceversa, ovvero prima delle comunicazioni client-server e dopo server-client, il server riceve la stringa dal client ma il client non riceve più risposte dal server.
..... (per fare questo test, basta semplicemente eseguire il codice del server e del client scritti di seguito...)

DOMANDE:
- i socket stream sono bidirezionali.... perchè a me non funzionano? :|

Il codice server:

/* SERVER */
import java.io.*;
import java.net.*;

public class es_serverMT
{
ServerSocket server;

public es_serverMT(int port)
    {
    try {
        // creazione ServerSocket
        server = new ServerSocket(port);
        System.out.println("Server creato con successo!");
        }
    catch (IOException ex)
        { ex.printStackTrace(); }
    }

public void runServer()
    {
    while (true)    //ciclo infinito
        {
        System.out.println("Server in attesa di connessioni...");
        try {// Impostiamo il server in ascolto per accettare le chiamate Client.
            Socket socket = server.accept();
            System.out.println("Un client si è connesso...");
            
            serverMT process = new serverMT(socket);
            }
        catch (IOException ex)    {  ex.printStackTrace();  }
        }
    }

/* SUB-CLASSE che estende la classe Thread */
public class serverMT extends Thread
    {
    private Socket socket; //socket di connessione con il client
    private BufferedReader in; //stream di input
    private PrintWriter out; //stream di output
    
    /* Il costruttore */
    public serverMT(Socket socket) throws IOException
        {
        this.socket = socket;
        in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),true);
        this.start();         // start(), manda il thread in esecuzione;
        }
    
    /* Metodo per la gestione del servizio, chiamata a seguito di this.start(). */
    public void run()
        {
        try {
            System.out.println("Inizio trasferimeto... " );
            
            
            
            /* Comunicazione 1: invio al client il messaggio "msg1" */
            out.println("msg1");         System.out.println(">Spedito: msg1");
            
            /* Comunicazione 2: ricevo dal client il messaggio "msg2" */
            System.out.println("<Ricevuto: " + in.readLine() );
            
            /* Comunicazione 3: invio al client il messaggio "msg3" */
            out.println("msg3");         System.out.println(">Spedito: msg3");
            
            
            
            System.out.println("Fine trasferimento!");
            out.close();
            socket.close();
            }
        catch(IOException e)    {  System.out.println("Errore..");  }
        
        System.out.println("Thread terminato.");
        }
    }//// END CLASS serverMT ///
    
public static void main (String[] args)
    {
    es_serverMT ss = new es_serverMT(9999);
    ss.runServer();
    }
}

Il codice client:

/* CLIENT */
import java.io.*;
import java.net.*;

public class es_clientMT
{
public static void main(String args[])
    {
    try {
        // Apre una connessione verso un server in ascolto sulla porta 9999.
        System.out.println("Apertura connessione…");
        Socket socket = new Socket ("127.0.0.1", 9999);
        BufferedReader is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        BufferedWriter os = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        PrintWriter out = new PrintWriter(os);
        
        System.out.println("Inizio trasferimeto... " );
        
        
        
        /* Comunicazione 1: ricevo dal server il messaggio "msg1" */
        System.out.println("<Ricevuto: " + is.readLine() );
        
        /* Comunicazione 2: invio al server il messaggio "msg2" */
        out.println("msg2");        System.out.println(">Spedito: msg2");
        
        /* Comunicazione 3: ricevo dal server il messaggio "msg3" */
        System.out.println("<Ricevuto: " + is.readLine() );
        
        
        
        System.out.println("Fine trasferimento!");
        
        // Chiudo gli stream di comunicazione e l'oggetto socket.
        out.close();
        socket.close();
        }
    catch (ConnectException connExc)    { System.err.println("Errore.."); }
    catch (IOException ex)    { ex.printStackTrace(); }
    System.out.println("Chiusura connessione effettuata.");
    }
}

[c0der]

Niente di che, è solo che sul client devi modificare questa linea:
PrintWriter out = new PrintWriter(os);
con
PrintWriter out = new PrintWriter(os, true);
in modo da abilitare l'autoflush, come avevi fatto correttamente sul server.

Oppure avresti dovuto aggiungere: out.flush() dopo la out.println()

Ciao.

[pushermad]

Perfetto funziona! Grazie mille.
E' da un paio di giorni che provavo senza trovare il problema.

Ho provato out.flush() in diversi modi ma senza risultato. Pensavo servisse per liberare il canale di comunicazione quindi lo mettevo prima di out.println(). Perchè va messo dopo?

Un'altra cosa visto che ci sono; "BufferedReader in" e "PrintWriter out " vanno chiusi obbligatoriamente con in.close() e out.close() come avviene per socket.close()? Se si, sia nel server che nel client?



NB: Faccio le mie scuse a tutti nel forum per i post ripetuti, ho cercato di rimediare nel mio possibile.

[c0der]

Il metodo flush serve per svuotare il buffer di scrittura (tu usi infatti dei BufferedWriter).
Altrimenti java svuoterebbe il buffer quando è pieno, come ottimizzazione interna.

Siccome tu ti metti poi a fare una read() allora il flush lo devi fare esplicitamente (ovvimente dopo la println),
o settare il flag autoflash sull'oggetto PrintWriter.

Riguardo ai reader/writer sì vanno chiusi e poi chiudi il socket,
vedi per esempio qui:
http://docs.oracle.com/javase/tutori...ngWriting.html

Ciao.

[pushermad]

Grazie c0der, tutto chiarissimo.
Sei stato di grande aiuto.