Discussion :

[pingoui]

Bonjour,

J'essaye de refactoriser mon code pour qu'il soit un peu plus pro.
N'étant pas du métier, j'ai du mal à choisir les bons patterns pour la conception de mon appli.
Je trouve que mon appli est fortement couplé et donc difficille pour la maintenance et futures évolutions.

Par exemple :
J'ai une classe "ZOO" qui contient une liste de "Secteur".
Ma classe "Secteur" contient une liste de "Cage".
Ma classe Cage contient une liste d' "Animal"

Zoo.java

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
 
public abstract class Zoo {
 
	private List<Secteur> 					secteurs        = new ArrayList<Secteur>();
 
	/**
         * Renvoie l'ensemble des secteur
         */
	public List<Station> getListOfStation() {
		return secteurs;
	}
 
	/**
         * Ajoute un secteur à ce zoo
         */
	protected void addSecteurToZoo(Secteur secteur) {		
		int index = this.secteurs.indexOf(station);
		// Si le secteur n'existe pas encore, ajout du nouveau secteur à la liste des secteurs
		if (index == -1) {
			//On ajoute le poste à la liste de poste
			this.secteurs.add(secteur);
		} else {
			secteur = this.secteurs.get(index);
		} 
	}
}

Secteur.java

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
 
public class Secteur{
 
	private String 								secteurName;//Nom du secteur
	private List<Cage>						cages;//Liste des cages
 
	/**
         * Création d'un secteur
         */
	public Station(String name) {
		this.secteurName = name;
		this.cages = new ArrayList<Cage>();
	}
 
	/**
         * Renvoie le nom du secteur
         */
	public String getSecteurName() {
		return stationName;
	}
 
	/**
         * Modifie le nom du secteur
         */
	public void setSecteurName(String secteurName) {
		this.secteurName = secteurName;
	}
 
	/**
         * Renvoie l'ensemble des cages
         */
	public List<Cage> getCages() {
		return cages;
	}
 
	/**
         * Ajoute une cage à ce secteur
         */
	public void addCageToSecteur(Cage cage) {
		int index = this.cages.indexOf(cage);
		// Si la cage n'existe pas encore, ajout de la nouvel cage à la liste
		// des cages
		if (index == -1) {
			// On ajoute le cage à la liste de cage
			this.cages.add(cage);
		} else {
			cage = this.cages.get(index);
		}
	}
}

La classe "Cage" et "Animal" sont presque identiques à "Secteur"

Pour sérialiser / déserialiser mon zoo, j'utilise JDOM. J'ai donc crée deux classe qui étendent de Zoo. XmlReader et XmlWriter

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
73
74
75
76
77
78
79
80
81
82
 
public class XmlReader extends Zoo{
 
	private Document document;
	private Element racine;
	/**
         * Création du lecteur de fichier XML
         */
	public XmlReader(){
		// On crée une instance de SAXBuilder
		SAXBuilder sxb = new SAXBuilder();
		try {
			// On crée un nouveau document JDOM avec en argument le fichier XML
			document = sxb.build(new File("Zoo.xml"));
			// Le parsing est terminé
		} catch (Exception e) {
			e.printStackTrace();
		}
 
		// On initialise un nouvel élément racine avec l'élément racine du
		// document.
		racine = document.getRootElement();
		//On parcours les différents noeuds de l'arbre
		readSecteur();		
	}
 
	public StationExplorer getStationExplorer(){
		return this;
	}
 
	/**
         * Permet de lire les enfants "secteur" du zoo
         */
	@SuppressWarnings("unchecked")
	private void readSecteur() {
		// On crée une List contenant tous les noeuds "secteur" de l'Element racine
		List<Element> listOfSecteur = racine.getChildren("secteur");
		for(Element element : listOfSecteur){
			//On crée un secteur avec son nom comme attribue
			Secteur secteur = new Secteur(element.getAttributeValue("name"));
			//On ajoute le secteur au zoo
			addSecteurToZoo(secteur);
			//On lit les autres noeuds enfants (cage)
			readCage(secteur,element);
 
		}			
	}
 
	/**
         * Permet de lire les enfants "cage" du secteur
         */
	@SuppressWarnings("unchecked")
	private void readCage(Secteur secteur,Element elementSecteur) {
		// On crée une List contenant tous les noeuds "cage" de l'Element "secteur"
		List<Element> listOfCage = elementSecteur.getChildren("cage");
		for(Element element : listOfCage){
			//On crée un départ avec son nom comme attribue
			Cage cage = new Cage(element.getAttributeValue("name"));
			// On ajoute la cage à son secteur
			secteur.addCageToSecteur(cage);
			//On lit les autres noeuds enfants (animal)
			readAnimal(cage,element);
		}			
	}
 
	/**
         * Permet de lire les enfants "equipement" du départ
         * @param departure
         * @param elementDeparture
         */
	@SuppressWarnings("unchecked")
	private void readAnimal(Cage cage,Element elementCage) {
		// On crée une List contenant tous les noeuds "animal" de l'Element "cage"
		List<Element> listOfAnimal = elementCage.getChildren("animal");
		for(Element element : listOfAnimal){
			//On crée un animal avec son nom
			Animal animal = new Animal(element.getAttributeValue("name"));
			//On ajoute l'équipement à son départ
			cage.addAnimalToCage(animal);			
		}			
	}
}

La classe XmlWriter est presque identique à XmlReader sauf comme son nom l'indique, elle permet d'écrire dans un fichier xml

Avec ce petit exemple, pouvez-vous m'aider à mieux concevoir mon appli pour qu'elle soit plus souple, plus pro !
Mon problème si je veux ajouter par exemple, une nouvelle variable d'instance, dans une de mes classes Zoo, Secteur, Cage ou Animal, je dois modifier aussi Xml Reader et XmlWriter avec toutes les erreurs possibles.

D'avance merci pour vos conseils

[djo.mos]

Salut,
Un truc déjà : pourquoi faire Hériter Xml(Reader|Writer) de tes objets Zoo et co ? Je trouve pas ça très propre.
Dans ton cas, ces objets servent à stocker les données, pas à avoir un comportement, qui plus est est spécifique à la persistence (xml dans ton cas).

Une approche beacoup plus propre amha serait de créer des classes Codec : ZooXmlCodec, SecteurXmlCodec, etc. avec des méthodes encode/decode.

Pour un maximum de réutilisabilité, je ferais en sorte que encode prend l'objet et rend un Element (xml), tandis que decode prend un Element et rend l'objet.

De cette façon, tu peux utiliser un codec dans un autre codec (ZooXmlCodec puet utiliser SecteurXmlCodec pour sérialiser ses fils dans le meme DOM).

[tchize_]

pour la lecture / écriture en xml, ut peux aussi t'orienter vers des outils tout fait comme xstream, que tu n'aura plus qu'à configurer pour avoir le format voulu.

[pingoui]

Salut,

Merci pour vos conseils.
Pour Xstream, j'ai été fortement séduit par la simplicité de cette API. Mais je me suis freiné lorsque j'ai utilisé une API du même type (Castor).

Je programme une application RCP et apparemment, il y a des problèmes de compatibilité entre le rongeur et eclipse. J'ai fait (peut être à tord) le rapprochement avec XStream.

De plus après la sérialisation/désérialisation, je cherche, modifier plusieurs noeuds de mon arbre. Je me demande si cela va pas me bloquer plus tard.
Dois-je réécrire complètement l'arbre dès que je modifie un objet?

Si XStream correspond à mes besoins, je suis plus que partant pour l'adopter

D'avance merci

[tchize_]

avec xstream tu devra effactivement refaire le rendu lorsque tu modifie un élément. Il ne fait pas de lien "arbre d'objet" <-> "arbre dom", au contraire, il prend un arbre d'objet et fait un rendu xml et vis versa (en fait il est pas limité au xml, y a un rendu json aussi si ma mémoire est bonne).

Si tu veux avoir un arbre dom dynamique en // à ton arbre d'objet va falloir y aller à la mano, mais je suis pas sur que ce soit utile de devoir garder les deux en mémoire.

[pingoui]

Salut,

J'ai opté pour avoir un arbre dynamique et donc faire cela à la main

J'ai donc créer une Classe XmlCodec qui permet d'écire et parser les xml

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
 
public class XmlCodec {
 
	private static Document document;
	private static Element racine;
 
	public static  void readXml(Zoo zoo){
		// On crée une instance de SAXBuilder
		SAXBuilder sxb = new SAXBuilder();
		try {
			// On crée un nouveau document JDOM avec en argument le fichier XML
			document = sxb.build(new File("Zoo.xml"));
			// Le parsing est terminé
		} catch (Exception e) {
			e.printStackTrace();
		}
 
		// On initialise un nouvel élément racine avec l'élément racine du
		// document.
		racine = document.getRootElement();
		//On parcours les différents noeuds de l'arbre
		SecteurCodec.readSecteur(zoo,racine);
	}
 
 
	public static void writeXml(Zoo zoo){
		racine = new Element("explorer");
		SecteurCodec.writeSecteur(zoo,racine);
		document = new Document(racine);
 
		try {
			// On utilise ici un affichage classique avec getPrettyFormat()
			XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
			// Sérialisation
			sortie.output(document, new FileOutputStream("ZooBis.xml"));
		} catch (java.io.IOException e) {
		}
	}
 
}

Ensuite, j'ai crée une classe par objet à sérialiser (Secteur, Cage, Animal)
SecteurCodec.java

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public class SecteurCodec {
 
 
	/**
         * Permet d'écrire les enfants "secteur" du zoo
         */
	protected static void writeSecteur(Zoo zoo,Element racine){
///// ici le code pour écrire les secteurs
			CageCodec.writeCage(secteur,secteurElement);
 
///// le reste du code
	}
}

J'ai donc maintenant CageCodec, AnimalCodec sur le même principe que SecteurCodec.

Est-ce déjà plus propre ? plus pro

Merci pour vos conseils