Chat. Si ha un server in ascolto sulla porta Quando un client richiede la connessione, il server risponde con: Connessione accettata.

Transcript

1 Chat Si ha un server in ascolto sulla porta 4444 Quando un client richiede la connessione, il server risponde con: Connessione accettata. Nome: Il client deve rispondere con lo user name A questo punto ha inizio la comunicazione Chat/2 Funzionamento del client (verso il server): Legge una stringa dallo standard I/O Invia la stringa letta al server Funzionamento del client (ricezione): Se il messaggio ricevuto dal server è "Closing connection... allora il client deve chiudere la connessione Altrimenti, stampa il messaggio Chiusura della connessione (client): Avviene quando viene letto Bye. dallo standard I/O Il server risponde con Closing connection... Alla ricezione di questo messaggio il client deve abbattere la connessione

2 Chat/3 Funzionamento del server (nuova connessione): Il server risponde con il messaggio "Connessione accettata. Nome utente: Il server attende che il client risponda con il nome del nuovo utente Funzionamento del server (ricezione): Un messaggio ricevuto da un client è spedito in broadcast a tutti i client connessi Formato del messaggio trasmesso: Verso il client da cui proviene l originale (eco): il messaggio è uguale a quello ricevuto Verso gli altri client: > Da <Nome>: <Messaggio> Chat/4 Funzionamento del server (abbattimento di connessione): Avviene quando il messaggio ricevuto è Bye. Il server: 1. Risponde in broadcast con "leaving chat... (stesse modalità di prima) 2. Risponde (solo al client che chiude la connessione) con "Closing connection... Dopo aver fatto quanto sopra, il server chiude la propria estremità della connessione

3 Architettura del sistema Dati connessioni Client 1 Client 2 Server Client n-1 Client n Architettura del server Quando arriva una richiesta crea un nuovo thread per servirla Il nuovo thread si occupa di tutto public class ChatServer {... ServerSocket listensocket = new ServerSocket(4444); while (true) { Socket clientsocket = listensocket.accept(); /* Avvia_nuovo_thread(clientSocket) */

4 Architettura del server/2 1. Conn. Req. Nuovo Client Server 3. Dialogo public class ChatServer {.../* chatserver è un oggetto ChatServer */ ServerSocket listensocket = new ServerSocket(4444); while (true) { 2. Crea nuovo ClientHandler Socket clientsocket = listensocket.accept(); new Thread((new ClientHandler(clientSocket,...))).start(); Runnable Nuovo ClientHandler ClientHandler Ogni oggetto ClientHandler gestisce la connessione con un client diverso (per questo la classe è Runnable) Il generico oggetto ClientHandler: 1. Ricevuto il socket verso il client, crea gli stream relativi 2. Finché non riceve Bye. dal client: riceve i messaggi del client e ne fa il broadcast verso gli altri client 3. Quando riceve il messaggio Bye. si occupa di abbattere la connessione (chiudere stream, socket, ecc.)

5 ClientHandler/2 public class ClientHandler implements Runnable {... /* riceve connsocket come parametro */ /* Inizializzazioni*/... in = new BufferedReader(new InputStreamReader(connSocket.getInputStream())); out = new PrintWriter(connSocket.getOutputStream(), true); out.println("connessione accettata. Nome utente: "); username = in.readline(); /* Registra il nuovo client presso il server*/ outmessage = in.readline(); while (!(outmessage.equals("bye."))) { messagebroadcast(outmessage); /* Invia a tutti gli altri client */ outmessage = in.readline(); /* End while è stato ricevuto Bye. */ messagebroadcast("leaving chat..."); out.println("closing connection..."); /* Rimuovi il client dall elenco di quelli registrati presso il server*/... 1 run() ClientHandler/3 public class ClientHandler implements Runnable { /* Variabili istanza*/ public ClientHandler(Socket clientsocket,...) { connsocket = clientsocket;... public void run() { 1... public void messagebroadcast(string outmessage) { int numclient; Connection nextconn = null; 2 run() numclient = /* Determina no. Client registrati */ for (int i = 0; i < numclient; i++) { if (i-esimo client == client servito da this) out[i].println(outmessage); /* Echo */ else out[i].println("> Da " + clientconn.username + ": " + outmessage);...

6 Problemi da risolvere - Server 1. Come gestire le connessioni Quali informazioni servono Dove sono memorizzate 2. Quali parametri la classe ChatServer passa al costruttore di ClientHandler Dipende dalle scelte fatte al punto 1 3. Implementazione di ChatServer 4. Implementazione di ClientHandler Gestione delle connessioni class Connection { Socket connsocket; PrintWriter out; BufferedReader in; String username; public Connection(Socket connsocket, PrintWriter out, BufferedReader in, String username) { this.connsocket = connsocket; this.out = out; this.in = in; this.username = username; public class ChatServer { private static Vector connvector;... Si definisce una classe Connection, che rappresenta la connessione con il generico client L oggetto ChatServer mantiene un vettore privato connvector, che implementa la lista delle connessioni attive Gli oggetti ClientHandler accedono a connvector attraverso metodi pubblici di ChatServer Nota: sono possibili altre scelte implementative

7 Gestione delle connessioni/2 public class ChatServer { private static Vector connvector;... public void addconn(connection newconn) { connvector.addelement(newconn); public void remconn(connection deadconn) { connvector.remove(deadconn); public Connection getconn(int i) { return (Connection) connvector.elementat(i); public int getconnnumber() { return connvector.size();... 3 Servono metodi per: Aggiungere una nuova connessione Eliminare una connessione Dato i, accedere all iesima connessione Conoscere il no. di connessioni attive La connessione è abbattuta dal ClientHandler Riassunto delle classi - Server ChatServer ClientHandler Connection

8 public class ChatServer { ChatServer Impl. private static Vector connvector; public ChatServer() { connvector = new Vector(); 3 /* Metodi per accedere e modificare connvector */ public static void main(string args[]) { System.out.println("Server is coming up..."); ChatServer chatserver = new ChatServer(); try { ServerSocket listensocket = new ServerSocket(4444); while (true) { Socket clientsocket = listensocket.accept(); new Thread((new ClientHandler(clientSocket, chatserver))).start(); catch(ioexception e) { ClientHandler Impl. public class ClientHandler implements Runnable { Connection clientconn; ChatServer server; public ClientHandler(Socket clientsocket, ChatServer server) { clientconn = new Connection(null, null, null, null); clientconn.connsocket = clientsocket; this.server = server; public void messagebroadcast(string outmessage) { 4 /* Vedi */ public void run() { 5 /* Vedi */

9 ClientHandler Impl./2 public void run() { String outmessage; try { clientconn.in = new BufferedReader(new InputStreamReader(clientConn.connSocket.getInputStream())); clientconn.out = new PrintWriter(clientConn.connSocket.getOutputStream(), true); clientconn.out.println("connessione accettata. Nome utente: "); clientconn.username = clientconn.in.readline(); server.addconn(clientconn); outmessage = clientconn.in.readline(); while (!(outmessage.equals("bye."))) { messagebroadcast(outmessage); outmessage = clientconn.in.readline(); messagebroadcast("leaving chat..."); clientconn.out.println("closing connection..."); clientconn.in.close(); clientconn.out.close(); clientconn.connsocket.close(); server.remconn(clientconn); catch (IOException e) { 5 ClientHandler Impl./3 public void messagebroadcast(string outmessage) { int numclient; Connection nextconn = null; numclient = server.getconnnumber(); for (int i = 0; i < numclient; i++) { nextconn = server.getconn(i); if (clientconn.equals(nextconn)) else clientconn.out.println(outmessage); nextconn.out.println("> Da " + clientconn.username + ": " + outmessage); 4

10 ChatClient Il client deve: 1. Leggere dallo standard Input 2. Scrivere quanto letto sul socket 3. Contemporaneamente: il client deve ricevere i messaggi che arrivano dal ClientHandler e stamparli su standard Output Servono due thread per il client: Il primo legge da standard Input e scrive sul socket Il secondo riceve e scrive su standard Output public class ChatClient { ChatClient/2 public static void main(string[] args) throws IOException {... chatsocket = new Socket("localhost", 4444); out = new PrintWriter(chatSocket.getOutputStream(), true); in = new BufferedReader(new InputStreamReader(chatSocket.getInputStream())); BufferedReader stdin = new BufferedReader( new InputStreamReader(System.in)); /* Registrazione */ /* Crea un thread in ascolto */ while (!(userinput = stdin.readline()).equals("bye.")) out.println(userinput); out.println(userinput); /* Chiusura */ 7 6

11 ChatClient/3 public static void main(string[] args) throws IOException {... Runnable Thread recthread = new Thread(new myreceiver(chatsocket, in)); 6 recthread.start(); while (!(userinput = stdin.readline()).equals("bye.")) out.println(userinput); out.println(userinput); try { recthread.join(); catch (InterruptedException e) { 7 in.close(); out.close(); chatsocket.close(); stdin.close(); ChatClient/4 class myreceiver implements Runnable { BufferedReader in; Socket chatsocket; public myreceiver(socket chatsocket, BufferedReader in) { this.chatsocket = chatsocket; this.in = in; public void run() { String fromother = null; try { fromother = in.readline(); while(!(fromother.equals("closing connection..."))) { System.out.println(fromOther); fromother = in.readline(); System.out.println(fromOther); catch(ioexception e) {