Groovy and Grails
Créer une application avec Grails
Les commandes grails
Voici les différentes commandes qui servent à créer une application avec Grails.
- grails create-app myApp :
Cette commande est la première que l'on tape lorsque l'on crée notre application. Elle permet de créer tous les dossiers de l'application web. - grails create-domain-class my.pckg.DomainClass :
Permet de créer une classe de domaine. - grails generate-controller my.pckg.DomainClass :
Génère le contrôleur par défaut pour le domaine précisé en argument. - grails generate-views my.pckg.DomainClass :
Génère les vues par défaut pour le domaine précisé en argument. - grails create-service my.pckg.ServiceName :
Permet de créer une classe vide pour y implémenter un service. - grails clean :
Permet de nettoyer le répertoire de l'application. Cela peut être utile lorsque l'on pense que l'application n'a pas un comportement normal. - grails run-app :
Permet de démarrer le serveur.
Le scaffolding
Le mot "scaffolding" signifie échafaudage en anglais. C'est le nom de la méthode par laquelle
les vues, les domaines, et les contrôleurs sont générés.
Pour chaque domaine, voici le type de vues et d'actions qui sont implémentées par défaut :
- Création
- Edition
- Suppression
- Affichage
- Liste
Le scaffolding peut être :
- dynamique : les contrôleurs et les vues ne sont pas générés en tant que fichiers. On obtient les comportements par défaut.
- statique : les contrôleurs et les vues sont générés. Il est possible de les modifier pour les adapter à ses propres besoins.
Voici une capture vidéo démontrant la force du scaffolding :
Controller
Le contrôleur est la classe qui reçoit la requête de l'utilisateur et qui, en fonction de l'action demandée, va effectuer un traitement. Ces traitements peuvent être sous-traités par la suite à un service.
Pour gérer quelle est l'action et quel contrôleur est appelé Grails se base sur le formatage de l'URL : http://<...>/controller/action/
Des exemples complets de contrôleurs sont disponibles en annexe.
Domain
Les classes de domaine servent à modéliser les données et a établir les relations avec les autres domaines. Cela permet d'établir le mapping entre les Objets et le schéma Relationel.
Elle définissent le comportement de l’application et facilite la validation des formulaires.
Il est possible d'effectuer des requêtes de base sur les domaines.
On trouve sur chaque domaines des méthodes get(), save(), list(), findByFirstname(), etc...
Ces méthodes n'ont jamais été définies par le développeur, mais elles existent grâce au MOP.
Validation
Il est possible de contrôler la validation des formulaires depuis le fichier qui définit le domaine.
Des contraintes existent par défaut. L'utilisation d'expressions régulières en est un exemple. On peut aussi créer nos propres contraintes.
Voici un exemple de définition de contrainte :
Ici, on vérifie que :
- les champs firstname, lastname, emailAdress et password ne sont pas vides.
- le champ emailAdress est unique dans la base.
- le champ password2 est identique au champ password. (exemple de contrainte définie par le développeur)
- le dernier champ respecte une expression régulière d'un code postal.
Voici les erreurs que l'ont peut obtenir si le formulaire est mal rempli.
Les messages d'erreurs peuvent être personnalisés à l'aide d'un fichier d'internationalisation.
Les services
Les services sont des objets Groovy chargés d'effectuer un traitement spécifique. Ils ont
la particularité d'avoir une durée de vie plus ou moins longue selon le "scope" qu'on leur définit.
Voici les différents scope que l'on peut avoir (Du plus long au plus court) :
- singleton
- session
- conversation
- flow
- flash
- request
- prototype
Voici l'exemple d'un service d'envoi de mails de confirmation d'inscription.
Ce service a une durée de vie infinie car il a un scope "singleton".
Il utilise lui-même un autre service fourni par Spring : "mailService".
class EmailConfirmationService implements InitializingBean, ApplicationContextAware {
static scope="singleton"
boolean transactional = true
ApplicationContext applicationContext;
def mailService;
Template template;
void afterPropertiesSet(){
def userTemplate = applicationContext.getResource("emailConfirmation.gtpl").getFile();
SimpleTemplateEngine templateEngine = new SimpleTemplateEngine();
template = templateEngine.createTemplate(userTemplate);
}
void send(Student student){
EmailToken token = new EmailToken(student:student, controller:"student", action:"complete");
token.save();
def binding = [ 'student' : student, 'token' : token, 'serverURL' : ConfigurationHolder.config.grails.serverURL ]
def mailHtml = template.make(binding);
mailService.sendMail {
to "${student?.firstname} ${student?.lastname} <${student.emailAddress}>"
subject "Inscription : ${student?.firstname} ${student?.lastname}"
html mailHtml;
}
}
}
Les vues
Les vues sont représentées par des fichiers GSP (Groovy Server Page).
Elles sont similaires aux pages JSP. La différence vient du fait qu'on peut insérer du code Groovy.
On constate dans l'arborescence qu'il y a une vue dédiée à chaque action.
Un fichier permettant de décrire le design principal est présent dans le répertoire layouts. Il est
utilisé par SiteMesh pour décorer les pages.
La taglib Grails
La TagLib fournie par Grails permet de créer des applications web riches. Beaucoup de ces tags utilisent l'Ajax.
Certains sont basés sur des framework javascript tel que "prototype" ou "dojo".
Voici ce que l'on peut réaliser comme type de formulaires grâce à cette taglib.
Les plugins
Une liste d’extensions est disponible sur le site de Grails.
- Service de mail
- Authentification
- Moteur de recherche
- RSS
- Paiement en ligne
- etc...
Il est aussi possible de créer sa propre extension.
L'installation est simple. Elle se fait en utilisant un système de repository. C'est assez similaire à la commande apt-get de Debian.
En voici une démonstration :