TOC

Une introduction à Grails 3 et à GORM

Une introduction à Grails 3 et à GORM

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 DataSource

Nous pouvons commencer sans avoir à spécifier une 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 lesapplication.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é dedevelopment si nous en avons besoin.

3. Domaine

Grails est capable de créer la structure de base de données pour nos classes de domaine, basée sur 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 nosvalidation constraints right in the model, ce qui permet de garder les choses belles et propres et sans annotations.

Ces contraintes seront automatiquement vérifiées par Grails lors de la persistance de l'entité et le cadre générera les exceptions de validation appropriées si l'une de ces contraintes est rompue.

Nous pouvons également spécifier les mappages GORM dans la propriétémapping du modèle: 

static mapping = { sort "userName" }

Maintenant, si nous appelonsUser.list() - nous obtiendrons les résultatssorted by username.

Nous pourrions bien sûr obtenir le même résultat en transmettant le tri à la liste API: 

User.list(sort: "userName")

4. Opérations CRUD

Quand on regarde les opérations de l'API,scaffolding 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 ligne, le framework générera 7 méthodes au moment de l'exécution: afficher, éditer, supprimer, créer, sauvegarder 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 é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 vont générer 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 domaineUser.

Àcreate new “user” record: 

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

Àfetch a single record:++ 

def user = User.get(1)

Cette APIget récupérera l'objet de domaine en mode modifiable. Pour un mode lecture seule, nous pouvons utiliser l'APIread: 

def user = User.read(1)

Àupdate existing record: `++` 

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. find

Commençons par l'APIfind: 

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

Nous pouvons également utiliser une syntaxe différente pour transmettre 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 au moment 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'expressionshere.

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'])

Ainsi que les opérations d'écriture:++ 

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

6. Conclusion

Cela a été une introduction très rapide à Grails et à GORM - à utiliser comme guide pour démarrer avec le framework.

Related