Aller au contenu principal

Le framework Grails

Talent HUB Team01/05/2025Environ 12 minCours

Le framework GRAILS

Table des matières

Introduction

Grails est un framework open source de développement agile, né en 2005 et initié par Graeme Rocher. Initialement appelé "Groovy on Rails", il a été renommé Grails et est basé sur le langage Groovy. Il est construit sur un modèle MVC (Modèle-Vue-Contrôleur) et s'est étendu sur d'autres aspects au fil du temps.

Groovy - Le langage sous-jacent

  • Créé en 2003
  • Langage orienté objet pour la plateforme Java
  • Alternative inspirée de Python, Ruby et Smalltalk
  • Intégré et compatible avec la JVM
  • Permet d'utiliser des librairies Java existantes

Avantages de Groovy

Typage dynamique

  • Par défaut dynamique
  • Typage fort possible pour plus de rigueur
  • Utilisation du mot clef « def »
def nombre = 10
def chaîne = "Bonjour"
String phraseTypée = "Je suis typée"

Syntaxe simple

Affichage dans la console / debugging :

println "Hello World"
println(nomVariable)

Collections Groovy

On utilise principalement:

  • Lists : ordonnées, crée un ArrayList au Runtime
  • Sets : contrainte d'unicité, non ordonnés
  • Maps : collection clef-valeur, ordonnée
  • Ranges : intervalle via la syntaxe ".."

Groovy Lists

def liste = [1, 2, 3, 4, 5]
def liste2 = ["a", "b", "c"]

Accès via l'index :

liste[0] // retourne 1

Ajout d'éléments :

liste.add(6)
liste << 7  // opérateur d'ajout

Retrait d'éléments :

liste.remove(2)  // supprime l'élément à l'index 2

Groovy Sets

def ensemble = [1, 2, 3, 3, 4] as Set
// résultat: [1, 2, 3, 4] (les doublons sont éliminés)

Groovy Maps

def map = [clé1: "valeur1", clé2: "valeur2"]

Ajout d'éléments :

map.put("clé3", "valeur3")
map.clé4 = "valeur4"

Retrait d'éléments :

map.remove("clé2")

Groovy Ranges

def range = 1..5  // représente [1, 2, 3, 4, 5]
def alphabet = 'a'..'e'  // représente ['a', 'b', 'c', 'd', 'e']

Manipulations des Collections

Compter les éléments :

liste.size()

Créer un sous-ensemble :

liste[0..2]  // extrait les 3 premiers éléments

Autres manipulations :

liste.findAll { it > 3 }  // trouve tous les éléments > 3
liste.collect { it * 2 }  // multiplie chaque élément par 2

Closures

  • Différentes des méthodes classiques
  • Interprétation de code entre "{" et "}" pour en faire le corps d'une méthode
  • Non liées à une classe
  • Peuvent retourner une valeur
  • Peuvent être assignées à une variable
def fermeture = { paramètre -> 
    // corps de la closure
    return paramètre * 2
}

// utilisation:
def résultat = fermeture(5)  // résultat = 10

Paramètres implicites :

def doubler = { it * 2 }  // 'it' est le paramètre implicite

Closures importantes :

  • sort : tri de collection
  • count : comptage selon un critère
  • collect : transformation d'éléments
  • each : parcours d'éléments

Philosophie de Grails

Les cinq fondamentaux

  1. DRY : Don't Repeat Yourself
  2. Développement rapide et prototypage
  • Scaffolding (génération automatique de code)
  1. Adapté aux gros projets
  2. Architecture orientée modèle
  3. « Convention » plutôt que « Configuration »
  • Exploite la puissance de la JVM (compilation en bytecode Java)

Avantages

  • Web MVC facile à utiliser
  • GSP : Langage de template simple et complet
  • Serveur embarqué
  • GORM : Modélisation et accès aux données
  • Base de donnée simulée (développement)
  • Internationalisation
  • Tests & Tests unitaires
  • Documentation très riche

Créer un projet : 3 étapes

  1. Création des classes de domaine
  2. Scaffold (génération automatique)
  3. Run (exécution)

Plugins

  • Par défaut : Tomcat, Hibernate
  • Utiles : Service de mail, Sécurité, Paiement en ligne, etc.
  • Note : Accélèrent grandement le développement, ne pas en abuser

Architecture de Grails

Architecture de Grails
Architecture de Grails

Évolution des versions de Grails

VersionCaractéristiques principalesFrameworks sous-jacents
2.xRessources plugin, Gant comme système de buildSpring 3.x, Hibernate 3/4
3.xSpring Boot, Gradle comme système de buildSpring Boot 1.x, Hibernate 5
4.xIntégration avec MicronautSpring Boot 2.1, Groovy 2.5
5.xConsolidation et mises à jourSpring Boot 2.5, Groovy 3, Micronaut 3
6.xJava 11 minimum, UI ForgeSpring Boot 2.7, Micronaut amélioré

Différences de configuration entre Grails 2.x et les versions modernes

Grails 2.XGrails 3.X et +Fonction
BuildConfig.groovybuild.gradleConfiguration de build, dépendances, plugins
Config.groovyapplication.groovy/application.ymlConfiguration générale du projet
DataSource.groovyapplication.groovy/application.ymlConfiguration des accès aux bases de données
UrlMappings.groovycontrollers/UrlMappings.groovyConfiguration des schémas d'URL (déplacé)
BootStrap.groovyinit/BootStrap.groovyInitialisation au démarrage (déplacé)

Structure d'un projet

  • assets : Ressources Web
  • config : Configuration
  • controllers : Contrôleurs web
  • domain : Définition du modèle
  • i18n : Internationalisation
  • init : contient le "Bootstrap"
  • services : Couche de service
  • taglib : "Taglibs" personnalisées
  • utils : "Classes codec" (encoders/decoders)
  • views : Groovy Server Pages
  • src : Autres sources (Java/Groovy) et tests
Structure d'un projet Grails
Structure d'un projet Grails

Gestion des ressources

Evolution des plugins de ressources

Ressources (Grails 2.0)

  • Plugin de base inclus depuis la version 2.0
  • Gestion des ressources web (JavaScript, CSS)
  • Optimisation (compression, concaténation)

Assets (Grails 2.4+)

  • Plugin de base inclus depuis la version 2.4
  • Gestion des ressources web (JavaScript, CSS, médias)
  • Optimisation (compression, concaténation)
  • Gestion par groupes ou ressources indépendantes

Exemple de ressources
Gestion de ressources par groupes
Ressources indépendantes
Gestion des liens

Configuration d'une base de données

DataSources (illustration Grails 2.X)

  • Configurations différenciées : Développement / Test / Production
  • Paramètre important dbCreate qui définit le comportement au lancement:
    • create : Crée les tables à chaque démarrage
    • create-drop : Crée puis supprime les tables à l'arrêt
    • update : Met à jour le schéma si nécessaire
Configuration DataSource
Configuration DataSource

Basculer sur une base MySQL

  1. Ajouter le connecteur à votre projet (driver)
  • Directement le JAR
  • Plugin connecteur
  1. Changer la chaîne de connexion

BuildConfig et configuration (Grails 2.X)

  • Configuration des VMs
  • Configurations des dépendances
  • Port de déploiement (grails.server.port = 8081)
  • Configuration des plugins (runtime, build, compile, test, provided)
  • Site officiel des plugins : https://grails.org/plugins/
Configuration BuildConfig
Configuration BuildConfig

Évolution avec Grails 3.X+

Configuration port Grails 3+
Configuration port Grails 3+

UrlMapping

  • Configuration des redirections
    • Expressions régulières
    • Vers des controllers/actions
    • Vers des vues
    • Vers des ressources (API REST)

Configuration UrlMapping
Redirection vers vue
Redirection REST

Définitions complexes et contraintes :

  • $ : permet de pré-nommer des variables
  • Expressions régulières pour des besoins particuliers

Préparation de l'environnement de travail

Les outils à télécharger

  • IntelliJ IDEA Ultimate edition : https://www.jetbrains.com/idea/download/
  • Java 1.8 ou version supérieure (Java 11 minimum pour Grails 6)
  • Grails (version à choisir selon vos besoins : 3.3, 4.x, 5.x ou 6.x)

Gestion des versions de Grails

Autres outils utiles

  • Serveur Apache et SQL : WAMP / XAMP / LAMP
  • MySQL Workbench
  • Navigateur Chrome + Developer Tools ou Firefox + Firebug
  • Outils pour requêtes HTTP & Services REST : curl, Postman
  • Préprocesseurs CSS : SASS / SCSS / LESS
  • Framework CSS : Bootstrap (plugin ou installation manuelle)

Modélisation avec GORM et Hibernate

Hibernate

  • Framework open source de persistance (ORM)
  • Utilisable dans tous les environnements (Client lourd / Web)
  • Remplacement d'une DAL classique
  • Utilisable sur n'importe quel SGBD relationnel

GORM (Grails Object Relational Mapping)

  • Illusion de base de données orientée objet
  • Correspondance monde objet / monde relationnel
  • Appel de méthodes objets de haut niveau:
def book = Book.findByTitle("Groovy in Action")
book
    .addToAuthors(name:"Dierk Koenig")
    .addToAuthors(name:"Guillaume LaForge")
    .save()

Avantages de Hibernate/GORM

  • On accède à des objets métiers au lieu de tables
  • Rapidité de mise en place (petites applications)
  • Syntaxe simple et unique pour tous les SGBD
  • Gestion des transactions
  • Génération et gestion automatique de propriétés
  • Binding poussé
    • Pas de SQL pour des requêtes simples
    • On appelle directement les objets que l'on a créé
  • Méthodes dynamiques

Inconvénients de Hibernate/GORM

  • Peut être difficile à utiliser dans des projets complexes
  • Surcouche, donc perte de performance
  • On ne sait pas ce qu'il se passe derrière
  • Blocage potentiel sans compréhension globale

Création du modèle

  • Définition des attributs
  • Relations (one-to-one, one-to-many, many-to-many)
  • Contraintes
  • Possibilité d'héritage (à éviter si possible - gourmand en ressources)
class Book {
    String title
    Date releaseDate
    
    static hasMany = [authors: Author]
    
    static constraints = {
        title nullable: false, blank: false
        releaseDate nullable: true
    }
}

Modélisation - Héritage

Différentes stratégies d'héritage:

  1. Table-per-hierarchy (par défaut)
  • NOT NULL impossible au niveau de la base de données
  • Possible au niveau métier
  1. Table-per-subclass
  • Performances faibles
  • Mieux pour certains cas d'utilisation

Relations dans GORM

One-to-one

Unidirectionnelle :

class Face {
    Nose nose
}
class Nose {
}

Bidirectionnelle :

class Face {
    Nose nose
}
class Nose {
    static belongsTo = [face: Face]
}

One-to-many

class Author {
    String name
    static hasMany = [books: Book]
}

class Book {
    String title
    static belongsTo = [author: Author]
}

BelongsTo cascade les "deletes" (suppression en cascade)

Many-to-many

class Book {
    String title
    static hasMany = [authors: Author]
}

class Author {
    String name
    static hasMany = [books: Book]
    static belongsTo = Book  // Définit le responsable de la relation
}

Contraintes

static constraints = {
    username nullable: false, blank: false, unique: true
    email email: true, blank: false
    age min: 18
    website url: true
    description maxSize: 1000
}

Mapping personnalisé

static mapping = {
    table 'USER_TABLE'
    id column: 'USER_ID'
    version false
    firstName column: 'FIRST_NAME'
    books lazy: false
    cache true
}

Manipulation des objets

Sauvegarde

objectInstance.save()

Options :

  • flush : quand défini à "true", persiste l'objet immédiatement
  • validate : valide la persistance de l'objet
  • insert : force hibernate à utiliser un INSERT(true) ou un UPDATE(false)
  • failOnError : si la persistance échoue, une exception sera levée
  • deepValidate : définit si les objets fils doivent aussi être validés

Ajout et suppression

// Ajout
vehiculeInstance.addToRoues(new Roue(...))

// Suppression
objectInstance.delete()
// ou
vehiculeInstance.removeFromRoues(roueInstance)

Requêtes GORM

Dynamic Finders

// Récupération par ID
Object.get(id)

// Récupération de tous les objets
Object.list()
Object.getAll()

// Requête sur propriété
Object.findByName("lenom")
Object.findAllByName("lenom")

Where Queries

Plus flexible que les "Dynamic Finders", moins verbeux que les "Critères".

Simple :

def books = Book.where { title == "The Stand" }.list()

Complexe :

def books = Book.where {
    (title =~ "%Grails%" || author.lastName == "Smith") && 
    releaseDate > startDate && 
    releaseDate < endDate
}.list(sort: "title", order: "asc")

Critères

Mode de requête permettant de construire des requêtes complexes :

def books = Book.createCriteria().list {
    eq("author.id", 1)
    between("releaseDate", startDate, endDate)
    or {
        like("title", "%Grails%")
        eq("publisher", "Manning")
    }
    order("title", "asc")
}

Comparaison des modes de requête

Where QueriesCritèresDescription
==eqÉgalité stricte
!=neDifférence
>gtSupérieur à
<ltInférieur à
>=geSupérieur ou égal à
<=leInférieur ou égal à
ininListEst contenu dans la liste fournie
==~likeLike SQL case sensitif
=~ilikeLike SQL non case sensitif

Contrôleurs

Structure de base

  • Peut contenir plusieurs méthodes
  • Méthode = Action
  • Chaque action = une URI dans le modèle par défaut (UrlMapping)
  • Action par défaut : index (si présente)
class BookController {
    def index() {
        [books: Book.list()]  // retourne un modèle à la vue
    }
    
    def show(Long id) {
        def book = Book.get(id)
        [book: book]
    }
}

Scopes dans les contrôleurs

  • servletContext : Portée application, instance de ServletContext
  • session : Portée session, association d'état avec un utilisateur via cookies, instance de HttpSession
  • request : Portée requête, stockage d'objets pour la requête, instance de HttpServletRequest
  • params : Portée requête, tableau associatif contenant les paramètres
  • flash : Temporaire, durée de vie de deux requêtes (courante et suivante)
def action() {
    session.user = User.get(params.id)
    flash.message = "Utilisateur connecté avec succès"
    redirect(action: "dashboard")
}

Retourner un objet

def show(Long id) {
    def poiInstance = Poi.get(id)
    respond poiInstance  // Retourne format approprié selon le content-type
}

Utilisation de withFormat pour spécifier des formats différents:

def show(Long id) {
    def poiInstance = Poi.get(id)
    withFormat {
        html { respond poiInstance }
        json { render poiInstance as JSON }
        xml { render poiInstance as XML }
    }
}

Intercepteurs

Dans Grails 2.X

Directement dans le contrôleur:

def beforeInterceptor = {
    log.debug "Executing action $actionName with params $params"
}

def afterInterceptor = { model ->
    log.debug "Finished executing action $actionName"
    return model
}

Dans Grails 3.X+

Classe séparée:

class SecurityInterceptor {
    SecurityInterceptor() {
        matchAll().excludes(controller: "public")
    }
    
    boolean before() {
        if (!session.user) {
            redirect(controller: "login", action: "auth")
            return false
        }
        return true
    }
}

Bootstrap

  • Initialisation des données au lancement de l'application
  • Pratique avec dbCreate: create-drop pour réinitialiser à chaque lancement
  • Utiliser les options de persistance immédiate (flush, failOnError)
  • Utiliser des services pour la création des entités
// Bootstrap.groovy
def init = { servletContext ->
    def adminRole = new Role(authority: 'ROLE_ADMIN').save(flush: true, failOnError: true)
    def userRole = new Role(authority: 'ROLE_USER').save(flush: true, failOnError: true)
    
    def adminUser = new User(username: 'admin', password: 'password').save(flush: true, failOnError: true)
    UserRole.create(adminUser, adminRole, true)
}

Services

  • Contiennent la logique métier
  • Souvent transactionnels
  • Utilisent l'annotation @Transactional / @NotTransactional
  • Rollback sur un throw d'une RuntimeException
@Transactional
class BookService {
    Book save(Book book) {
        book.save(flush: true, failOnError: true)
        return book
    }
    
    @NotTransactional
    List<Book> search(String query) {
        Book.where { title =~ "%${query}%" }.list()
    }
}

Scopes des services

  • Singleton (défaut) : une seule instance pour toute l'application
  • Prototype : une nouvelle instance à chaque injection
  • Request : une nouvelle instance par requête
  • Flash : une nouvelle instance pour la requête courante et la suivante
  • Flow : une nouvelle instance par "web flow"
  • Conversation : une nouvelle instance par conversation (ensemble de flows)
  • Session : une nouvelle instance par session HTTP

Injection de dépendances

class BookController {
    // Injection par convention
    BookService bookService
    
    def list() {
        [books: bookService.list()]
    }
}

Taglibs

  • Balises personnalisées
  • Factorisation du code dans les vues
// Définition
class MyTagLib {
    static namespace = "custom"
    
    def salut = { attrs, body ->
        out << "Bonjour ${attrs.nom ?: 'inconnu'}"
        out << body()
    }
}

// Utilisation dans une GSP
<custom:salut nom="John">
    contenu optionnel
</custom:salut>

Sécurité dans Grails

Mécanismes de base

  • Tous les accès via GORM sont systématiquement "escaped" (protection contre injections SQL)
  • Formulaires générés via scaffolding "escaped" à l'affichage
  • Liens générés via tags (link, form, createLink, createLinkTo) préviennent l'injection
  • Codecs disponibles pour "escape" les données (.encodeAsHTML())

Précautions avec les requêtes

Utiliser des paramètres positionnés ou nommés:

// Mauvaise pratique - risque d'injection
def users = User.executeQuery("from User where username='${params.username}'")

// Bonne pratique
def users = User.executeQuery("from User where username=?", [params.username])
// ou
def users = User.executeQuery("from User where username=:username", [username: params.username])

Spring Security

Plugin populaire pour la gestion de l'authentification et des autorisations:

  1. Ajout de la dépendance
  2. Exécution du script d'initialisation:
    grails s2-quickstart fr.mbds.tpgrails User Role UserRole
  3. Configuration dans application.yml (ou Config.groovy pour Grails 2.x)

Service de sécurité

class MonController {
    def springSecurityService
    
    def action() {
        def currentUser = springSecurityService.currentUser
        def isLoggedIn = springSecurityService.isLoggedIn()
        // ...
    }
}

Différentes méthodes de sécurisation

  1. Annotations:
@Secured(['ROLE_ADMIN'])
def adminAction() {
    // Action sécurisée
}
  1. Static Rules:
static rules = [
    [pattern: '/admin/**',     access: ['ROLE_ADMIN']],
    [pattern: '/api/**',       access: ['ROLE_API']],
    [pattern: '/**',           access: ['permitAll']]
]
  1. Intercept URL Map:
grails.plugin.springsecurity.interceptUrlMap = [
    [pattern: '/admin/**',     access: ['ROLE_ADMIN']],
    [pattern: '/api/**',       access: ['ROLE_API']],
    [pattern: '/**',           access: ['permitAll']]
]

Grails Moderne (Versions 3.x à 6.x)

Grails 3: Transition vers Spring Boot

Grails 3 a représenté un changement majeur avec l'adoption de Spring Boot comme fondation.

Changements principaux:

  • Système de build: Passage de Gant à Gradle
  • Structure du projet: Réorganisation alignée avec Spring Boot
  • Configuration: Passage de Config.groovy à application.yml/application.groovy
  • Profils d'application: Introduction pour différents types d'applications
  • Asset pipeline: Amélioration de la gestion des ressources

Grails 4: Intégration avec Micronaut

Grails 4 a marqué l'intégration avec Micronaut, un framework optimisé pour les microservices.

Caractéristiques:

  • Micronaut beans: Injection dans applications Grails
  • Spring Boot 2.1: Mise à jour majeure
  • Groovy 2.5: Support amélioré
  • GORM 7: Performances optimisées
  • Java 8 minimum: Prérequis technique

Utilisation de Micronaut dans Grails 4

// Dans build.gradle
dependencies {
    implementation "io.micronaut:micronaut-http-client"
}

// Client HTTP déclaratif
@Client("https://api.example.com")
interface ExampleClient {
    @Get("/data")
    String getData()
}

// Injection dans un service
class ExampleService {
    ExampleClient exampleClient

    String fetchData() {
        return exampleClient.getData()
    }
}

Grails 5: Consolidation

Mises à jour majeures:

  • Groovy 3: Support du nouveau parseur Parrot
  • Micronaut 3: Intégration améliorée
  • Spring Boot 2.5: Nouvelles fonctionnalités
  • Gradle 7: Build system modernisé
  • Autowiring par type: Remplacement de l'autowiring par nom

Grails 6: Java 11 et améliorations

Nouveautés:

  • Java 11 minimum: Performances et sécurité améliorées
  • Spring Boot 2.7.12: Mise à jour majeure
  • Grails Forge UI: Interface moderne pour création de projets
  • CLI repensée: Basée sur Picocli et le moteur Rocker

Déploiement et Conteneurisation

Options modernes

  • JAR autonome: "Make JAR, not WAR"
  • Conteneurs Docker: Isolation et portabilité
  • Cloud Platforms: AWS, Google Cloud, Azure
  • Kubernetes: Orchestration des conteneurs

Exemple de Dockerfile pour Grails 6

FROM openjdk:11-jdk-slim

WORKDIR /app
COPY build/libs/myapp-0.1.jar application.jar
EXPOSE 8080
ENTRYPOINT ["java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/app/application.jar"]

Performances et Optimisations

Conseils d'optimisation

  1. Compilation statique:
@CompileStatic
class OptimizedService {
    // Code compilé statiquement, plus rapide
}
  1. Requêtes GORM optimisées:
// Éviter les requêtes N+1
def books = Book.findAll { author.id == 1 }
// Préférer
def books = Book.where { author.id == 1 }.join('author').list()
  1. Caching:
@Cacheable('books')
List<Book> getAllBooks() {
    return Book.list()
}
  1. Contrôle du lazy loading:
static mapping = {
    author lazy: false  // Chargement eager
    comments lazy: true  // Chargement lazy
}

Documentation et Références

Documentation officielle

Migration entre versions

De Grails 2.x à Grails 3.x

La migration de Grails 2.x vers Grails 3.x représente un changement majeur en raison de l'adoption de Spring Boot:

  1. Système de build: Passer de BuildConfig.groovy à build.gradle
  2. Configuration: Migrer de Config.groovy vers application.yml/application.groovy
  3. Structure du projet: Adapter à la nouvelle structure basée sur Spring Boot
  4. Plugins: Vérifier la compatibilité et mettre à jour les dépendances
// Exemple de build.gradle pour Grails 3
apply plugin: "org.grails.grails-web"

dependencies {
    compile "org.springframework.boot:spring-boot-starter-logging"
    compile "org.springframework.boot:spring-boot-starter-actuator"
    compile "org.springframework.boot:spring-boot-autoconfigure"
    compile "org.grails:grails-core"
    // ...
}

De Grails 3.x à Grails 4.x

  1. Java 8: S'assurer que le projet utilise Java 8 minimum
  2. Spring Boot 2.1: Adapter les configurations
  3. Groovy 2.5: Vérifier la compatibilité du code
  4. Micronaut: Exploiter les nouvelles fonctionnalités d'intégration

De Grails 4.x à Grails 5.x

  1. Groovy 3: Adapter le code pour profiter des nouvelles fonctionnalités
  2. Spring Boot 2.5: Mettre à jour les configurations
  3. Autowiring par type: Remplacer l'autowiring par nom
  4. Gradle 7: Mettre à jour les scripts de build

De Grails 5.x à Grails 6.x

  1. Java 11: Mettre à niveau l'environnement de développement et de production
  2. Spring Boot 2.7: Adapter les configurations
  3. Nouvelle CLI: Adapter les scripts et workflow de développement
  4. Spring Security: Mettre à jour vers Spring Security Core 6 si utilisé

Bonnes pratiques et astuces

Patterns recommandés

  1. Services transactionnels: Isoler la logique métier dans des services

    @Transactional
class BookService {
    // Logique métier ici
}

  2. Contrôleurs légers: Déléguer la logique aux services

    class BookController {
    BookService bookService
    
    def save() {
        // Délégation au service
        respond bookService.save(params)
    }
}

  3. Tests unitaires: Tester chaque composant individuellement

    @TestFor(BookService)
class BookServiceSpec extends Specification {
    void "test saving a book"() {
        // Tests ici
    }
}

Optimisation des requêtes GORM

  1. Éviter les requêtes N+1:

    // Mauvaise pratique
def books = Book.list()
books.each { book ->
    println book.author.name  // Requête supplémentaire pour chaque livre
}

// Bonne pratique
def books = Book.findAll { author != null }
books.each { book ->
    println book.author.name  // Pas de requête supplémentaire
}

  2. Utiliser les requêtes par lot:

    // Traitement par lots de 100 entités
Book.withSession { session ->
    session.withBatch(100) { batch ->
        // Opérations par lot
    }
}

  3. Requêtes projections:

    // Au lieu de charger toutes les propriétés
def titles = Book.createCriteria().list {
    projections {
        property('title')
    }
}

Ressources complémentaires

Conclusion

Grails a considérablement évolué depuis sa création, passant d'un framework MVC simple à un écosystème complet intégrant Spring Boot et Micronaut. La philosophie originale de "convention plutôt que configuration" et DRY reste au cœur du framework, tout en s'adaptant aux tendances modernes comme les microservices, la conteneurisation et le cloud.

Les récentes versions (3.x à 6.x) ont apporté une modernisation importante, tant au niveau de l'architecture que des outils de développement, permettant à Grails de rester pertinent dans l'écosystème Java/Groovy contemporain.

Talent
Copyright © 2025 Talent HUB Team