Newsgroup: it.comp.java
Titolo: Lettura di una stringa quando si aspetta un intero

Ho un canale di comunicazione costituito da DataInputStream (lato
client) e DataOutputStream (lato server). Se il server fa writeString
ma il client aspetta in intero, cioè fa readInt, che succede?
Ho necessità di spedire il nome dell'eccezione se si verifica un
problema nell'elaborazione sul server e quindi al posto di spedire
l'intero che fa da risultato alla richiesta inviata dal client spedisco
il nome dell'eccezione e il messaggio.
Secondo voi come posso risolvere questa problematica?
Io pensavo di mandare prima dell'intero/stringa un booleano così che
il client faccia prima readBoolean e poi readInt se il booleano vale
true o readString se invece vale false. Tuttavia è un overhead
abbastanza seccante.
Esistono alternative?
Ciao e grazie,
ReX

L'unica cosa che mi viene in mente è scivere un intero che corrisponde
ad un codice.
Però di certo non è elegante come modo e non puoi mappare sugli
interi tutte le possibili eccezioni che possono verificarsi.
Per cose del genere dovresti usare IMHO un diverso rapporto tra client
e server, tipo un WebService o l'equivalente JAVA del .NET Remoting.

 Esistono alternative?
Ne esistono infinite. Quella che hai detto è una e se è efficace non
vedo perchè non implementarla. Il discorso sull'overhead mi sembra
esagerato, d'altra parte il check sui dati un minimo di costo ce l'ha.

D_Guidi ha scritto:

Il problema è che sto utilizzando la piattaforma J2ME che non mi offre 
nulla, in pratica mi sto implementando l'invocazione di metodi remoti a 
mano, quindi ti lascio immaginare quali sono i problemi che sto avendo 
nel dover usare il solo DataInput/OutputStream.
Se avessi avuto a che fare con J2SE avrei usato CORBA che avrebbe fatto 
gran parte di quello che cerco...
Ciao,
ReX

Vincent Vega ha scritto:

Il problema è che se l'utente che userà la mia libreria non è furbo e si 
  mette a leggere 1 byte alla volta per fare il fetch di un file 
disponibile sul server ci sarà 1 boolean per ogni byte letto quindi 
l'overhead porta al raddoppio del volume di dati da scambiare. 
Ovviamente il problema non si pone se si legge a blocchi di byte in 
quanto l'overhead come dici tu è minimo.
Tuttavia non vedo altro modo per risolvere il problema su piattaforma 
J2ME...
Ciao,
ReX

 quanto l'overhead come dici tu è minimo.
Non vedo il problema. Se il protocollo lo stabilisci tu, tu decidi come
l'utente legge i dati. Tu mandi un byte e un intero, o un byte e una
stringa. L'utente ovviamente si adegua a leggere i dati come glie li mandi.
Non capisco perchè tu debba mandare un byte di check per ogni byte letto
se l'utente legge un byte alla volta.

Vincent Vega ha scritto:

Non l'ho scritto all'inizio, sto scrivendo una libreria per estendere le 
funzionalità del Generic Connection Framework MIDP, quindi di fatto le 
mie classi offrono al programmatore (Data)In/OutStream virtuali mappati 
su quelli offerti dal GCF. Ho implementato nelle mie classi tutti i 
metodi degli Stream e quindi il problema si pone perchè chi usa le 
librerie sarà libero di usare la read di 1 byte o la read di un array e 
analogamente la write di 1 byte o la write di un array.
Ciao,
ReX