Groovy Server Pages : Qu'est-ce que c'est et Comment ça Marche ?

Vous entendez parler de Groovy Server Pages (GSP) dans le contexte de Grails, mais ne savez pas par où commencer ?

Pas de panique, le concept est simple. Ce guide vous explique comment GSP fonctionne avec des exemples de code clairs.

Qu’est-ce que Groovy Server Pages (GSP) ?

GSP, pour Groovy Server Pages, est une technologie qui sert à créer les pages web que voient les utilisateurs dans une application construite avec le framework Grails. C’est une technologie de rendu côté serveur, ce qui veut dire que le serveur assemble la page HTML avant de l’envoyer au navigateur.

Un fichier GSP est simplement un mélange de balisage standard (comme du HTML) et de code Groovy. Ce code permet d’afficher des données dynamiques. Tous les fichiers GSP se trouvent dans le répertoire grails-app/views de votre projet Grails. C’est la technologie de vue par défaut de cet environnement.

Le principe fondamental : du contrôleur à la vue

Pour bien comprendre GSP, il faut voir comment les données circulent. Le schéma est presque toujours le même : un contrôleur prépare les données, puis il les passe à une vue GSP qui se charge de les afficher.

Le contrôleur rassemble les informations nécessaires dans ce qu’on appelle un « modèle ». Ce modèle est une simple collection de variables. Voici un exemple d’une action de contrôleur qui récupère un livre et le met dans le modèle :

// Dans un fichier contrôleur, par exemple BookController.groovy
def show() {
    [book: Book.get(params.id)]
}

Ici, le contrôleur crée un modèle contenant une seule variable : `book`. Ensuite, Grails utilise par défaut une vue GSP qui porte le même nom que l’action (ici, `show.gsp`) pour l’affichage. Pour utiliser les données du modèle dans le fichier GSP, la syntaxe est directe :

<!-- Dans grails-app/views/book/show.gsp -->
<h1>Titre du livre : ${book.title}</h1>
<p>Auteur : ${book.author}</p>

La syntaxe `${…}` permet d’insérer la valeur d’une variable du modèle directement dans le HTML. C’est le mécanisme de base de GSP.

Mise en place et dépendances

Depuis la version 3.3 de Grails, GSP est un plugin indépendant. Pour l’utiliser dans un projet moderne, vous devez vous assurer que votre fichier de configuration `build.gradle` est correctement paramétré.

D’abord, vous devez ajouter la dépendance au plugin GSP dans la section `dependencies`. Cela permet à votre projet de télécharger les librairies nécessaires.

// Dans build.gradle
dependencies {
    //...
    implementation "org.grails.plugins:gsp:6.2.3"
}

Ensuite, vous devez appliquer le plugin Gradle pour que la compilation des fichiers GSP soit gérée correctement, surtout en production. Cela se fait en ajoutant une ligne au début de votre `build.gradle`.

// Dans build.gradle
apply plugin: "org.grails.grails-gsp"

Avec ces deux éléments en place, votre projet Grails est prêt à utiliser Groovy Server Pages.

Syntaxe et concepts de base de GSP

GSP propose plusieurs manières d’intégrer de la logique et des données dans vos pages. Connaître la syntaxe de base est essentiel pour commencer.

Expressions, scriptlets et commentaires

Il existe différentes balises pour insérer du code Groovy dans une page GSP.

Expressions GSP : C’est la méthode préférée et la plus propre. Elle sert à afficher la valeur d’une expression. La syntaxe est `${expression}`.
<p>Bonjour, ${params.name} !</p>
Sortie de valeur : C’est une syntaxe héritée de JSP, qui fait la même chose. La syntaxe est `<%= expression %>`.
<p>Heure actuelle : <%= new Date() %></p>
Scriptlets : Ils permettent d’exécuter du code Groovy complexe directement dans la page, avec la syntaxe `<% … %>`. Cette pratique est fortement déconseillée car elle mélange la logique et la présentation, ce qui rend le code difficile à maintenir.
Commentaires côté serveur : Pour laisser des notes dans le code GSP qui ne seront pas visibles dans le HTML final, utilisez `<%– … –%>`.
<%-- Ceci est un commentaire pour le développeur --%>

Attention à la sécurité : Afficher directement des données venant d’un utilisateur (comme `params.name`) sans les nettoyer peut créer une faille de sécurité de type Cross Site Scripting (XSS). Grails encode par défaut les sorties des expressions `${…}` pour limiter ce risque.

Variables et portées (scopes)

Vous pouvez déclarer des variables directement dans un GSP avec un scriptlet, même si c’est à utiliser avec modération : `<% def now = new Date() %>`. Vous y accédez ensuite avec `<%= now %>` ou `${now}`.

En plus des variables que vous passez via le modèle, chaque GSP a accès à un ensemble de variables prédéfinies. Elles donnent accès à des informations sur la requête, la session ou l’application :

`application` : Le contexte du servlet (javax.servlet.ServletContext).
`applicationContext` : Le contexte de l’application Spring.
`flash` : L’objet `flash`, pour passer des messages d’une requête à l’autre.
`grailsApplication` : L’objet principal de l’application Grails.
`out` : Le `writer` de la réponse, pour écrire directement dans le flux de sortie.
`params` : L’objet qui contient tous les paramètres de la requête.
`request` : L’objet `HttpServletRequest`.
`response` : L’objet `HttpServletResponse`.
`session` : L’objet `HttpSession`.
`webRequest` : L’objet `GrailsWebRequest`.

Logique et itération

Il est possible d’utiliser des scriptlets pour des boucles ou des conditions, même si les tags GSP (vus plus loin) sont une meilleure option.

Voici un exemple de boucle `each` pour parcourir une liste :

<% [1,2,3,4].each { num -> %>
   <p>Numéro ${num}</p>
<%}%>

Et un exemple de condition `if/else` pour afficher un contenu différent selon un paramètre :

<% if (params.hello == 'true') { %>
  Bonjour !
<% } else { %>
  Au revoir !
<% } %>

Encore une fois, ces exemples montrent ce qui est possible, mais l’approche recommandée est d’utiliser les tags GSP.

Directives de page

Les directives de page, qui commencent par `<%@ page … %>`, permettent de configurer certains aspects du GSP.

La directive la plus courante est `import`, pour rendre des classes disponibles sans avoir à taper leur nom complet.

<%@ page import="java.util.Date" %>
<p>Date : <%= new Date() %></p>

Une autre directive utile est `contentType`, qui permet de changer le type MIME de la réponse. C’est pratique pour générer autre chose que du HTML, comme du JSON ou du XML.

<%@ page contentType="application/json" %>
{"message": "hello"}

La puissance des tags GSP (g:)

La manière la plus propre et la plus maintenable de travailler avec GSP est d’utiliser les Tag Libraries (TagLibs). Grails fournit une bibliothèque de tags par défaut, tous préfixés par `g:`. Ces tags remplacent le besoin d’écrire du code Groovy en scriptlets.

Syntaxe générale des tags

La syntaxe est similaire à celle du HTML. Un tag peut avoir un corps ou être auto-fermant. Les attributs peuvent recevoir des chaînes de caractères ou des expressions Groovy.

Tag auto-fermant : <g:example />
Tag avec un corps : <g:example>Contenu</g:example>
Attributs avec expression : <g:tag attr="${new Date()}" />
Attributs avec une Map : <g:tag attr2="[one:1, two:2]" />

Gestion des variables, de la logique et de l’itération

Les tags GSP offrent des alternatives propres aux scriptlets pour les tâches courantes.

Pour déclarer une variable, on utilise `<g:set>`. On peut aussi préciser sa portée (`scope`).

<g:set var="now" value="${new Date()}" scope="request" />

Les portées possibles sont :

`page` (par défaut) : la variable n’existe que dans la page actuelle.
`request` : la variable existe pour toute la durée de la requête.
`flash` : la variable survit à une redirection.
`session` : la variable est stockée dans la session de l’utilisateur.
`application` : la variable est partagée par tous les utilisateurs.

Pour la logique conditionnelle, on utilise `<g:if>`, `<g:else>` et `<g:elseif>`.

<g:if test="${session.user != null}">
  <p>Utilisateur connecté.</p>
</g:if>
<g:else>
  <p>Visiteur.</p>
</g:else>

Pour les boucles, le tag `<g:each>` est très pratique.

<ul>
  <g:each in="${bookList}" var="book">
    <li>${book.title}</li>
  </g:each>
</ul>

Recherche et filtrage de collections

GSP fournit des tags pour manipuler des collections de données directement dans la vue.

Le tag `<g:findAll>` permet de filtrer une collection selon une condition.

<!-- Affiche uniquement les livres de Stephen King -->
<g:findAll in="${books}" expr="it.author == 'Stephen King'">
  <p>${it.title}</p>
</g:findAll>

Le tag `<g:grep>` est encore plus flexible. Il peut filtrer par type de classe ou avec une expression régulière. Il est aussi capable d’extraire des propriétés en utilisant la syntaxe GPath (par exemple `books.title`).

Création de liens et de formulaires

Générer des URLs et des formulaires est une tâche très courante. Les tags GSP simplifient énormément ce processus.

Pour créer un lien vers un autre contrôleur ou une autre action, on utilise `<g:link>`. Il génère automatiquement la bonne URL.

<g:link controller="book" action="list">Voir la liste des livres</g:link>

Pour les formulaires, le tag `<g:form>` et ses tags associés sont essentiels. Ils aident à créer des formulaires qui s’intègrent parfaitement avec l’architecture Grails.

<g:form name="myForm" url="[controller:'book', action:'save']">
  <!-- champs du formulaire ici -->
</g:form>

Grails fournit une large gamme de tags pour les champs de formulaire :

`textField`, `passwordField`, `hiddenField` pour les entrées de texte.
`checkBox` et `radio` pour les cases à cocher et boutons radio.
`select` pour les listes déroulantes.
Des helpers comme `radioGroup`, `localeSelect`, `currencySelect`, `timeZoneSelect`.

Il est même possible de créer des formulaires avec plusieurs boutons de soumission qui déclenchent des actions différentes, grâce à `<g:actionSubmit>`.

Concepts avancés et bonnes pratiques

Une fois les bases maîtrisées, GSP offre des fonctionnalités avancées pour organiser et réutiliser votre code.

Utiliser les tags comme des appels de méthode

Une fonctionnalité très pratique de GSP est que chaque tag peut être appelé comme une méthode Groovy. Cette méthode retourne une chaîne de caractères contenant le HTML généré.

C’est particulièrement utile pour générer des valeurs à l’intérieur d’attributs HTML, ce qui rend le code plus propre et valide. Par exemple, au lieu d’imbriquer un tag dans un autre, on peut faire ceci :

<img src="${createLinkTo(dir: 'images', file: 'logo.jpg')}" />

Ici, `createLinkTo` est l’équivalent de la méthode pour le tag `<g:createLinkTo>`. Cet appel peut même être fait depuis un contrôleur, en préfixant l’appel par `g.` :

def imageLocation = g.createLinkTo(dir:"images", file:"logo.jpg").toString()

Vues, gabarits (templates) et réutilisabilité

Pour éviter de copier-coller du code HTML, GSP utilise un système de gabarits (templates). Un template est un fragment de GSP réutilisable.

Par convention, le nom d’un fichier template commence par un tiret bas (`_`). Par exemple, `_bookTemplate.gsp`. Pour inclure ce template dans une autre page, on utilise le tag `<g:render>`.

Pour afficher un seul template en lui passant un modèle spécifique :

<g:render template="bookTemplate" model="[book: myBook]" />

Cette approche devient très puissante lorsqu’on l’applique à une collection. Le tag `<g:render>` peut itérer sur une liste et appliquer le même template à chaque élément :

<!-- Affiche chaque livre de la liste en utilisant _bookTemplate.gsp -->
<g:render template="bookTemplate" var="book" collection="${bookList}" />

État actuel du projet GSP

Il est important de noter que le projet GSP a évolué. Depuis Grails 7, le code source de GSP a été déplacé dans un nouveau projet nommé `grails-views`.

Le dépôt GitHub historique, `grails/grails-gsp`, est maintenant archivé. Il est en lecture seule et n’est plus maintenu. Toute nouvelle évolution se fera dans le projet `grails-views`.

Groovy Server Pages reste une technologie de vue simple et efficace pour les applications Grails. Sa force réside dans son intégration avec l’écosystème Grails et sa syntaxe flexible. Pour écrire du code propre et facile à maintenir, il faut privilégier l’utilisation des tags `g:` plutôt que les scriptlets `<% ... %>`. Cette approche sépare bien la logique de la présentation et tire parti de toute la puissance du framework.