TOC

Eine Einführung in Grails 3 und GORM

Eine Einführung in Grails 3 und GORM

1. Überblick

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 müssen zunächst keine explizite Datenquellenkonfiguration angeben. 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 inapplication.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 mehrere Umgebungen erstellen, bei Bedarf nebendevelopment.

3. Domain

Grails kann die Datenbankstruktur für unsere Domänenklassen basierend auf der EigenschaftdbCreatein 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 unserevalidation constraints right in the modelangeben, 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 GORM-Zuordnungen auch in der Eigenschaftmappingdes Modells angeben: 

static mapping = { sort "userName" }

Wenn wir nunUser.list() aufrufen, erhalten wir die Ergebnissesorted by username 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, spieltscaffolding am Anfang eine sehr interessante Rolle. Damit können Sie eine grundlegende CRUD-API für eine Domänenklasse generieren, 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 sieben 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“

  • Verwenden Sie zum Erstellen des Controllers und der Ansicht mit dem Gerüst Folgendes: „grails generate-controller User“

  • Verwenden Sie: „grails generate-all User“, um alles in einem einzigen Befehl zu erstellen.

Diese Befehle generieren automatisch das erforderliche Installationsprogramm für dieses bestimmte Domänenobjekt.

Lassen Sie uns nun einen kurzen Blick auf die Verwendung dieser Operationen werfen - zum Beispiel für das Domain-ObjektUser.

Zucreate new “user” record: 

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

Zufetch a single record:++ 

def user = User.get(1)

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

def user = User.read(1)

Zuupdate existing record: `++` 

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

Beginnen wir mit derfind-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 Suchfunktion, die Domäneneigenschaften verwendet, um zur Laufzeit eine Abfrage 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")

Sie können weitere Ausdrückehere finden.

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

Hier eine kurze Anmerkung: 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 Schreiboperationen:++ 

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

6. Fazit

Dies war eine sehr kurze Einführung in Grails und GORM - als Leitfaden für den Einstieg in das Framework.

Related