Problème d'entrée sortie

Bonjour,

je voudrais savoir s'il était possible de forcer l'écriture du EOF dans un flux.

Je développe une application Client / Serveur:

coté serveur voici le code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    public synchronized  byte[] makeRequest() {
 
            byte[] tab = new byte[1024];
            byte retour[]=null;
            ByteArrayOutputStream b = new ByteArrayOutputStream();
            int tailleLu=0;
        try {
 
            while ((tailleLu = this.entree.read(tab, 0, tab.length))!=-1) {
 
                b.write(tab, 0, tailleLu);
                b.flush();
 
            }
            retour=b.toByteArray();
 
        } catch (IOException ex) {
            Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
        }finally{
            try {
                b.close();
            } catch (IOException ex) {
                Logger.getLogger(Client.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
 
            return retour;
    }

Et voici le code coté client:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
    public void run() {
 
        while (true) {
 
            RequeteDistante r = (RequeteDistante) this.gestionnaireDeRequete.traiterRequeteSuivante();
            byte reponse[] = (byte[]) r.methode_distante();
            byte[] tab = new byte[1024];
            ByteArrayInputStream b = new ByteArrayInputStream(reponse);
            int tailleLu = 0;
 
            try {
 
 
                while ((tailleLu = b.read(tab, 0, tab.length)) != -1) {
 
                    this.sortie.write(tab, 0, tailleLu);
                    this.sortie.flush();
 
                }
 
            } catch (IOException ex) {
                Logger.getLogger(ExecuteurDeRequete.class.getName()).log(Level.SEVERE, null, ex);
            } finally {
                try {
                    b.close();
                } catch (IOException ex) {
                    Logger.getLogger(ExecuteurDeRequete.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
 
 
            this.yield();
        }
 
 
    }

Le soucis, c'est que sur un exemple, coté client j'écrit 176 bits et je ferme le flux ByteArrayInputStream.

En revanche coté serveur, 175 bits sont lus et ensuite il reste boqué en attente en lecture.

Si je ferme coté client le flux de sortie de socket aprés la premiere requete, il y a bien 176 bits qui sont lus ( cependant vu que le flux est fermé je ne peux plus demandé aux clients de traiter de nouvelles de requetes).

Merci d'avance pour les personnes qui m'apporteront leur aide