Un'introduzione a Grails 3 e GORM

Persistenza in alto

Ho appena annunciato il nuovo corso Learn Spring , incentrato sui fondamenti di Spring 5 e Spring Boot 2:

>> SCOPRI IL CORSO

1. Panoramica

Questa è una rapida introduzione a Grails 3 e GORM.

Ovviamente utilizzeremo Groovy e, implicitamente, il framework utilizza anche Hibernate per ORM, Spring Framework per Dependency Injection, SiteMash per layout e temi, ecc.

2. Configurazione DataSource

Possiamo iniziare senza dover specificare alcuna configurazione esplicita dell'origine dati: per impostazione predefinita, Grails utilizza il database HSQLDB per gli ambienti di sviluppo e test.

Ma se vuoi cambiare queste impostazioni predefinite, puoi definire l'origine dati selezionata in application.yml :

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

Allo stesso modo possiamo creare più ambienti qui, accanto allo sviluppo, se necessario.

3. Dominio

Grails è in grado di creare la struttura del database per le nostre classi di dominio, basata sulla proprietà dbCreate nella configurazione del database.

Definiamo qui una di queste classi di dominio:

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

Nota come stiamo specificando i nostri vincoli di convalida direttamente nel modello , che mantiene le cose belle, pulite e prive di annotazioni.

Questi vincoli verranno controllati da Grails automaticamente quando l'entità viene mantenuta e il framework genererà le eccezioni di convalida appropriate se uno qualsiasi di questi vincoli viene infranto.

Possiamo anche specificare mappature GORM nella proprietà di mappatura del modello:

static mapping = { sort "userName" }

Ora se chiamiamo User.list () , restituiremo i risultati ordinati per nome utente .

Potremmo ovviamente ottenere lo stesso risultato passando l'ordinamento all'API dell'elenco:

User.list(sort: "userName")

4. Operazioni CRUD

Quando guardiamo alle operazioni API, lo scaffolding gioca un ruolo molto interessante all'inizio; ti consente di generare un'API CRUD di base per una classe di dominio, tra cui:

  • Le viste necessarie
  • Azioni del controller per le operazioni CRUD standard
  • Due tipi: dinamico e statico

Ecco come funziona con lo scaffolding dinamico:

class UserController { static scaffold = true }

Scrivendo semplicemente questa singola riga, il framework genererà 7 metodi in fase di esecuzione: mostra, modifica, elimina, crea, salva e aggiorna. Questi verranno pubblicati come API per quella particolare entità di dominio.

Esempio di ponteggio statico:

  • Per creare una vista con ponteggi utilizzare: " grails generate-views User "
  • Per creare il controller e visualizzare con scaffolding utilizzare: " grails generate-controller User "
  • Per creare tutto in un unico comando, usa: " grails generate-all User "

Questi comandi genereranno automaticamente l'impianto idraulico necessario per quel particolare oggetto di dominio.

Diamo ora una rapida occhiata all'utilizzo di queste operazioni, ad esempio per il nostro oggetto dominio utente .

Per creare un nuovo record "utente" :

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

Per recuperare un singolo record :

def user = User.get(1) 

Questa API get recupererà l'oggetto del dominio in modalità modificabile. Per una modalità di sola lettura, possiamo utilizzare l' API di lettura :

def user = User.read(1)

Per aggiornare il record esistente :

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

E una semplice operazione di cancellazione per un record esistente:

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

5. Query GORM

5.1. trova

Cominciamo con l' API di ricerca :

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

Possiamo anche usare una sintassi diversa per passare il parametro:

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

Possiamo anche usare un parametro denominato:

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

5.2. findBy

Grails fornisce una funzione di ricerca dinamica che utilizza le proprietà del dominio per eseguire una query in fase di esecuzione e restituire il primo record corrispondente:

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

Puoi trovare altre espressioni qui.

5.3. Criteri

Possiamo anche recuperare i dati utilizzando alcuni criteri flessibili:

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

Una breve nota qui: quando si utilizza una query con criteri, utilizzare "{}" invece di "()".

5.4. Esegui query / aggiornamento

GORM supporta anche la sintassi delle query HQL - per le operazioni di lettura:

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

Oltre alle operazioni di scrittura:

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