Présentation de Springfuse

Jaxio est une société française qui s'est spécialisé dans la génération de code.

Le produit principal s'appelle Celerio. Sa particuliarité est le

Pour pouvoir générer un projet avec SpringFuse, il est nécessaire de remplir quelques conditions :

• Un JDK 5 (ou plus) pour le développement ET le déploiement
• Une installation Maven 2.0.9 sur le poste de développement
• Une base de données
• Un compte Springfuse, gratuit jusqu'à 10 tables

Afin de pouvoir générer un projet avec SpringFuse, il est nécessaire d'avoir le modèle sur lequel SpringFuse va se baser.

Voici le schéma qui sera utilisé dans notre exemple :

CREATE TABLE  `springfuse`.`account` (
  `username` varchar(30) NOT NULL,
  `password` varchar(40) NOT NULL,
  PRIMARY KEY (`username`)
) 

CREATE TABLE  `springfuse`.`auteur` (
  `auteur_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `first_name` varchar(45) NOT NULL,
  `last_name` varchar(45) NOT NULL,
  `picture_content_type` varchar(255) DEFAULT NULL,
  `picture_size` int(10) unsigned DEFAULT NULL,
  `picture_file_name` varchar(255) DEFAULT NULL,
  `picture_binary` blob,
  PRIMARY KEY (`auteur_id`)
) 

CREATE TABLE  `springfuse`.`livre` (
  `livre_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `titre` varchar(45) NOT NULL,
  `sous_titre` varchar(45) DEFAULT NULL,
  `isbn` varchar(13) NOT NULL,
  `langue` enum('FR','EN') NOT NULL DEFAULT 'FR',
  `account_id` varchar(45) NOT NULL,
  PRIMARY KEY (`livre_id`),
  KEY `account_ref` (`account_id`),
  CONSTRAINT `account_ref` FOREIGN KEY (`account_id`) REFERENCES `account` (`username`)
) 

CREATE TABLE  `springfuse`.`livre_auteur` (
  `auteur_ref` int(10) unsigned NOT NULL,
  `livre_ref` int(10) unsigned NOT NULL,
  PRIMARY KEY (`auteur_ref`),
  KEY `livre_ref` (`livre_ref`),
  CONSTRAINT `auteur_ref` FOREIGN KEY (`auteur_ref`) REFERENCES `auteur` (`auteur_id`),
  CONSTRAINT `livre_ref` FOREIGN KEY (`livre_ref`) REFERENCES `livre` (`livre_id`)
) 

CREATE TABLE  `springfuse`.`role` (
  `role_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `role_name` varchar(45) NOT NULL,
  PRIMARY KEY (`role_id`)
) 


CREATE TABLE  `springfuse`.`role_account` (
  `account` varchar(40) NOT NULL,
  `role` int(10) unsigned NOT NULL,
  PRIMARY KEY (`account`,`role`) USING BTREE,
  KEY `FK_role_account_2` (`role`),
  CONSTRAINT `FK_role_account_1` FOREIGN KEY (`account`) REFERENCES `account` (`username`),
  CONSTRAINT `FK_role_account_2` FOREIGN KEY (`role`) REFERENCES `role` (`role_id`)
)

Bien qu'il travaille effectivement sur le modèle SQL, le générateur de SpringFuse ne travaille pas directement sur le code SQL, mais sur un fichier propriétaire représentant cette base de données.

Pour cela, SpringFuse propose un projet Maven (Télécharger le pom) qui va permettre de créer ce fichier.

Avant de lancer le script, il est cependant nécessaire de modifier quelques variables spécifiques à l'environnement.

<!-- ====== PLEASE EDIT THESE 4 VALUES ======== -->
<database.name>springfuse</database.name>
<database.host>localhost</database.host>
<database.user>springfuse</database.user>
<database.password>springfuse</database.password>
<!-- =========================================== -->

• database.name : le nom du schema
• database.host : le nom de la machine sur lequel se trouve la base de données
• database.user : le nom de l'utilisateur
• database.password : le mot de passe de celui-ci

Une fois cette tache réalisée, une simple commande permet de lancer l'introspection :

mvn -Pmysql initialize

Le paramètre -Pmysql active le profile Mysql du POM, qui est le moteur utilisé dans notre cas. D'autre profiles existent : postgresql, oracle, h2, hsql, derby.

Le résultante est un fichier data-model.springfuse.

Ce fichier sera utilisé parSpringFuse afin de générer un nouveau projet.

Pour cela, certains informations doivent être fournies :

• Project name : Le nom du projet, doit être unique
• Java Package : Le nom du package racine du projet, dans lequel tout les sous package seront crées
• data-model.springfuse : le fichier précédemment généré
• Spring fuse's generator version : 2.8.15 pour un projet basé sur JPA, 2.7.4 pour un projet basé sur Hibernate
• Comment : TODO

Une fois la génération terminée, une page récapitule le contenu du projet :

Un email de notification est également envoyé à la fin de la génération.

Le projet est disponible sous la forme d'une archive zip téléchargeable.

Un projet généré est géré par Maven, et est préconfiguré avec un lot de plugin. Parmi ceux-ci, le plugin Jetty permet de tester visualiser le résultat, sans avoir serveur ou IDE complémentaire.

Tout d'abord, il est nécessaire de modifier une fois encore le fichier POM pour spécifier les informations de connexion à la base de données :

<!-- ====== PLEASE EDIT THESE 4 VALUES ======== -->
<!-- Note: during development using the same value for your login, password,
database name and project name is really convenient -->
<database.name>springfuse</database.name>
<database.host>localhost</database.host>
<database.user>springfuse</database.user>
<database.password>springfuse</database.password>

Pour lancer le jetty :

mvn -Pmysql

Par défaut, le plugin Jetty écoute sur le port 8080, et le projet est visible sur l'adresse http://localhost:8080/

Afin de continuer et de voir la page d'administration, il est nécessaire de s'authentifier.
Nous le verrons plus loin en détail, mais si aucune table d'utilisateurs n'est trouvé par SpringFuse, celui-ci génère un Mock d'authentification avec deux utilisateurs en dur : admin/admin et user/user.

Une fois connecté comme administrateur, un menu propose divers options