Discussion :

[Coooo]

Bonjour,

Je pense que c'est la première fois que je pose un problème sur ce forum à propos de Java.

Je suis actuellement en train de développer un serveur Java qui doit communiquer avec un autre serveur (le serveur fait donc office de client et serveur).

Le service qui pose problème (exception en rouge)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
/**
     * Permet d'envoyer un message (Objet) vers un autre serveur a travers le tube
     * @param s est une instance de la socket
     * @param m est une instance du message
     * @throws metier.MetierException en cas de probleme lors de l'envoi
     */
    public static void envoyerServeur(Socket s, Message m) throws MetierException
    {
        ObjectOutputStream oos = null;

        try {
            oos = FactoryStream.getInstance().getOutput(s);
        } catch(StreamException ex) {
            try {
                oos = FactoryStream.getInstance().creerOutput(s);
            } catch (StreamException ex1) {
                m = null;
                throw new MetierException(ex.getMessage());
            }
        }

        // On tente d'envoyer
        try {
            oos = new ObjectOutputStream(s.getOutputStream());
            oos.writeObject(m);
            oos.flush();
        } catch (IOException ex) {
            m = null;
            throw new MetierException("Impossible d'envoyer un objet sur le flux "+ex.getMessage());
        }
    }

    /**
     * Permet de recevoir un message (objet)
     * @param s est une instance de la socket
     * @return une instance de message
     * @throws metier.MetierException en cas de probleme de lecture
     */
    public static Message recevoirServeur(Socket s) throws MetierException
    {
        ObjectInputStream ois = null;
        Message message = null;

        try {
            System.err.println("R");
            ois = FactoryStream.getInstance().getInput(s);
            System.err.println("R");
        } catch(StreamException ex) {
            try {
                System.err.println("C");
                ois = FactoryStream.getInstance().creerInput(s);
            } catch (StreamException ex1) {
                throw new MetierException(ex.getMessage());
            }
        }

        try {
            message = (Message)ois.readObject();
        } catch (StreamCorruptedException ex) {
            System.err.println(ex);
            throw new MetierException("Impossible de recevoir un objet sur le flux "+ex.getMessage());
        } catch (IOException ex) {
            throw new MetierException("Impossible de recevoir un objet sur le flux "+ex.getMessage());
        } catch (ClassCastException ex) {
            throw new MetierException("Impossible de lire l'objet envoye par le serveur distant (L'objet n'est pas un message)");
        } catch (ClassNotFoundException ex) {
            throw new MetierException("Impossible de lire l'objet envoye par le serveur distant (L'objet n'est pas un message)");
        } finally {

        }
        return message;
    }

et une fabrique qui gère mes ObjectInput et ObjectOutput

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
37
38
39
40
41
42
43
44
45
46
47
48
49
public ObjectOutputStream getOutput(Socket s) throws StreamException
    {
        if(oos.containsKey(s))
            return oos.get(s);
        else
            throw new StreamException("Impossible de trouver un oos car il n'existe pas");
    }
 
    public ObjectOutputStream creerOutput(Socket s) throws MetierException, StreamException
    {
        if (oos.containsKey(s)) {
            throw new StreamException("Impossible de creer un nouveau oos car il existe deja");
        }
 
        ObjectOutputStream noos = null;
        try {
            noos = new ObjectOutputStream(s.getOutputStream());
            oos.put(s, noos);
            return noos;
        } catch (IOException ex) {
            throw new MetierException("Impossible de creer un nouveau oos : "+ex.getMessage());
        }
    }
 
    public ObjectInputStream getInput(Socket s) throws StreamException
    {
        if(ois.containsKey(s)) {
            return ois.get(s);
        }
        else
            throw new StreamException("Impossible de trouver un ois car il n'existe pas");
    }
 
    public ObjectInputStream creerInput(Socket s) throws MetierException, StreamException
    {
 
        if (ois.containsKey(s)) {
            throw new StreamException("Impossible de creer un nouveau ois car il existe deja");
        }
 
        ObjectInputStream nois = null;
        try {
            nois = new ObjectInputStream(s.getInputStream());
            ois.put(s, nois);
            return nois;
        } catch (IOException ex) {
            throw new MetierException("Impossible de creer un nouveau ois : "+ex.getMessage());
        }
    }

Le fichier sérialisé est un objet message qui implémente bien serializable

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
package metier;
 
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
 
/**
 * Represente un message à envoyer vers un serveur ou un client
 * @author Corentin
 */
public class Message implements Serializable {
 
    private static final long serialVersionUID = 42L;
 
 
    private int code;                   // Code pour le protocole
    private String message;             // Contenu du message
    private List <Object> arguments;    // Arguments
 
    public Message(int code, String message)
    {
        this.code = code;
        this.message = message;
    }
 
    public int getCode()
    {
        return code;
    }
 
    /**
     * Retourne le nombre d'arguments
     * @return un entier avec le nombre d'argument
     */
    public int size()
    {
        return arguments.size();
    }
 
    public void addArguments(Object argument)
    {
        if(arguments==null)
            arguments = new ArrayList<Object>();
        arguments.add(argument);
    }
 
    public Object getArgument(int numero)
    {
        return arguments.get(numero);
    }
 
}

Mon exception est levée au moment de la lecture (désérialization) de l'objet message (en rouge dans le code).

J'ai essayé pas mal de chose et je m'oriente vers vous.
Merci

[vic]

Hello,

le problème est que tu crées un ObjectOutputStream à chaque envoi de message, alors que de l'autre coté tu gardes toujours le même ObjectInputStream. Il faut que soit tu conserves l'ObjectOutputStream, soit tu recrées également l'ObjectInputStream à chaque lecture.

[Coooo]

Salut,

Merci pour ta réponse je vais essayer de m'orienter vers cette piste