Eine Einführung in Grails 3 und GORM

Ausdauer oben

Ich habe gerade den neuen Learn Spring- Kurs angekündigt , der sich auf die Grundlagen von Spring 5 und Spring Boot 2 konzentriert:

>> Überprüfen Sie den Kurs

1. Übersicht

Dies ist eine kurze Einführung in Grails 3 und GORM.

Wir werden natürlich Groovy verwenden und - implizit - das Framework verwendet auch Hibernate für ORM, das Spring Framework für Dependency Injection, SiteMash für Layout und Themen usw.

2. DataSource-Konfiguration

Wir können beginnen, ohne eine explizite Datenquellenkonfiguration angeben zu müssen - standardmäßig verwendet Grails die HSQLDB-Datenbank für die Entwicklungs- und Testumgebungen.

Wenn Sie diese Standardeinstellungen ändern möchten, können Sie Ihre ausgewählte Datenquelle in der application.yml definieren :

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

Ebenso können wir hier neben der Entwicklung bei Bedarf mehrere Umgebungen erstellen .

3. Domain

Grails kann die Datenbankstruktur für unsere Domänenklassen basierend auf der Eigenschaft dbCreate in der Datenbankkonfiguration erstellen .

Definieren wir hier eine dieser Domänenklassen:

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 } }

Beachten Sie, wie wir unsere Validierungsbeschränkungen direkt im Modell festlegen, um die Dinge schön und sauber und ohne Anmerkungen zu halten.

Diese Einschränkungen werden von Grails automatisch überprüft, wenn die Entität beibehalten wird, und das Framework löst entsprechende Validierungsausnahmen aus, wenn eine dieser Einschränkungen verletzt wird.

Wir können auch GORM-Zuordnungen in der Zuordnungseigenschaft des Modells angeben :

static mapping = { sort "userName" }

Wenn wir nun User.list () aufrufen, erhalten wir die nach Benutzernamen sortierten Ergebnisse zurück .

Wir könnten natürlich das gleiche Ergebnis erzielen, indem wir die Sortierung an die Listen-API übergeben:

User.list(sort: "userName")

4. CRUD-Operationen

Wenn wir uns API-Operationen ansehen, spielt das Gerüst am Anfang eine sehr interessante Rolle. Damit können Sie eine CRUD-API für eine Domänenklasse erstellen, einschließlich:

  • Die notwendigen Ansichten
  • Controller-Aktionen für die Standard-CRUD-Operationen
  • Zwei Typen: Dynamisch und Statisch

So funktioniert das mit dynamischen Gerüsten:

class UserController { static scaffold = true }

Durch einfaches Schreiben dieser einzelnen Zeile generiert das Framework zur Laufzeit 7 Methoden: Anzeigen, Bearbeiten, Löschen, Erstellen, Speichern und Aktualisieren. Diese werden als API für diese bestimmte Domänenentität veröffentlicht.

Beispiel für ein statisches Gerüst:

  • Um eine Ansicht mit Gerüst zu erstellen, verwenden Sie: „ grails generate-views User
  • Um den Controller zu erstellen und mit dem Gerüst anzuzeigen, verwenden Sie: „ grails generate-controller User
  • Um alles in einem einzigen Befehl zu erstellen, verwenden Sie: " grails generate-all User "

Diese Befehle generieren automatisch die erforderliche Installation für dieses bestimmte Domänenobjekt.

Lassen Sie uns nun einen kurzen Blick auf die Verwendung dieser Vorgänge werfen - beispielsweise für unser Benutzerdomänenobjekt .

So erstellen Sie einen neuen Benutzerdatensatz :

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

So rufen Sie einen einzelnen Datensatz ab :

def user = User.get(1) 

Diese get- API ruft das Domänenobjekt in einem bearbeitbaren Modus ab. Für einen schreibgeschützten Modus können wir die Lese- API verwenden:

def user = User.read(1)

So aktualisieren Sie den vorhandenen Datensatz :

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

Und ein einfacher Löschvorgang für einen vorhandenen Datensatz:

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

5. GORM-Abfragen

5.1. finden

Beginnen wir mit der Such- API:

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

Wir können auch eine andere Syntax verwenden, um den Parameter zu übergeben:

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

Wir können auch einen benannten Parameter verwenden:

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

5.2. findBy

Grails bietet eine dynamische Finder-Funktion, die Domäneneigenschaften verwendet, um eine Abfrage zur Laufzeit auszuführen und den ersten übereinstimmenden Datensatz zurückzugeben:

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

Weitere Ausdrücke finden Sie hier.

5.3. Kriterien

Wir können Daten auch anhand einiger flexibler Kriterien abrufen:

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") }

Ein kurzer Hinweis hier: Wenn Sie eine Kriterienabfrage verwenden, verwenden Sie "{}" anstelle von "()".

5.4. Abfrage / Aktualisierung ausführen

GORM unterstützt auch die HQL-Abfragesyntax - für Leseoperationen:

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

Sowie Schreibvorgänge:

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