Présentation de Springfuse

Gildas Cuisinier

- Titre : Présentation de Springfuse

- Auteur : Gildas Cuisinier

- Parution : 13 juillet 2009

- Licence : Copyright ® 2009 Gildas Cuisinier. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- Jaxio, Celerio et SpringFuse

- II. Quick start avec SpringFuse

- Pré-requis

- Créer un schéma

- Extraire les métadonnées

- Générer le projet sur SpringFuse

- Tester le projet généré

I - Introduction

Jaxio, Celerio et 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

Les différents possibilités de SpringFuse

II - Quick start avec SpringFuse

Pré-requis

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

Créer un schéma

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`)
)

Extraire les métadonnées

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

Extraction des métadonnées

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.

Générer le projet sur SpringFuse

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

Ecran de génération d'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 :

Status de la génération

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.

Tester le projet généré

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/

Page d'index du projet

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

Zone d'administration