Discussion :

[OSryx]

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

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

[tchize_]

les designs pattern dans une architecture sont de plus sont un outils, un moyen. Certainement pas un objectif!

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

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

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

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

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

[OSryx]

Bon voici le code :

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

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

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


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

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

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