Generation de code a partir de SQL

Version imprimable

08/06/2006, 11h43
RemiRoques

Generation de code a partir de SQL

Je travaille sur un projet de simulateur. Toutes les données de la simulation sont stockées dans une base SQL.

Je chercher à générer du code Java à partir des données de la base. Le simulateur ensuite compilé pourra tourner sans la base, seulement grâce au code généré (le simulateur est censé être embarqué sur un ordi ou la base de données ne sera pas présente ...).

Avez vous des idées, outils, méthodes pour générer une telle application de génération de code ?
Merci
08/06/2006, 14h40
sinok

Au pire tu peusser passer par un base de données embarquée en java comme hsqldb ou derby...
Tu devras juste effectuer une migration des données, et ton code ne vaireras pas énormément (juste le driver à changer si tu as fait ça de manière propre ^^)
08/06/2006, 15h03
RemiRoques

En gros, on me demande d'utiliser la base de données pour connaître les données de la simulation et d' ensuite générer un executable tournant independamment de la base.
Alors j aurais bien aimé garder la base ou la transférer vers une base de donnée "légère" mais ... pas le choix malheureusement.
08/06/2006, 15h12
g_rare

Tu peux créer des fichiers .java (encodage UTF-16) à partir de tes requêtes SQL, et les placer dans un répertoire du -classpath : puis les charger en mémoire avec "Class.forName()"...
;)
08/06/2006, 15h20
RemiRoques

Je ne comprends pas très bien ... Tu peux m'expliquer d'avantage ?

Mon idée de départ était de parser la base de données et d'écrire dans un fichier .java la création de chaque objet un par un (utilisant des boucles ... ). Les classes représentant les tables de la base seraient préalablement définies. Les objets seraient alors stockés dans une structure de données adequate (arbre ou liste). Ensuite, lors de l éxécution, tous les objets sont créés et la base se retrouve en mémoire.

Je n ai pas encore trouvé d'autres solutions. Mais je reste très ouvert à vos propositions!
08/06/2006, 18h41
fabszn

Hello,

Tu pourrais générer un fichier xml (interessant si tu veux garder une structure dans tes données) contenant l'ensemble des données necessaire à la simulation. Ce fichier serait genéré dans l'arborescence de tes classes pour qu'il soit accessible à coup via le classpath.
Au moment du lancement de ton programme, dans un bloc static, tu pourrais parser ce fichier et créer les objets en les decorant des données récupérées depuis le fichier.

Toutes tes données serait accessible en mémoire via l'ensemble des tes objets.

C'est une idée je pense plus simple à mettre en oeuvre plutot que de passer par de la génération de code...:D

J'espère que celà t'aidera, si tu as des questions n'hesite pas! :D
09/06/2006, 09h51
RemiRoques

Je suis en effet d'accord, ce serait plus simple. Malheureusement j ai qqes contraintes de la part du responsable de projet et la génération de code semble inévitable...

Je pense créer un générateur de simulateur, indépendant du simulateur lui même, qui récupère les données de la base par des requêtes et fait un println(...) dans un fichier java. Le printout écrirait l'instanciation les classes représentant les tables de ma base.

Ensuite le fichier .java créé peut être compilé avec le reste du simulateur (classes de communication, IHM ...). Lors de l' exécution tous les objets représentant les données de la base sont créés (oui il y en aura beaucoup). Tout peut tourner alors sans la base.

Ce n 'est sûrement pas la méthode la plus élégante mais vu la relative petite dimension du projet, je voudrais faire tout assez simplement en utilisant au maximum les librairies sun sans passer par la grosse artillerie d'outils de génération code utilisant patterns, fichiers de grammaire ...

Salutations
09/06/2006, 10h21
fabszn

Hello,

Si contrainte il y a... je comprend! :D

Si tu dois obligatoirement générer du code,
Tu pourrais générer la creation d'un Objet de type Hashmap (enfin une collection contenant des couples clefs valeurs) qui s'initialiserai avec l'ensemble des données nécessaires à la simulation.
Ensuite tu pourrais manipuler cette HashMap pour acceder aux données par l'intermédiaire des clefs.

Cela te permettrai de générer un code assez simple (creation et initialisation de la collection) et dans l'ensemble de ton projet manipuler une interface.

Je ne sais pas si je suis très clair! :oops:

ça me semble en effet une bonne idée.
le code généré ressemblerait a qqchose comme ça (ce n'est peut être pas très explicite pour vous, désolé ...)

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
 
 
/**
*       Class générée automatiquement depuis la base SQL ou autre
*       Peut être un thread éventuellement
*
*
*/
import java.util.*;
 
 
public class Simulator{
 
	private HashMap tests;
	private Config conf; // tel que ATP, QT, mode Single ou random ....
	private Communication comm;
	private WorkingMode wm;
 
 
	/**
        *       Constructeur, 
        *       on récupère la config
        *       on initialise les tests
        *
        */
	public Simulator(Config conf, Communication comm){
		this.conf = conf;
		this.comm = comm;
		wm = new WorkingModeSingle(); // par défault
		tests = new HashMap();
		init();
		wm.add(tests);
	}
 
 
 
	/**
        *       Créé grâce à des requête sur la base
        *       On remplit l'ArrayList tests pour stocker toute la base en mémoire
        */
	public void init(){
 
	//les classes Test et Message ont été généré préalablement 
	//et contiennent les même champs de classes que les colones de la table correspondante dans la BD
	Test t1 = new Test (1, "TestRAM", "F", 7, 1, "F", 000, 000, 00, 00, 0, 00);
	Message m1 = new Message(1, Error, 1, 01, "Send", 0, "Anomalie Bit1, LSB", 0, 0);
	// ajout des params si nécessaire
	t1.add(m1);
	tests.add(t1);
 
	// et ce pour toute la base => beaucoup d 'objet de lignes de code !
 
	}
 
	/**
        *       Grand switch généré automatiquement
        *
        */
	public void simule(){
 
		String cmd = comm.receiveCmd()
 
		// switch sur cmd ou sur un int associé (id du test par exemple, mais nécessite un lookup dans la HashMap)
		switch(cmd){
 
			case cmd:
				wm = conf.getWorkingMode(); //single, random ou scroll
				wm.answer(cmd); // envoie un ou plusieurs messages suivant la commande
				break;
 
			// et ce pour tous les messages entrant		
 
			case default:
				wm.sendErrorProtocol();
 
		}
	}
}

09/06/2006, 11h05
sozie9372

Salut !

+1 pour le XML... J'aurai opté pour une feuille de style XSL permettant de générer n'importe quel type de fichier...
Je m'explique, tu génères ton flux XML à partir de ta BDD. Et ensuite tu la transforme via XSL en Java, très peu de code Java pour une plus grande flexibilité...
bon courage !
+++
Ju
09/06/2006, 16h07
RemiRoques

En effet ça marche très très bien. J ai récupéré une feuille XSL générant du C à partir de l XML et l ai adapté pour générer du Java. ça marche du feu de dieu. je dois encore étudier ça plus en détail mais cette solution me paraît très efficace et relativement facile à mettre en oeuvre pour peu qu on prenne le temps de se former aux transformations XSL.
Merci beaucoup.