Newsgroup: it.comp.java
Titolo: Semplice sistema client-server

Sto facendo alcune prove di semplici sistemi client-server (come dicevo in un
messaggio poco piu' sotto...)
Riesco a stabilire con successo una connessione tra server e 3 client: tutti in
localhost per le prove.
Nella parte client, ognuno dei client costruisce, appena ottenuto il socket, uno
stream cosi':
output = new PrintWriter(new OutputStreamWriter(theSocket.getOutputStream()));
(ovviamente theSocket e' il socket creato, ed ovviamente nessuna eccezione viene
sollevata)
quindi vi scrivono una stringa cosi':
output.println(s);
(dove s e' sempre la stringa).
Che la stringa esista e che si arrivi e superi questa parte di codice sono
sicuro.
Dalla parte server, sempre una volta ottenuta la connessione, ottengo lo stream
di input cosi':
input = new InputStreamReader(s.getInputStream());
e quindi controllo che sia arrivato qualcosa con "input.ready()".
Sbaglio qualcosa concettualmente fino a qui? Spero sia cosi', perche' altrimenti
non riesco a capire il motivo del fatto che vengono spediti dati ma questi non
vengono mai ricevuti dall'altro socket... :-/
Esistono forse problematiche particolari legate all'iterazione tra Thread e
Socket per quanto riguardo Java? Ricordo dei vecchi issue del vc++ ad esempio
riguardo al fatto che bisognava fare dei giri strani quando si passava un socket
da uno thread all'altro per mantenerlo valido... Qui l'unica cosa che mi e'
venuta in mente e' che, essendo desincronizzati le chiamate ai metodi per
mandare messaggi e la loro effettiva spedizione, fosse quello il problema... ma
un po' di debug mi ha rivelato che cosi' non e'...
mah... :P
PS: se un'eccezione viene lanciata da uno thread che non e' il main, e non viene
catchata, dove se ne va a finire? 8-)
--
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Mattia "The Killer" Belletti --- Student in Computer Science @ unibo
 Mail address: 
mbel...@cs.unibo.it
 --- Spam not allowed!!! :)
 ICQ: 33292311 --- IRC nickname: BluShine
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 catchata, dove se ne va a finire? 8-)
Risale tutta la catena di Thread fino alla VM che ricevuta l'eccezione
termina il programma segnalando la StackTrace.

output = new PrintWriter(new OutputStreamWriter(theSocket.getOutputStream()));
per sicurezza prova a mettere:
	output=new PrintWriter(theSocket.getOutputStream(),true);
che setta l'autoflush a true (ah, l'OutputStreamWriter intermedio mi
sembra inutile...).
HTH,
Mauri.
-- 
La forza di gravitą č un falso mito,
č la Terra che succhia!

messaggio poco piu' sotto...)
[DiscardClient.java]
import java.io.*;
import java.net.*;
public class DiscardClient
{
	public static void main(String[] args)throws Exception
	{
		BufferedReader console=new BufferedReader
			(new InputStreamReader(System.in));
		Socket sock=new Socket("localhost",4444);
		PrintWriter out=new PrintWriter
			(sock.getOutputStream(),true);
		String line="";
		while((line=console.readLine())!=null)
			out.println(line);
	}
}
[DiscardServer.java]
import java.io.*;
import java.net.*;
public class DiscardServer extends Thread
{
	Socket sock;
 
	public DiscardServer(Socket sock)
	{
		this.sock=sock;
		this.start();
	}
 
	public void run()
	{
		String line="";
		try
		{
			BufferedReader in=new BufferedReader(new
InputStreamReader(sock.getInputStream()));
			while((line=in.readLine())!=null)
				System.out.println(line);
		}
		catch(IOException e){}
	}
	public static void main(String[] args)throws Exception
	{
		ServerSocket serv=new ServerSocket(4444);
		while(true)
			new DiscardServer(serv.accept());
	}
}
HTH,
Mauri.
-- 
La forza di gravità è un falso mito,
è la Terra che succhia!

hai provato a flushare il buffer di uscita (il printWriter) dopo aver scitto
la stringa??
credo che anche con l'autoflush a true non venga fatto prima che la socket
venga chiusa.
ciao
--
carloni nico
"without stress my life would be empty"

 System.out.println(line);
La socket viene attivata, cerca di leggere il flusso dati, non trova niente,
esce dal ciclo senza aspettare i dati in arrivo.
anche qui metterei:
while(true)
{
 if((line=in.readLine())!=null) System.out.println(line);
}

}
Idem come sopra, e anche qui la strategia del buffer mi sembra sensata
per non tentare di inviare un pacchetto per ogni carattere...
Provare per credere, leggere la documentazione per capire.
Ciao,


venga chiusa.
Se chiami println() parte immediatamente, provare per credere.
Ciao,
Mauri.
-- 
La forza di gravitŕ č un falso mito,
