[JAVA] Problema di lettura/scrittura oggetti tramite Socket

[Giobbo]

Ciao a tutti.
Vado subito al sodo.
Sto effettuando delle prove per capire al meglio il funzionamento di Socket, ServerSocket, pattern Proxy e Skeleton e scrittura/lettura di oggetti.
Ma ho un problema che non riesco a risolvere (fondamentalmente perché non lo riesco a capire).
Innanzitutto metto subito le classi.

MainClient (che è banalmente il main del client che avvia il proxy e crea l'oggetto da inviare). Banalmente, l'oggetto è formato da due stringhe:


public class MainClient {

public static void main(String [] args) throws Exception {
System.out.println("CLIENT: ciao sono il client");
User user = new User ("Giobbo", "password");
Proxy proxy = new Proxy();
proxy.printUser(user);
}
}

Proxy, che è la classe che si occupa di creare la connessione con il server (o meglio, lo Skeleton):


import java.io.*;
import java.net.*;

public class Proxy implements ServerInterface {

private Socket socket;
private ObjectInputStream ois;
private ObjectOutputStream oos;

public Proxy() throws Exception {
InetAddress addr = InetAddress.getByName(null);
socket = new Socket(addr , ServerInterface.PORT);
System.out.println("PROXY: creazione fatta");
ois = new ObjectInputStream(socket.getInputStream());
oos = new ObjectOutputStream (socket.getOutputStream());
}

@Override
public void printUser(User user) throws IOException {
oos.writeObject(user);
oos.close();
this.close();
System.out.println("PROXY: Chiudo connessione con server");
}

public void close() throws IOException {
this.socket.close();
}
}

MainServer, che è il main per lanciare il server:

import java.net.*;

public class MainServer {

public static void main(String[] args) throws Exception {
ServerSocket server_socket = new ServerSocket(ServerInterface.PORT);
System.out.println("Server socket avviato: " + server_socket);

while(true) {
System.out.println ("In attesa di una connessione...");
Socket socket = server_socket.accept();
System.out.println("Socket connesso: " + socket);
new Thread(new Skeleton(socket)).start();
}
}
}

Skeleton, che è chiaro cosa fa dal nome:


import java.io.*;
import java.net.*;

public class Skeleton implements ServerInterface, Runnable {

private Socket socket;
private ObjectInputStream ois;
private ObjectOutputStream oos;

private Server server = new Server() ;

public Skeleton(Socket socket) throws IOException {
this.socket = socket;
System.out.println("SKELETON: creazione skeleton fatta");
ois = new ObjectInputStream(socket.getInputStream());
System.out.println("SKELETON: creazione skeleton fatta");
oos = new ObjectOutputStream (socket.getOutputStream());
}

public void run() {
try {
while(!this.socket.isClosed()) {
User user = (User) ois.readObject();
this.printUser(user);
this.close();
}
} catch(Exception e) {
e.printStackTrace();
try {
this.socket.close();
} catch(IOException e2) {
System.err.println("Chiusura socket fallita...");
}
}
}

@Override
public void printUser(User user) throws IOException {
server.printUser(user);
}

public void close() throws IOException {
this.socket.close();
}

}

Server, che è la classe che modella il server reale che fornisce il servizio (che qui banalmente è stampare i campi dell'oggetto inviato):


public class Server implements ServerInterface{

@Override
public void printUser(User user/*String str*/) throws IOException {
System.out.println("Ciao, sono il SERVER. Mi hai inviato questi dati...");
System.out.println("FaceID: " + user.getFaceId());
System.out.println("Password: " + user.getPassword());
}

}

Infine la semplice interfaccia che fornisce i metodi alle classi Proxy, Skeleton e Server (oltre alla costante PORT per creare ServerSocket e Socket):


import java.io.*;

public interface ServerInterface {

public static final int PORT = 8080;

public void printUser(User user /*String str*/) throws IOException;

}


Bene.
Il tutto funziona perfettamente se al posto dell'oggetto User invio dal client al server una semplice stringa (modificando opportunamente gli Input e gli Output).
Ma se invio l'oggetto, l'esecuzione si blocca e stappandola mi viene dato un errore. Esattamente così come sotto.

Output server:

Server socket avviato: ServerSocket[addr=0.0.0.0/0.0.0.0,localport=8080]
In attesa di una connessione...
Socket connesso: Socket[addr=/127.0.0.1,port=57981,localport=8080]
SKELETON: creazione skeleton fatta

Output client:

CLIENT: ciao sono il client
PROXY: creazione fatta

Come si vede, la Socket viene creata correttamente (come la Proxy) ma poi l'esecuzione si ferma lì. E se la vado a stoppare, mi da questa eccezione:

Exception in thread "main" java.io.EOFException
at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2328)
at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:2797)
at java.io.ObjectInputStream.readStreamHeader(ObjectInputStream.java:802)
at java.io.ObjectInputStream.<init>(ObjectInputStream.java:299)
at Skeleton.<init>(Skeleton.java:20)
at MainServer.main(MainServer.java:15)

La riga "incriminata" è questa:

ois = new ObjectInputStream(socket.getInputStream());

Ho provato a cercare in rete varie possibili soluzioni relative a questo tipo di eccezione, ma non ho trovato nulla che potesse aiutarmi.

Qualcuno sa aiutarmi in qualche modo?
Gliene sarei molto grato.
Grazie mille per la pazienza e la disponibilità a chi avrà voglia di leggere e provare a rispondermi.

[sottovento]

In Proxy, inverti la creazione dell'ObjectInputStream con l'ObjectOutputStream, cosi' come mostrato di seguito:


public class Proxy implements ServerInterface {

private Socket socket;
private ObjectInputStream ois;
private ObjectOutputStream oos;

public Proxy() throws Exception {
InetAddress addr = InetAddress.getByName(null);
socket = new Socket(addr , ServerInterface.PORT);
System.out.println("PROXY: creazione fatta");
// Sottovento - inverto creazione ois con creazione oos
oos = new ObjectOutputStream (socket.getOutputStream());
ois = new ObjectInputStream(socket.getInputStream());
}

@Override
public void printUser(User user) throws IOException {
oos.writeObject(user);
oos.close();
this.close();
System.out.println("PROXY: Chiudo connessione con server");
}

public void close() throws IOException {
this.socket.close();
}
}

[Giobbo]

Sottovento, ti ringrazio moltissimo!
Così funziona! Grazie davvero.

Ora la domanda è d'obbligo: perché?
Nel senso, qual'è la logica di questa "correzione" e quindi non fa presentare l'errore?

[sottovento]

Sottovento, ti ringrazio moltissimo!
Così funziona! Grazie davvero.

Ora la domanda è d'obbligo: perché?
Nel senso, qual'è la logica di questa "correzione" e quindi non fa presentare l'errore?

Quando esegui

ois = new ObjectInputStream(socket.getInputStream());

Crei uno stream di oggetti, quindi non sei piu' responsabile di ogni singolo byte che spedisci nella socket, ma ti affidi a Java, sapendo che Java introdurra' informazioni aggiuntive per poter spedire e ricevere (quindi ricostruendo correttamente) degli oggetti.
Alla creazione, Java si aspetta che la controparte spedisca dei dati, una specie di intestazione. Quindi il programma restera' bloccato su questa istruzione fintanto che dall'altra parte qualcuno non crei un ObjectOutputStream().

Siccome il client creava prima l'ObjectInputStream, erano entrambi bloccati ad aspettarsi l'un l'altro. Un deadlock, insomma.

[Giobbo]

Ok, charissimo.
Non lo sapevo proprio. Ben venga, una cosa in più da sapere.
Io ho invertito i costruttori sia nel Proxy che nello Skeleton, e funziona. E' un errore? Dalla spiegazione che mi hai dato non credo.
Grazie ancora.

[sottovento]

Ok, charissimo.
Non lo sapevo proprio. Ben venga, una cosa in più da sapere.
Io ho invertito i costruttori sia nel Proxy che nello Skeleton, e funziona. E' un errore? Dalla spiegazione che mi hai dato non credo.
Grazie ancora.

No, dovrebbe essere corretto. E' sempre meglio creare prima l'OutputObjectStream.

[Giobbo]

EDIT: problema risolto

[Giobbo]

EDIT:
sottovento, mi si è presentato un nuovo problema sempre relativo all'eccezione (EOFException) precedente.
Innanzitutto qui c'è il progetto che sto sviluppando:

https://github.com/Giobbo89/my-facedoor

Ora ti espongo il problema.
Sto testando il funzionamento del database e per farlo vado nella pagina di registrazione (classe RegisterPanel) e, dopo aver inserito i dati, completo la registrazione cliccando sul pulsante apposito, che invia i dati al server tramite l'invio di due oggetti (la parte in questione si trova sempre in RegisterPanel dalla riga 151).
Da qui quindi si crea il Proxy che invia i dati allo Skeleton e via dicendo (in questo caso le classi sono praticamente identiche a prima, invio in più solamente delle stringhe per determinare l'operazione da eseguire).
In pratica, effettuo una registrazione di prova e la cosa va a buon fine, senza errori di sorta.
Ma se tento di eseguire un'altra registrazione (con primary key diversa dalla precedente, quindi non è un problema di database) allora mi viene lanciata l'eccezione (in particolare dalla riga 34 della classe Skeleton).
Preciso che la cosa si verifica se tento di eseguire due registrazioni durante la medesima esecuzione del client, quindi senza chiuderlo e riaprirlo. Se invece ne faccio una, poi chiudo il client e lo riapro, allora va una nuova registrazione va a buon fine (ma non un'eventuale seconda).

[sottovento]

Ciao
scusa il ritardo, ultimamente non passo spesso sul forum.
Mi puoi riassumere
- cosa fa il programma?
- cosa devo scaricare per vedere l'errore?

[Giobbo]

Ciao
scusa il ritardo, ultimamente non passo spesso sul forum.
Mi puoi riassumere
- cosa fa il programma?
- cosa devo scaricare per vedere l'errore?

Il programma in sé è una sorta di piccolo (ed inutile :D ) social network, dove un utente si registra e compila il suo profilo e può eseguire ricerche per trovare altri profili.

Per vedere l'errore ti conviene scaricare il tutto e poi eseguire questi passaggi:
1. devi avere postgresql
2. eseguire dal terminale il file sh create_databases.sh
3. avviare il main del server (che presenta solo output sulla "console") e poi quello del client, che invece è formato da un'interfaccia grafica.
4. per vedere l'errore, basta che provi a registrarti e poi a loggarti con i dati appena inseriti.

In pratica si presenta se si eseguono due operazioni di comunicazione tra client e server durante la stessa esecuzione: la prima va a buon fine, qualunque essa sia, mentre la seconda no.
Il che mi fa pensare che l'errore stia nella creazione di nuovi Threads della classe Skeleton, visto che la prima comunicazione funziona perfettamente.

[Giobbo]

sottovento, non hai avuto modo di vedere il problema?
Facendo varie prove, ho visto che l'eccezione è generata sempre nello Skeleton quando provo (sempre che si tratti della seconda operazione client-server durante quell'esecuzione) a leggere un'oggetto tramite l'ObjectInputStream.
Ma non riesco a capire perché la prima volta funziona correttamente, mentre la seconda no.

[sottovento]

Scusami, sono davvero preso. Mi dispiace. Provo a scaricarlo fra qualche ora, chiedo perdono!

[Giobbo]

Scusami, sono davvero preso. Mi dispiace. Provo a scaricarlo fra qualche ora, chiedo perdono!

Ma ci mancherebbe altro, figurati!
Era giusto per chiedere visto che ancora io non ho capito quale sia il problema.

[sottovento]

Ho dato un'occhiata. Non ho il database a disposizione, quindi non posso far girare il sistema (anche se sto pensando che magari, visto che non sembra un problema di database, potrei eliminare le parti che lo riguardano, per fare un test veloce).

Se ho ben capito, fai cosi': per ogni registrazione il client
- apre una socket
- scrive un paio di oggetti
- chiude la socket

Dall'altra parte (server) ci si aspetta di vedere le operazioni speculari, vale a dire
- accettare la socket
- leggere un paio di oggetti
- chiudere la socket

In realta' il server fa un lavoro un po' diverso:


public Skeleton(Socket socket, Server server) throws IOException {
...
in = new BufferedReader (new InputStreamReader(socket.getInputStream())); // Perche'?
out = new PrintWriter (new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true); // Perche'?

oos = new ObjectOutputStream (socket.getOutputStream()); // OK
ois = new ObjectInputStream(socket.getInputStream()); // OK
}


Poi, per la lettura:

while(!this.socket.isClosed()) { // Perche'?
String op = in.readLine(); // Perche' leggi una stringa cosi'?
User user = (User) ois.readObject();
Profile profile = (Profile) ois.readObject();
}

Analogamente fai una println() di una stringa in scrittura

Ho due considerazioni:
1 - Se crei degli ObjectInputStream/ObjectOutputStream, usa quelli! Non mischiare con altri stream!!
Se hai bisogno di trasmettere una stringa, lo puoi sempre fare con oos.WriteObject e leggerla allo stesso modo.
2 - L'errore apparentemente (scusa, non ho investigato con un debugger) e' dovuto al fatto che usi un while.
Dopo aver letto gli oggetti, il server fa un altro giro di giostra ed e' fermo su
String op = in.readLine();
mentre il client ha finito di spedire e si appresta a chiudere la socket. A questo punto, la in.readLine() fallisce perche' gli hai chiuso la socket sotto il naso, quindi si arrabbia.
In realta' sai che devi ricevere due oggetti (anzi 3, considerando la stringa) e poi chiudere, quindi sarebbe meglio leggere i 3 oggetti e non fare ulteriori cicli; a meno che, s'intende, tu non voglia considerare un altro protocollo di comunicazione (per esempio, tenendo la socket sempre aperta, ecc).

[Giobbo]

Ho dato un'occhiata. Non ho il database a disposizione, quindi non posso far girare il sistema (anche se sto pensando che magari, visto che non sembra un problema di database, potrei eliminare le parti che lo riguardano, per fare un test veloce).

Se ho ben capito, fai cosi': per ogni registrazione il client
- apre una socket
- scrive un paio di oggetti
- chiude la socket

Dall'altra parte (server) ci si aspetta di vedere le operazioni speculari, vale a dire
- accettare la socket
- leggere un paio di oggetti
- chiudere la socket

In realta' il server fa un lavoro un po' diverso:


public Skeleton(Socket socket, Server server) throws IOException {
...
in = new BufferedReader (new InputStreamReader(socket.getInputStream())); // Perche'?
out = new PrintWriter (new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true); // Perche'?

oos = new ObjectOutputStream (socket.getOutputStream()); // OK
ois = new ObjectInputStream(socket.getInputStream()); // OK
}


Poi, per la lettura:

while(!this.socket.isClosed()) { // Perche'?
String op = in.readLine(); // Perche' leggi una stringa cosi'?
User user = (User) ois.readObject();
Profile profile = (Profile) ois.readObject();
}

Analogamente fai una println() di una stringa in scrittura

Ho due considerazioni:
1 - Se crei degli ObjectInputStream/ObjectOutputStream, usa quelli! Non mischiare con altri stream!!
Se hai bisogno di trasmettere una stringa, lo puoi sempre fare con oos.WriteObject e leggerla allo stesso modo.
2 - L'errore apparentemente (scusa, non ho investigato con un debugger) e' dovuto al fatto che usi un while.
Dopo aver letto gli oggetti, il server fa un altro giro di giostra ed e' fermo su
String op = in.readLine();
mentre il client ha finito di spedire e si appresta a chiudere la socket. A questo punto, la in.readLine() fallisce perche' gli hai chiuso la socket sotto il naso, quindi si arrabbia.
In realta' sai che devi ricevere due oggetti (anzi 3, considerando la stringa) e poi chiudere, quindi sarebbe meglio leggere i 3 oggetti e non fare ulteriori cicli; a meno che, s'intende, tu non voglia considerare un altro protocollo di comunicazione (per esempio, tenendo la socket sempre aperta, ecc).

Mmmmm, ma la registrazione va a buon fine, se è la prima operazione di comunicazione che eseguo. Così come il login.
Il problema si presenta (con qualsiasi operazione client-server, registrazione, login, modifica password, ecc...) alla seconda eseguita durante la medesima esecuzione.

In teoria, nel while lo Skeleton non ci rimane.
Perché il Proxy invia prima la stringa per identificare l'operazione, poi gli oggetti utili per eseguire l'operazione (che possono variare di numero) e poi un'ultima stringa per dire allo Skeleton che la comunicazione può considerarsi conclusa.

Forse una possibile soluzione al problema potrebbe essere cambiare il ciclo while da:

while (this.socket.isClosed())

a

while (true)

ed inserire semplicemente un break dopo aver letto la stringa "END" che identifica la fine delle comunicazioni.
Potrebbe funzionare?

Per quanto riguarda la soluzione che proponi di rimuovere il ciclo while, come potrei gestire il fatto che le varie operazioni hanno bisogno di un numero diverso di oggetti? Con semplici if innestati?

[sottovento]

Sono pressoche' sicuro che il ciclo while e' quello che ti causa problemi, poiche' la condizione di eof e' testata velocemente; dopo di che il flusso di esecuzione torna a bloccarsi sulla lettura di un oggetto, che non verra' mai letto poiche' vai a chiudere la socket dal server.

Non sapevo che il numero di oggetti che vai a leggere fosse variabile. Si, potresti risolvere con if innestati, ma non e' troppo elegante, potresti trovare soluzioni migliori. Tuttavia questo e' un passo successivo, per prima cosa devi essere sicuro di quello che succede nella tua applicazione.

A questo proposito: sembra chiaro che il database non c'entra nulla in questo problema; potresti fare una versione di test, eliminando l'uso del database? Invece di usare il database, potresti semplicemente scrivere "Salvataggio ok" e via dicendo.
In questo modo il debugging sarebbe facilitato ed io (ed altri in questo forum) avrebbero a disposizione una versione molto semplice, che gira immediatamente. Sarebbe piu' facile per tutti, potresti trovare un aiuto decisamente piu' efficace

[Giobbo]

AGGIORNAMENTO: come immaginavo, l'errore è relativo alla creazione di più Thread relativi alla classe Skeleton. Anche se non riesco a capire quale possa essere.
Per fare una prova, ho cambiato questa istruzione (che viene invocata ogni volta che un client tenta di connettersi al server tramite un socket):

new Thread(new Skeleton(socket, server)).start();

in questa

new Skeleton(socket, server).run();

In pratica, invece di creare un nuovo thread relativo alla classe Skeleton, creo direttamente un nuovo oggetto Skeleton.
In questo modo le varie operazioni vanno a buon fine.
La domanda è: perché?

EDIT: no, come non detto. Mi presenta il medesimo problema.

[Giobbo]

Sono pressoche' sicuro che il ciclo while e' quello che ti causa problemi, poiche' la condizione di eof e' testata velocemente; dopo di che il flusso di esecuzione torna a bloccarsi sulla lettura di un oggetto, che non verra' mai letto poiche' vai a chiudere la socket dal server.

Non sapevo che il numero di oggetti che vai a leggere fosse variabile. Si, potresti risolvere con if innestati, ma non e' troppo elegante, potresti trovare soluzioni migliori. Tuttavia questo e' un passo successivo, per prima cosa devi essere sicuro di quello che succede nella tua applicazione.

A questo proposito: sembra chiaro che il database non c'entra nulla in questo problema; potresti fare una versione di test, eliminando l'uso del database? Invece di usare il database, potresti semplicemente scrivere "Salvataggio ok" e via dicendo.
In questo modo il debugging sarebbe facilitato ed io (ed altri in questo forum) avrebbero a disposizione una versione molto semplice, che gira immediatamente. Sarebbe piu' facile per tutti, potresti trovare un aiuto decisamente piu' efficace

Ok, ora ho tolto i riferimenti al database (ci sono le prime due righe della classe MainServer che mi son scordato di "togliere" mettendole come commento, ma non dovrebbero creare problemi; nel caso, bastano un paio di //):

https://github.com/Giobbo89/my-facedoor

Testata velocemente funziona senza database.

Il numero di oggetti è variabile in base all'operazione: nella registrazione al momento sono due (user e profile) ma poi saranno tre con l'aggiunta dell'immagine; nel login è solo uno; ecc...
Gli if innestati sarebbero poco eleganti? Quale potrebbe essere una soluzione migliore? Un blocco switch?

[Giobbo]

E, a quanto pare, avevi ovviamente ragione sottovento!
Ho eliminato il ciclo while (oltre al fatto di utilizzare solo gli stream di oggetti per le comunicazioni) e utilizzato per il momento if innestati: a quanto pare sembra funzionare!

[sottovento]

E, a quanto pare, avevi ovviamente ragione sottovento!
Ho eliminato il ciclo while (oltre al fatto di utilizzare solo gli stream di oggetti per le comunicazioni) e utilizzato per il momento if innestati: a quanto pare sembra funzionare!

Puoi mostrare la parte di codice relativa agli if innestati?
Come dicevamo, sarebbe interessante vedere se si puo' implementare una soluzione alternativa...

[Giobbo]

Eccola qui:


try {
String op = (String) ois.readObject();
System.out.println(op);
if (op.equals(ClientServerCostants.REGISTER)) {
User user = (User) ois.readObject();
Profile profile = (Profile) ois.readObject();
ProfileImage image = (ProfileImage) ois.readObject();
this.saveUser(user, profile, image);
} else {
if (op.equals(ClientServerCostants.CHECK)) {
User user = (User) ois.readObject();
Profile profile = this.setUser(user);
oos.writeObject(profile);
} else {
if (op.equals(ClientServerCostants.DELETE_IMG)) {
Profile profile = (Profile) ois.readObject();
this.deleteImage(profile);
} else {
if (op.equals(ClientServerCostants.CHANGE_PASS)) {
User user = (User) ois.readObject();
this.setNewPassword(user);
} else {
if (op.equals(ClientServerCostants.MODIFY)) {
Profile profile = (Profile) ois.readObject();
String faceid = (String) ois.readObject();
this.modifyProfile(profile, faceid);
} else {
if (op.equalsIgnoreCase(ClientServerCostants.DELETE)) {
String faceid = (String) ois.readObject();
this.deleteUser(faceid);
} } } } } }
this.close();
} catch(Exception e) {
e.printStackTrace();
try {
this.socket.close();
} catch(IOException e2) {
System.err.println("Chiusura socket fallita...");
}
}
}


In pratica il client invia una prima stringa (che sono le varie costanti ClientServerConstants) per identificare il servizio richiesto al server, e poi gli eventuali altri oggetti necessari per eseguire questo servizio.

Pensavo che forse, modificando opportunamente le varie stringhe che identificano le varie operazioni, si potrebbe utilizzare un blocco switch che in base al primo carattere della stringa che identifica il servizio, determina le istruzioni da eseguire.

[sottovento]

L'idea che normalmente si applica e' piu' o meno cosi':

1 - dichiari un'interfaccia per i comandi che vuoi eseguire sul server, per esempio:


public interface CmdExecutable
{
public String getCommandName();
public void executeCommand(ObjectInputStream ois, ObjectOutputStream oos);
}


Ovviamente per la executeCommand() ho messo dei parametri che probabilmente ti serviranno. La lista dei parametri potrebbe essere piu' lunga, oppure potresti pensare ad un altro sistema per accedere ai parametri che ti servono.

2 - Questa interfaccia sara' implementata da ogni comando che vuoi implementare.
Per esempio:


public class DeleteImageCommand : CmdExecutable
{
@Override
public String getCommandName()
{
return ClientServerConstants.DELETE_IMG;
}

@Override
public void executeCommand(ObjectInputStream ois, ObjectOutputStream oos);
{
Profile profile = (Profile)ois.readObject();
deleteImage(profile); // Potrebbero servirti altri parametri
}
}


e cosi' via, li implementi tutti.

3 - In inizializzazione (probabilmente solo una volta durante l'esecuzione del programma), crei una struttura che contiene i tuoi gestori dei comandi.
Potrebbe essere, per esempio, un vettore. Io preferisco usare la HashMap. Questa deve essere una variabile membro. Per esempio:


private HashMap<String, CmdExecutable> mapRegisteredCommands;

private void initialiseRegisteredCommands()
{
mapRegisteredCommands = new HashMap<>();

DeleteImageCommand cmdDelete = new DeleteImageCommand();

mapRegisteredCommands.put(cmdDelete.getCommandName(), cmdDelete);
/* e cosi' via, li registri tutti */
}


4 - il tuo if diventa:

String op = (String) ois.readObject();
System.out.println(op);
CmdExecutable command = mapRegisteredCommands.get(op);
if (command != null) /* Se command == null, e' un comando non riconosciuto dal sistema */
command.executeCommand(ois, oos);


Questa e' una soluzione considerata "standard". Il vantaggio principale e' che e' facile estendere/modificare i comandi, soprattutto nel caso in cui terze persone debbano lavorare sul progetto.
Questo perche' ogni comando ha la sua class dedicata, il codice relativo al comando sta li' e solo li'. L'unica cosa che occorre ricordarsi di fare e' registrare il comando nella HashMap: nei programmi complessi, la registrazione puo' essere ripetuta durante l'esecuzione o la registrazione stessa puo' essere basata su file di configurazione (e' il meccanismo di base dei plug in).

Ovviamente e' solo una proposta, in ultima analisi tocca a te decidere quale strada seguire.

[Giobbo]

Questa soluzione è veramente ottima. Elegante e semplice.
La utilizzerò sicuramente. Sai se questo particolare pattern ha un nome?

Ne approfitto per fare un'ulteriore domanda: come posso, dal mio programma (in questo caso dal server) inviare una mail?
Ho visto che c'è un API apposita (JavaMail) per farlo. Ma mi domando: il mio server deve essere quindi online? Oppure è la stessa API che si occupa del tutto?

[sottovento]

Questa soluzione è veramente ottima. Elegante e semplice.
La utilizzerò sicuramente. Sai se questo particolare pattern ha un nome?

Ne approfitto per fare un'ulteriore domanda: come posso, dal mio programma (in questo caso dal server) inviare una mail?
Ho visto che c'è un API apposita (JavaMail) per farlo. Ma mi domando: il mio server deve essere quindi online? Oppure è la stessa API che si occupa del tutto?

Praticamente e' un Abstract Factory. Siccome hai degli oggetti semplici, la factory e' solo la registrazione degli oggetti.

Riguardo JavaMail: l'ho usato poche volte, ma devi essere online. Le API fanno i vari collegamenti per te ed implementano i protocolli di mail, ma non fanno altro. Se vuoi un sistema che possa inviare quando si trova online (e bufferizzare quando si e' offline, per spedire in seguito) lo devi implementare, non mi sembra che esista niente del genere in Javamail

[Giobbo]

Ciao sottovento, mi scuso per il ritardo nel risponderti ma tra weekend (scorso) e lavoro ho avuto pochissimo tempo.
Allora, ho implementato lo standard che mi hai consigliato per le varie operazioni e rende il tutto molto pulito e ordinato. Ottimo veramente. L'inizializzazione dell'HashMap l'ho inserita come metodo statico dello Skeleton.

Ho una nuova domanda, tanto per cambiare.
Come posso mettere/rendere/nonsoqualesiailverboappropriato online il mio server e quindi poter inviare le mail attraverso l'API JavaMail?

[sottovento]

Purtroppo sono in ospedale e non posso dare un'occhiata. Spero che qualcun altro lo possa fare, altrimenti ci sentiamo quando esco.
Ciao

[Giobbo]

Osti, tutto bene?
Spero niente di grave.

[sottovento]

Osti, tutto bene?
Spero niente di grave.
No, un'operazione chirurgica, ma mi terra' fuori combattimento per una settimana, piu' la convalescenza. In bocca al lupo per il tuo problema, non ho modo di darci un'occhiata, per ora

[sottovento]

Ho una nuova domanda, tanto per cambiare.
Come posso mettere/rendere/nonsoqualesiailverboappropriato online il mio server e quindi poter inviare le mail attraverso l'API JavaMail?

Ciao, sono tornato a far danni ;)
Per spedire una mail attraverso javamail non devi essere necessariamente un server e non devi essere necessariamente online. Javamail funziona come il tuo mailer, quindi ti basta scaricare un programma di esempio funzionante, metterci il tuo setting (user/pass/server/...) ed il gioco e' fatto.
Ciao