[Sérialisation] StackOverFlowError levée

Version imprimable

J'ai une structure en arbre d'objet à sérialiser. Lorsque la structure atteint une taille critique, j'ai une erreur de type StackOverFlowError qui est levée.

Code pour sérialiser mon objet :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public static void serialize(Serializable serializable, OutputStream outputStream) throws ATypeOfException { try { ObjectOutputStream objectOutputStream = new ObjectOutputStream( outputStream); objectOutputStream.writeObject(serializable); objectOutputStream.close(); } catch (IOException e) { throw new ATypeOfException(e); } catch(StackOverflowError e){ throw new ATypeOfException(e); } }
En cherchant un peu sur Google, j'ai trouvé ceci (pour ceux que ça intéresse) :
http://forum.java.sun.com/thread.jsp?forum=4&thread=320056

Sur la base de cette discussion, j'ai implémenté les méthodes suivantes dans les objets intervenant dans ma structure
Code:

1 2 3 4 5 6 7 8 private void writeObject(ObjectOutputStream out) throws IOException { //Ecriture sur le flux des attributs de mon objets } private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { //Lecture depuis le flux des attributs de mon objets }
Exactement même comportement que sans leur implémentation. :?

J'ai aussi réfléchi aux champs contenus dans mes objets pour définir ceux qui ne m'intéressent pas comme transient afin de ne pas les sérialiser... Mais toujours même comportement. :?

Je pose donc la question suivante, est-ce que quelqu'un est déjà tombé sur un cas semblable, si oui, alors comment l'a-t'il résolu...

Merci @+

03/11/2004, 14h30
ptitjack

Est-ce que quelqu'un sait si cette affirmation est encore valable sous jsdk 1.4 ?

Citation:

Envoyé par www.ChurchillObjects.com

The serialization process uses recursion to find all of the classes that make up an object to be serialized, and there is an upper limit to the depth that the JVM can handle. This chain can run for exactly 1001 objects deep before it throws a Stack*Overflow*Error. This is a limitation that still exists in JDK1.3, although it’s probably safe to say if you’re trying to do this you’ve got something wrong with your design.

Pour ceux que ça intéresse

@+
03/11/2004, 14h31
otsgd

Salut,

est-ce que l'écriture de ton objet sur le flux est récursive ? car c'est généralement d'une récursion infinie que vient le stackOverFlow.

Tu peux mettre du code ?

En fait, un noeud de mon arbre est de cette forme :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 /** * Représente un noeud de l'arbre */ public class Node implements Serializable { //Identifie le noeud private String name=null; //Noeud père private Node father = null; //Contient l'ensemble des noeuds fils private ArrayList nodesList = null; public Node(Node theFather, String theName){ nodesList = new ArrayList(); name=theName; father = theFather; } //... }
Donc indirectement, je fais appel aux méthode writeObject et readObject de manière recursive...

Je vois donc qu'il me faut absolument être certain que je n'ai pas la référence du père de mon noeud courant qui soit aussi contenue dans l'arborescence de ses fils...

03/11/2004, 14h47
otsgd

Non,

je serialise aussi des arbres dont les fils contiennent une référence sur leur père. Java résout ce genre de cycle très facilement.

En revanche, ce que tu relèves avant sur une éventuelle taille limite est intéressant, je ne sais pas ce qu'il en est dans la 1.4, à voir.

tu as essayé de sérialisé un petit objet ?

Quel est la taille de ton arbre ?

Je suppose que tu ne passes pas une copie du pere a ton fils, enfin on sait jamais.
03/11/2004, 14h52
ptitjack

Citation:

Envoyé par otsgd

tu as essayé de sérialisé un petit objet ?

Oui, tout fonctionne à merveille dans pratiquement tous les cas :lol:

Citation:

Envoyé par otsgd

Je suppose que tu ne passes pas une copie du pere a ton fils, enfin on sait jamais.

Non, c'est juste la référence du père... (ça m'embête d'ailleurs... Mais j'en ai besoins :( )
03/11/2004, 15h31
otsgd

Et dans quel cas ça ne marche pas ? une taille trop importante ?

Pas d'inquiétude pour la référence sur le père, c'est cohérent et bien géré.
03/11/2004, 15h37
ptitjack

J'essaie d'isoler la partie qui ne fonctionne pas, car le problème arrive lors d'un traitement de données...

Et bien évidemment que la donnée qui ne fonctionne pas lors du traitement, se laisse sérialiser parfaitement lorsqu'on l'isole...

Bon, le problème ne semble pas venir de la sérialisation de la structure, mais du nombre important de sérialisations que je fait à la suite (environ 5000)...

Est-ce qu'il y a qqch qui vous choque et que je ne vois pas dans le code ci-dessous ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void serialize(Serializable serializable, OutputStream outputStream)
    throws ATypeOfException {
   try {
       ObjectOutputStream objectOutputStream = new ObjectOutputStream(
               outputStream);
       objectOutputStream.writeObject(serializable);
       objectOutputStream.close();
   } catch (IOException e) {
      throw new ATypeOfException(e);
   } catch(StackOverflowError e){
      throw new ATypeOfException(e);
   }
}

04/11/2004, 13h27
ptitjack

Voilà, j'ai résolu mon problème...

Pour parcourir ma structure en arbre, j'ai des méthodes qui étaient implémentées de manières récursives... Et ben, j'ai atteint visiblement la limite de la récursivité pour la JVM :roll:

J'ai réfliéchi mon algo pour limiter la récursivité et maintenant, ça passe...

-> Ce n'était pas un problème dû à la sérialisation, désolé.
@+