Conception d'un modèle

Version imprimable

11/08/2010, 15h46
OSryx

Conception d'un modèle

Bonjour

J'ai pour objectif d'élaborer une architecture utilisant des Design Patterns. le projet consiste en utilisation de la bibliothèque JFreeChart pour tracer un graphique.

franchement je suis completement perdu ! quelqu'un peut me mettre sur des pistes ??

Cordialement
11/08/2010, 16h42
thelvin

Le site de JFreeChart propose
- de consulter et télécharger la JavaDoc des APIs JFreeChart.
- d'acheter un guide du développeur. Il est très intéressant, notamment parce qu'il inclut le code source de l'application de démonstration, et illustre donc assez clairement comment faire tel ou tel graphique.
11/08/2010, 18h00
tchize_

les designs pattern dans une architecture sont de plus sont un outils, un moyen. Certainement pas un objectif!
11/08/2010, 18h18
OSryx

la documentation payante est deja achetée... j'ai deja implementé certains exemples de ce que je veux faire.

le souci est que j'ai besoin de modulariser, structurer architecturer ( en utilisant les heritages aggrégations, les patterns design..)

et la je sais pas par où commencer ?
11/08/2010, 18h30
tchize_

le point de départ comme toujours c'est la définition des besoin utilisateur. C'est seulement quand on aura une idée claire là dessus qu'on pourra commencer l'architecture.
11/08/2010, 18h33
OSryx
justement c'est exactement par quoi j'ai commencé. Alors voici le résultat : un logiciel (mature) a besoin dans plusieurs de ses vues d'integrer des graphiques cartésiens liés à une JTable.

J'ai bien étudié la philosophie d'utilisation de JFreeChart, elle s'organise de la façon suivante :
- Création d'un 'dataset' contenant l'ensemble des données à afficher dans le graphique
- Création d'un objet JFreeChart responsable de tracer le graphique
- Personnalisation de cette objet pour personnaliser le graphique
- Affichage du graphiqu
devrais-je faire une classe pour chaque étape et les lier ou quelque chose comme ca?
12/08/2010, 09h48
OSryx

ce que j'essaye de vous demander est le suivant ( peut etre j'ai du mal àl'exprimer mais bon)

Comment structurer une portion de code de 15 lignes en plusieurs classes entre liées entre elles ??

ya un ami qui m'a recommandé la méthode des "patates" , je dégage chaque étape ( que j'estime indépendante) en une patate. puis j'étudie les dépendances entre elles !
12/08/2010, 10h50
tchize_

15 lignes de code c'est rien, poruquoi ne pas les garder dans une seule méthodes? Si t'as un soucis avec la structure d'un bout de code, le plus simple est de le montrer.

Bon voici le code :

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
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
83
84
85
86
87
88
89
 
/* 
* (C) Copyright 2010 by Alji
*/
 
/* imports nécessaires*/
import java.awt.BasicStroke;
import javax.swing.JPanel;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.labels.StandardXYToolTipGenerator;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.XYStepRenderer;
import org.jfree.data.xy.XYDataset;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.jfree.ui.ApplicationFrame;
import org.jfree.ui.RefineryUtilities;
 
public class cartesien_escalier extends ApplicationFrame {
 
   public cartesien_escalier(String title) {
       super(title);
       JPanel chartPanel = createDemoPanel();
       chartPanel.setPreferredSize(new java.awt.Dimension(500, 300));
       setContentPane(chartPanel);
   }
 
   private static JFreeChart createChart(XYDataset dataset) {
 
       /* création de l'objet JFreeChart */
       JFreeChart chart = ChartFactory.createXYLineChart(
           "XYStepRenderer Demo 1",
           "X",
           "Y",
           dataset,
           PlotOrientation.VERTICAL,
           true,true,false
       );
 
       /* personnalisation du graphique */
       XYPlot plot = (XYPlot) chart.getPlot();
       plot.setDomainPannable(true);
       plot.setRangePannable(true);
       XYStepRenderer renderer = new XYStepRenderer();
       renderer.setBaseShapesVisible(true);
       renderer.setSeriesStroke(0, new BasicStroke(2.0f));
       renderer.setSeriesStroke(1, new BasicStroke(2.0f));
       renderer.setBaseToolTipGenerator(new StandardXYToolTipGenerator());
       renderer.setDefaultEntityRadius(6);
       plot.setRenderer(renderer);
       return chart;
   }
 
   /* reation d'un dataset pour deux séries donc deux lignes */
   private static XYDataset createDataset() {
       XYSeries series1 = new XYSeries("Series 1");
       series1.add(1.0, 3.0);
       series1.add(2.0, 4.0);
       XYSeries series2 = new XYSeries("Series 2");
 
       series2.add(1.0, 7.0);
       series2.add(2.0, 6.0);
       series2.add(3.0, 9.0);
       series2.add(6.0, 4.0);
       XYSeriesCollection dataset = new XYSeriesCollection();
 
       dataset.addSeries(series1);
       dataset.addSeries(series2);
       return dataset;
   }
 
   public static JPanel createDemoPanel() {
       /* creation du graphique et utilisation de ChartPanel propre à JFreeChart*/
       JFreeChart chart = createChart(createDataset());
       ChartPanel panel = new ChartPanel(chart);
       panel.setMouseWheelEnabled(true);
       return panel;
   }
 
   public static void main(String[] args) {
       cartesien_escalier demo = new cartesien_escalier("JFreeChart: XYStepRendererDemo1.java");
       demo.pack();
       RefineryUtilities.centerFrameOnScreen(demo);
       demo.setVisible(true);
   }
}

comme je l'ai deja mentionné il obeit à la philosophie (4 étapes) d'utilisation de JFreeChart. Mais j'ai besoin de le structurer pour une meilleure réutilisabilité . (parce que je serai emmener à l'implementer dans plusieurs endroit sous différentes formes)

pour l'instant j'ai trouvé une technique interessante pour commencer : Object structure et article interessant : http://www.cs.cmu.edu/~tlatoza/chase10.pdf une expérience petinente ...

vous avez des idées ?

12/08/2010, 13h58
tchize_

première remarque: le nom de classe. Les nom de classes en java doivent obéir pour bien faire à la notation UpperCamelCase, donc ce devrais être CartesienEscalier

L'idéal serait aussi de retirer ces static, qui sont inutiles. Certe tu n'y manipule aucune donnée de l'instance, mais comme ça n'a pas besoin d'être appelé en dehors de l'instance, le static (opinion personelle bien sur) rend les choses confues. De plus en rendant non statique, on pourra par le futur étendre la classe pour redéfinir par exemple la méthode générant le set de données.

Ensuite on pourrait stocker les données et le chart comme attributs d'instance de la classe pour une réutilisation futur (changer les données ou autres). Mis à part ça, je vois pas ce qu'on pourrait chipoter de plus à la classe.
15/08/2010, 14h30
OSryx

Merci tchize_ vous venez de m'éclairer sur un point tres important la qualité de mon code : j'ai repris plusieurs passage, le choix de nomenclature aussi de mes codes sources en notation UpperCamelCase, je me suis aussi debarassé de tous les avertissements et j'ai effectué un nettoyage des packages inutiles ( ya pour cela une fonctionnalité dans Eclipse)

stockage des données et du chart en variables d'instance ne résout pas le probleme . j'explique autrement, prenons l'exemple d'un adaptateur de prise :
http://img39.imageshack.us/img39/5513/adaptateur.jpg

cet adaptateur permet de connecter des lignes électriques suivant la norme américaine (etabli aussi en france) avec deux trous dans une prise de muraille chinoise avec trois trous :) je sais l'exemple est 'bizarre' mais exprime pleinement ce que je veux faire :ccool:

Alors voila, la prise de muraille coté chinois c'est le code du logiciel que j'essaye de lui ajouter l'utilisation de la bibliothèque JFreeChart, l'adaptateur exprime l'ensemble des besoins ( par exemple j'ai besoin d'un objet Chart, d'une source de données..) et le fil electrique coté américain :) est la portion de code qui va dépendre directement de la bibliothèque JFreeChart. Donc si un jour les développeurs décident de changer la bibliothèque JFreeChart par une autre (ILogJViewChart par exemple) ils auront à tout simplement implémenter les besoins du coté américain :)

c'est ainsi que j'ai établi une premiere séparation : la distinction entre Besoins (un package à part), Concret_JFC (package contenant les classes qui vont implementer les besoins et il est en dependance direct avec JFreeChart)

bon j'espere que mon point de vue est bien clair la :mouarf:

la maintenant j'essaye d'extraire les concepts communs entre les différents bibliothèque graphiques comme JFreecHart et tout .

vous avez un document qui aborde un sujet pareil ??