Persistance java sans SGBD !

Version imprimable

23/10/2010, 16h47
MaxLaMenaX

Persistance java sans SGBD !

Salut !

Bon en fait, j'ai une petite application java, et le souci c'est que j'aimerais pouvoir sauvegarder les objets créé à l'intérieur de celle ci.

Je ne pense pas me tromper, en disant que JDBC est une api d'accés à une base de donnée pour Java, mais que cette solution ne réponds pas à mon problème.

Car j'ai besoin de sauvegarder, mon application, afin que les objets ne soient pas perdus après un "exit" et qu'ils soient rechargés au lancement, ou sur click sur un bouton ...

Rassurez moi, pour cela il n'y a que 2 solutions ?

1°) - utilisé une base de donnée
2°) - utilisé un fichier

Si il y en a d'autres évidentes ou astucieuses... je suis preneur !

Pour le 1°) le problème est qu'elle sous entend d'avoir un serveur SGBD, et qu'il soit démarré, ce qui porterait atteinte à la portabilité de mon application...

Car j'aimerais qu'elle puisse tourner sur une clef USB par exemple et sur n'importe quel ordi, sans avoir à ne rien installer ...

Donc la meilleure solution est les fichiers ???
23/10/2010, 17h14
MaxLaMenaX
Pour le moment je suis un peu parti tête baissé et bon ca tourne mais j'ai l'impression que ma programmation est un peu biscornue...

et en plus apparemment j'ai reprogrammé la Serialisation apparemment ...

Si j'ai deux Classes par exemple :
Code:

1 2 3 4 5 6 7 8 9 Class PorteDocument String name; List<Document> documents = new ArrayList()<Document>; Class Document String name; int taille;
Ce sont mes classes de bases... Après comme j'ai voulu les conservées dans des fichiers, j'ai ajouté à la Classe Document et PorteDocument un Id (Integer) ...

et dans ma Classe Document un idPere, qui me permet avec la sauvegarde de savoir à quel PorteDocument ils sont liés...

Enfin bref, j'ai l'impression de tourner en Rond...

Ce que je devrais plutôt faire, c'est Serialiser mes objets mais je suis en train de m'embrouiller avec les objets qui contiennent des listes d'objest qui contiennent eux même d'autres listes d'objets ...

Il faut simplement que je cree une liste de conteneur Globale, l'objet racine, et que je sérialise cela, à la désérialisation, il contiendra toujours ces fils, et les fils de ses fils ???

Ouais, effectivement je crois que j'avais redévelopper l'informatique de A à Z, la Sérialisation et les bases des données :lol: !

Bon je donne l'exemple, si jamais ca peut servir :

- Un PorteDocument qui contient un nom et plusieurs Document ( 1 à n)
- Un Document qui contient un nom, une taille et un Truc (1 à 1)
- Un Truc qui contient un nom.

- Le TOUT, soit les divers PorteDocument sont contenus dans une HashTable

Et donc il suffit de Sérialiser l'objet conteneur Globale ou que j'appelais Racine, soit la Hashtable pour Sauvegarder, et de déserialisé pour Recharger !

Cool, c'est un milliards de fois plus simple que ce que j'essayais de faire :mrgreen: !

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class PorteDocument implements Serializable {
 
	private static final long serialVersionUID = 1L;
	String name;
	List<Document> documents;
 
	public PorteDocument(String name, List<Document> documents){
		this.name = name;
		this.documents = documents;
	}
 
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public List<Document> getDocuments() {
		return documents;
	}
	public void setDocuments(List<Document> documents) {
		this.documents = documents;
	}

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
public class Document implements Serializable {
	private static final long serialVersionUID = 1L;
	String name;
	Integer taille;
	Truc truc;
 
	public Document (String name, Integer taille, Truc truc){
		this.name = name;
		this.taille = taille;
		this.truc = truc;
	}
 
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getTaille() {
		return taille;
	}
	public void setTaille(Integer taille) {
		this.taille = taille;
	}
	public Truc getTruc() {
		return truc;
	}
	public void setTruc(Truc truc) {
		this.truc = truc;
	}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Truc implements Serializable {
	private static final long serialVersionUID = 1L;
	String name;
 
	public Truc(String name){
		this.name = name;
	}
 
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}	
}

Serialisation (Sauvegarde)

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
37
38
39
public abstract class TestSerialisation {
 
	public static void main(String[] args) {
		Truc c1 = new Truc("Truc1");
		Truc c2 = new Truc("Truc2");
		Truc c3 = new Truc("Truc3");
		Truc c4 = new Truc("Truc4");
		Truc c5 = new Truc("Truc5");
		Document d1 = new Document("Doc1", 1, c1);
		Document d2 = new Document("Doc2", 2, c2);
		Document d3 = new Document("Doc3", 3, c3);
		Document d4 = new Document("Doc4", 4, c4);
		Document d5 = new Document("Doc5", 5, c5);
		List<Document> doc1 = new ArrayList<Document>();
		doc1.add(d1);
		doc1.add(d2);
		doc1.add(d3);
		List<Document> doc2 = new ArrayList<Document>();
		doc2.add(d4);
		doc2.add(d5);
		PorteDocument p1 = new PorteDocument("PorteDoc1", doc1);
		PorteDocument p2 = new PorteDocument("Portedoc2", doc2);
		Hashtable<String, PorteDocument> porteDocuments = new Hashtable<String, PorteDocument>();
		porteDocuments.put(p1.getName(), p1);
		porteDocuments.put(p2.getName(), p2);
 
		try {
			FileOutputStream fos = new FileOutputStream("PorteDocuments.serial");
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			oos.flush();
			oos.writeObject(porteDocuments);
			oos.close();
			fos.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

DeSerialisation (Chargement)

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
public class TestDeSerialisation {
 
	public static void main(String[] args) throws InterruptedException {
		Hashtable<String, PorteDocument> porteDocuments = null;
		try{
			FileInputStream fis = new FileInputStream("PorteDocuments.serial");
			ObjectInputStream ois = new ObjectInputStream(fis);
			porteDocuments = (Hashtable<String, PorteDocument>) ois.readObject();
			ois.close();
			fis.close();
		}
		catch(Exception e){
			e.printStackTrace();
		}
		for (Enumeration<PorteDocument> enumValeur = porteDocuments.elements(); enumValeur.hasMoreElements();){
			PorteDocument p= enumValeur.nextElement();
			System.out.println("-- PorteDocument " + p.getName());
			for ( int i = 0; i<p.getDocuments().size(); i++){
				Document d = p.getDocuments().get(i);
				System.out.println("\t - Document " +(i+1)+ " :  nom " + d.getName()+ " , taille " + d.getTaille() );
				System.out.println("\t\t - Truc :  nom " + d.getTruc().getName());
			}
		}
	}

Resultats Deserialisation à la console :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
-- PorteDocument PorteDoc1
	 - Document 1 :  nom Doc1 , taille 1
		 - Truc :  nom Truc1
	 - Document 2 :  nom Doc2 , taille 2
		 - Truc :  nom Truc2
	 - Document 3 :  nom Doc3 , taille 3
		 - Truc :  nom Truc3
-- PorteDocument Portedoc2
	 - Document 1 :  nom Doc4 , taille 4
		 - Truc :  nom Truc4
	 - Document 2 :  nom Doc5 , taille 5
		 - Truc :  nom Truc5

23/10/2010, 19h02
MaxLaMenaX

Bon c'est pas pour faire un monologue, mais j'ai lu aussi dans un autre Post que

la solution d'une Base de donnée intégré dans java pouvait aussi répondre à ce problème apparemment comme Derby et hosqldb(pas sur)...

Maintenant le souci va être de savoir où placer le fichier de serialisation...

Je suppose que je ne peux pas le laisser à l'intérieur du .JAR car je n'y aurais pas accés, n'est ce pas ?
23/10/2010, 23h54
dinobogan

Citation:

Envoyé par MaxLaMenaX

Je suppose que je ne peux pas le laisser à l'intérieur du .JAR car je n'y aurais pas accés, n'est ce pas ?

Non, la raison est bien pire : le jar de l'application est en cours d'utilisation par la JVM. Il peut être locké, ou alors tu pourrais planter la JVM.
Donc ne JAMAIS modifier un jar en cours d'utilisation.
Par contre, même si tu distribues ton application par clé USB, on peut tout à fait imaginer qu'elle créée un fichier à côté du jar.
31/10/2010, 17h29
MaxLaMenaX

Salut, ouais en fait quand j'ai exporté mon application en .jar, et que je l'ai testé, elle a mis les fichiers de serialisation automatiquement à coté du .jar, donc pour le moment ca va bien !

Mais au début quand, j'avais reprogrammé, la serialisation et les BD lol, donc je le faisais avec un fichier .txt pour chaque objet qui contenait les instances de l'objet. Et sous Eclipse ca marchait bien, mais quand je l'exportais en .jar, comme tu dis, il est loqué donc ca marchait plus ... il pouvait pas écrire, les nouvelles instances d'objets dans les fichiers !