Discussion :

[ptitjack]

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 :

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

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 :

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

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 @+

[ptitjack]

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

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

@+

[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 ?

[ptitjack]

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

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
/**
* 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...

[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.

[ptitjack]

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

Oui, tout fonctionne à merveille dans pratiquement tous les cas

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 )

[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é.

[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...

[ptitjack]

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 :

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

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);
   }
}

@+

[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

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é.
@+