Comme indiqué dans le précédent article, le Play!framework est une avancée notable dans le paysage Java. C'est en effet un framework Agile de développement d'application web, proposant certains précepts en vogue aujourd'hui dans le paysage du web: a savoir, le pattern MVC, la persistance via JPA, des annotations à foison, le principe de règles de notations plutôt que configuration, et j'en passe, et des meilleures. Bref, tout ce que d'autre framework basés sur d'autres langages proposent depuis quelques temps déjà.
Editons dans l'arborescence du projet créé le fichier myplayapp/conf/application.confet remplaçons dans les lignes suivantes:
Remplaçons la ligne du db=mem par un db=fs et supprimons le #, ceci afin d'avoir une persistance temporaire dans une base de données sur le système de fichier, et non pas en mémoire, ce qui est un peu trop volatile à mon goût. Ce qui donne:
Vérifions que celle-ci est opérationnelle avec la commande :
et accédons l'url http://localhost:9000/
figure 0 - Premier pas dans le monde de Play!
- Ajoutons au dessus des attributs title, description, yearOfPublication l'annotation @Required, indiquant le caractère "indispensable" de la présence de valeur pour ces attributs.
Et ouvrez votre navigateur (Firefox, Chrome, Safari, IE ?) sur l'url http://localhost:9000/@tests !
La page appraissant à l'écran vous propose de lancer les tests souhaités. choisissez EntitiesTest et cliquez sur "Start !".
figure 6 - Lancement des tests unitaires via l'interface Web de Play!
Le test choisi déroulé, le résultat de celui-ci apparait dans la même page:
figure 7 - Résultat du test unitaire exécuté
Il faut bien avouer que c'était un atout qui manquait sévèrement à notre langage favori qu'est Java. Mais c'est maintenant un retard comblé par Play!.
Première application
Ok, nous allons nous pencher sur la création de notre première application. Pour commencer, assurons nous que notre framework est bien installé.
Installation
Téléchargez l'archive contenant le framework et dézippez la dans le répertoire de votre choix sur votre machine; par exemple dans ~/tools/play si vous êtes sous Linux/Ubuntu oubien sur D:\tools\play sous Windows.
Ensuite, ajoutez ce nouveau chemin à votre chemin système.
Sous Linux, éditer votre fichier ~/.bashrc, et ajouter en fin de fichier
export PATH=%PATH%:~/tools/play:.
sous Windows, éditer vos variables système (Propriété du poste de travail, onglet "Avancé", boutons "variables systèmes" et modifier l'entrée PATH en ajoutant à la fin
;D;\tools\play;.
et le tour est joué.
Création de l'application
fermez puis relancer votre session utilisateur pour être sur que la nouvelle valeur de PATH soit bien prise en compte.
enfin,ouvrez une console de commande (Windows) ou un terminal (Linux) et tapez :
mkdir ~/Projects/Java/playcd ~/Projects/Java/playplay new myplayapp
La console indique alors :
frederic@nostromo6:~/Projects/Java/play$ play new myplayapp
~ _ _~ _ __ | | __ _ _ _| |~ | '_ \| |/ _' | || |_|~ | __/|_|\____|\__ (_)~ |_| |__/~~ play! 1.1, http://www.playframework.org~~ The new application will be created in /home/frederic/Projects/Java/play/myplayapp~ What is the application name? [myplayapp]~~ OK, the application is created.~ Start it with : play run myplayapp~ Have fun!~
Editons dans l'arborescence du projet créé le fichier myplayapp/conf/application.confet remplaçons dans les lignes suivantes:
# Database configuration
# ~~~~~
# Enable a database engine if needed.
#
# To quickly set up a development database, use either:
# - mem : for a transient in memory database (HSQL in memory)
# - fs : for a simple file written database (HSQL file stored)
#db=mem
#
# ~~~~~
# Enable a database engine if needed.
#
# To quickly set up a development database, use either:
# - mem : for a transient in memory database (HSQL in memory)
# - fs : for a simple file written database (HSQL file stored)
#db=mem
#
Remplaçons la ligne du db=mem par un db=fs et supprimons le #, ceci afin d'avoir une persistance temporaire dans une base de données sur le système de fichier, et non pas en mémoire, ce qui est un peu trop volatile à mon goût. Ce qui donne:
# Database configuration
# ~~~~~
# Enable a database engine if needed.
#
# To quickly set up a development database, use either:
# - mem : for a transient in memory database (HSQL in memory)
# - fs : for a simple file written database (HSQL file stored)
db=fs
#
# ~~~~~
# Enable a database engine if needed.
#
# To quickly set up a development database, use either:
# - mem : for a transient in memory database (HSQL in memory)
# - fs : for a simple file written database (HSQL file stored)
db=fs
#
Vérifions que celle-ci est opérationnelle avec la commande :
play run
et accédons l'url http://localhost:9000/
figure 0 - Premier pas dans le monde de Play!
Voila, l'application est créée... Trop dur !
Éditeur et/ou IDEs
Ok, maintenant, pour pouvoir travailler proprement, je vous propose d'utiliser Eclipse. Partons sur Galileo (Eclipse 3.5) pour commencer. Mais si vous avez un préférence pour Netbeans, pas de soucis.
1. Eclipse
la commande magique suivante permet de générer un projet Play! éditable dans Eclipse. Simplement, placez-vous dans le répertoire de votre projet nouvellement créé:
cd ~/Projects/Java/play/myplayappplay eclipsify .
ce qui donne dans la console:
frederic@nostromo6:~/Projects/Java/play/myplayapp$ play eclipsify .~ _ _~ _ __ | | __ _ _ _| |~ | '_ \| |/ _' | || |_|~ | __/|_|\____|\__ (_)~ |_| |__/~~ play! 1.1, http://www.playframework.org~~ OK, the application is ready for eclips~ Use File/Import/General/Existing project to import /home/frederic/Projects/Java/play/myplayapp into eclipse~~ Use eclipsify again when you want to update eclipse configuration files.~ However, it's often better to delete and re-import the project into your workspace since eclipse keeps dirty caches...~
Maintenant, ouvrez votre Eclipse préféré dans une workspace de votre choix (ex: ~/workspaces/java/play/myplayapp).
figure 1 - Ouverture d'un nouveau workspace pour importer notre projet Play!
Puis, via le menu contextuel dans l'explorateur de projet (sidebar de gauche...) faite "Import > Import..." puis dans la fenêtre affichée, choisissez "Existing projects into Workspace".
figure 2 - Import du projet play "eclipsifié" dans votre workspace
Parcourez le répertoire de votre projet et valider.
figure 3 - Projet play détecté par Eclipse (3.5 ici) et prêt à être importé
Un click sur Finish, et voilà votre projet importé, et prêt a être éditer dans Eclipse
figure 4 - Eclipse présentant votre projet Play! fraîchement importé
Et voilà !
Sous NetBeans, la proécédure est très similaire, la commande permettant de créer la définition du projet Netbeans étant la suivante:
cd ~/Projects/Java/play/myplayappplay netbeanify .
Ce qui trace dans la console:
frederic@nostromo6:~/Projects/Java/play/myplayapp$ play netbeansify .~ _ _~ _ __ | | __ _ _ _| |~ | '_ \| |/ _' | || |_|~ | __/|_|\____|\__ (_)~ |_| |__/~~ play! 1.1, http://www.playframework.org~~ OK, the application is ready for netbeans~ Just open /home/frederic/Projects/Java/play/myplayapp as a netbeans project~~ Use netbeansify again when you want to update netbeans configuration files, then close and open you project again.~
Je laisse les aficionados de NetBeans procéder à l'import du projet dans l'IDE de Sun (sic... Oracle), ne connaissant pas aujourd'hui moi-même la procédure.
Entités et autres contrôleurs
C'est une application de gestion de liste de jeux vidéo que nous allons créer, au fait !
Et donc, de quoi avons nous besoin pour modéliser notre bibliothèque de jeux vidéo ? Disons, une entité représentant un jeu, et une entité pour désigner la plateforme d'accueil de ce jeu. C'est un bon début.
Et si on souhaite en faire une vraie application internet, il nous faut, pour pouvoir la sécuriser, une entité représentant un utilisateur.
En plus de ces entité, nous bâtirons l'application sur 1 contrôleur principale, gérant la page d'accueil, et, à l'aide du module CRUD, autant de sous-contrôleurs que d'entités pour la partie administration.
Voilà la liste est faite, plus qu'à se lancer dans le développement de cette magnifique application.
Game
Un jeu est modélisé par un titre, une plateforme (que nous "entité-iserons" plus tard) une description, un éventuel test, une année de production, un studio de développement, un éditeur (qui pourront devenir à leur tour des entités à part entière d'ici quelques temps), une note, et enfin une image représentant la pochette du jeu.
Précipitons nous sous notre IDE préféré, Eclipse pour ma part, et créons une première classe Game dans le package models. N'oubliez pas d'hériter de la classe Model (play.db.jpa.Model) afin de pouvoir faire persister notre jeu dans une base de données (nous aborderons cela au chapitre suivant). Utiliser l'assistant pour vous faciliter la tâche:
figure 5 - La classe Game héritant de play.db.jpa.Model
Et après un clic sur "finish", ajoutons les choses suivantes:
Tout d'abord,
- l'annotation @Entity indiquant à Java et à JPA que cette classe devra persister.
- Ajoutons les attributs dont nous avons parlé précédemment, à savoir:
- public String title;
- public String platform;
- public String description;
- public Boolean publish;
- public String test;
- public String developerStudio;
- public String editor;
- public Integer yearOfPublication;
- public Integer note;
- public String cover;
Ce qui nous donne a peu de chose près la classe suivante:
/**
* Projet myplayapp
* Entité Game
*/
package models;
import javax.persistence.Entity;
import play.data.validation.Required;
import play.db.jpa.Model;
/**
* Game Classe modélisant un jeu vidéo de la bibliothèque
* @author frederic
*
*/
@Entity
public class Game extends Model {
@Required
public String title;
@Required
public String platform;
@Required
public String description;
public Boolean publish;
public String testContent;
public String developerStudio;
public String editor;
@Required
public Integer yearOfPublication;
public Integer note;
public String cover;
public Game(String title, String description, Boolean publish,
String testContent, String developerStudio, String editor,
Integer yearOfPublication, Integer note, String cover) {
this.title=title;
this.description=description;
this.publish = publish;
this.testContent=testContent;
this.developerStudio=developerStudio;
this.editor=editor;
this.yearOfPublication = yearOfPublication;
this.note = note;
this.cover = cover;
}
}
Voilà une première étape de faite.
Mais avant de pouvoir tester cette chose, codons justement un test unitaire de la classe de persistance et de sa DAO, géré par le framework.
Créons donc une classe de test dans le répertoire de source test et nommons le EntitiesTest:
Notre petite classe est destinée à tester la persistance de nos entitée:
public class EntitiesTest extends UnitTest {
@Test
public void testGame(){
Game game = new Game("MyGame",
"X360",
"My Description game",
true,
"Test of the game",
"My Studio",
"My Editor",
2010,
8,
"public/images/x360/my_game/cover/mygame-cover.jpg");
game.save();
Long id = game.getId();
assertNotNull(id);
}
}
Ok,maintenant, testons notre test ;) et lançons dans la sessions de commandes précédemment ouverte, la ligne suivante:
play test
nota: depuis Eclipse, via la bar d'icônes de debug, cliquez sur le bouton "Run Configurations...", et dans le groupe "Java applications", lancer "Test myplayapp".
Et ouvrez votre navigateur (Firefox, Chrome, Safari, IE ?) sur l'url http://localhost:9000/@tests !
Vous pouvez alors lancer le ou les tests que vous avez créés.
La page appraissant à l'écran vous propose de lancer les tests souhaités. choisissez EntitiesTest et cliquez sur "Start !".
figure 6 - Lancement des tests unitaires via l'interface Web de Play!
Le test choisi déroulé, le résultat de celui-ci apparait dans la même page:
figure 7 - Résultat du test unitaire exécuté
Vous pouvez aussi choisir de lancer l'intégralité des tests unitaires proposés nativement par Play!, ainsi que vos tests "custom".
Pour cela rappelez la page des tests et cliquer sur le lien "select all" puis sur "Start !". Tous les tests natifs sont appelés, y compris un test via Sélénium vérifiant le bon affichage de la page d'accueil de l'application.
figure 8 - Tous les tests ont été lancés et exécutés avec succès
figure 8 - Tous les tests ont été lancés et exécutés avec succès
Conclusion
Nous voilà avec les prémices d'une belle application Play! Nous avons découvert a travars ces premiers pas, la richesse technique et la complétude proposées par ce fabuleux framework Java. Nous découvrirons au prochain épisode notre première page bien à nous et la mis en place des modules CRUD et Security, natif eux aussi à Play! mais non activés par défaut. Vous trouverez ci-joint, l'archive du code correspondant à cet article.
Nous voilà avec les prémices d'une belle application Play! Nous avons découvert a travars ces premiers pas, la richesse technique et la complétude proposées par ce fabuleux framework Java. Nous découvrirons au prochain épisode notre première page bien à nous et la mis en place des modules CRUD et Security, natif eux aussi à Play! mais non activés par défaut. Vous trouverez ci-joint, l'archive du code correspondant à cet article.
