Une introduction à Grails 3 et GORM

Haut de persistance

Je viens d'annoncer le nouveau cours Learn Spring , axé sur les principes de base de Spring 5 et Spring Boot 2:

>> VOIR LE COURS

1. Vue d'ensemble

Ceci est une introduction rapide à Grails 3 et GORM.

Nous allons bien sûr utiliser Groovy et - implicitement - le framework utilise également Hibernate pour ORM, Spring Framework for Dependency Injection, SiteMash pour la mise en page et les thèmes, etc.

2. Configuration de la source de données

Nous pouvons commencer sans avoir à spécifier de configuration de source de données explicite - par défaut, Grails utilise la base de données HSQLDB pour les environnements de développement et de test.

Mais si vous souhaitez modifier ces valeurs par défaut, vous pouvez définir la source de données sélectionnée dans le fichier application.yml :

environments: development: dataSource: driverClassName : "com.mysql.jdbc.Driver" url : "jdbc:mysql://localhost:8080/test" dialect : org.hibernate.dialect.MySQL5InnoDBDialect 

De même, nous pouvons créer plusieurs environnements ici, à côté du développement, si nécessaire.

3. Domaine

Grails est capable de créer la structure de base de données pour nos classes de domaine, en fonction de la propriété dbCreate dans la configuration de la base de données.

Définissons ici l'une de ces classes de domaine:

Class User { String userName String password String email String age static constraints = { userName blank: false, unique: true password size: 5..10, blank: false email email: true, blank: true } }

Notez comment nous spécifions nos contraintes de validation directement dans le modèle , ce qui permet de garder les choses belles et propres et sans annotations.

Ces contraintes seront vérifiées automatiquement par Grails lorsque l'entité est persistante et le framework lèvera les exceptions de validation appropriées si l'une de ces contraintes est rompue.

Nous pouvons également spécifier des mappages GORM dans la propriété de mappage du modèle:

static mapping = { sort "userName" }

Maintenant, si nous appelons User.list () - nous obtiendrons des résultats triés par nom d' utilisateur .

On pourrait bien sûr obtenir le même résultat en passant le tri à l'API list:

User.list(sort: "userName")

4. Opérations CRUD

Quand nous regardons les opérations d'API, l' échafaudage joue un rôle très intéressant au début; il vous permet de générer une API CRUD de base pour une classe de domaine, y compris:

  • Les vues nécessaires
  • Actions du contrôleur pour les opérations CRUD standard
  • Deux types: dynamique et statique

Voici comment cela fonctionne avec l'échafaudage dynamique:

class UserController { static scaffold = true }

En écrivant simplement cette seule ligne, le framework générera 7 méthodes lors de l'exécution: afficher, modifier, supprimer, créer, enregistrer et mettre à jour. Ceux-ci seront publiés en tant qu'API pour cette entité de domaine particulière.

Exemple d'échafaudage statique:

  • Pour créer une vue avec un échafaudage, utilisez: " grails generate-views User "
  • Pour créer le contrôleur et la vue avec l'échafaudage, utilisez: " grails generate-controller User "
  • Pour tout créer en une seule commande, utilisez: " grails generate-all User "

Ces commandes généreront automatiquement la plomberie nécessaire pour cet objet de domaine particulier.

Examinons maintenant très rapidement l'utilisation de ces opérations - par exemple, pour notre objet Domaine utilisateur .

Pour créer un nouvel enregistrement «utilisateur» :

def user = new User(username: "test", password: "test123", email: "[email protected]", age: 14) user.save()

Pour récupérer un seul enregistrement :

def user = User.get(1) 

Cette API get récupérera l'objet de domaine dans un mode modifiable. Pour un mode lecture seule, nous pouvons utiliser l' API de lecture :

def user = User.read(1)

Pour mettre à jour un enregistrement existant :

def user = User.get(1) user.userName = "testUpdate" user.age = 20 user.save() 

Et une simple opération de suppression pour un enregistrement existant:

def user = User.get(1) user.delete()

5. Requêtes GORM

5.1. trouver

Commençons par l' API find :

def user = User.find("from User as u where u.username = 'test' ")

Nous pouvons également utiliser une syntaxe différente pour passer le paramètre:

def user = User.find("from User as u where u.username?", ['test'])

Nous pouvons également utiliser un paramètre nommé:

def user = User.find("from User as u where u.username=?", [username: 'test'])

5.2. findBy

Grails fournit une fonction de recherche dynamique qui utilise les propriétés du domaine pour exécuter une requête lors de l'exécution et renvoyer le premier enregistrement correspondant:

def user = User.findByUsername("test") user = User.findByUsernameAndAge("test", 20) user = User.findByUsernameLike("tes") user = User.findByUsernameAndAgeNotEquals("test", "100")

Vous pouvez trouver plus d'expressions ici.

5.3. Critères

Nous pouvons également récupérer des données en utilisant certains critères flexibles:

def user = User.find { username == "test"} def user = User.createCriteria() def results = user.list { like ("userName", "te%") and { between("age", 10, 20) } order("userName", "desc") }

Une note rapide ici - lorsque vous utilisez une requête de critères, utilisez "{}" au lieu de "()".

5.4. Exécuter la requête / la mise à jour

GORM prend également en charge la syntaxe de requête HQL - pour les opérations de lecture:

def user = User.executeQuery( "select u.userName from User u where u.userName = ?", ['test'])

En plus des opérations d'écriture:

def user = User.executeUpdate("delete User u where u.username =?", ['test'])

6. Conclusion

This has been a very quick intro to Grails and GORM – to be used as a guide to getting started with the framework.

Persistence bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

>> CHECK OUT THE COURSE