streamalism.org

Ik heb zojuist het nieuwe aangekondigd Leer de lente natuurlijk, gericht op de basisprincipes van Spring 5 en Spring Boot 2:

1. Overzicht

Dit is een korte introductie tot Grails 3 en GORM.

We gaan natuurlijk Groovy gebruiken en - impliciet - het framework maakt ook gebruik van Hibernate voor ORM, het Spring Framework for Dependency Injection, SiteMash voor layout en thema's, etc.

2. Configuratie van gegevensbron

We kunnen beginnen zonder een expliciete gegevensbronconfiguratie te hoeven specificeren - Grails gebruikt standaard de HSQLDB-database voor de ontwikkel- en testomgevingen.

Maar als u deze standaardinstellingen wilt wijzigen, kunt u uw geselecteerde gegevensbron definiëren in het application.yml:

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

Evenzo kunnen we hier naast ontwikkeling als dat nodig is.

3. Domein

Grails is in staat om de databasestructuur voor onze domeinklassen te creëren op basis van de dbCreate eigenschap in de databaseconfiguratie.

Laten we hier een van deze domeinklassen definiëren:

Klasse Gebruiker {Tekenreeks gebruikersnaam Tekenreeks wachtwoord Tekenreeks e-mail Tekenreeks leeftijd statische beperkingen = {gebruikersnaam leeg: onwaar, uniek: waar wachtwoordgrootte: 5..10, leeg: onwaar e-mail e-mail: waar, leeg: waar}}

Merk op hoe we onze specificeren validatiebeperkingen direct in het model, waardoor alles netjes en schoon blijft, en zonder annotaties.

Deze beperkingen worden automatisch door Grails gecontroleerd wanneer de entiteit wordt gehandhaafd en het raamwerk zal geschikte validatie-uitzonderingen genereren als een van deze beperkingen wordt verbroken.

We kunnen ook GORM-toewijzingen specificeren in in kaart brengen eigenschap van het model:

statische mapping = {sort "userName"}

Als we nu bellen Gebruikers lijst() - we krijgen resultaten terug gesorteerd op gebruikersnaam.

We zouden natuurlijk hetzelfde resultaat kunnen bereiken door de sortering door te geven aan de lijst-API:

User.list (sorteer: "gebruikersnaam")

4. CRUD-operaties

Als we naar API-bewerkingen kijken, stellingen speelt in het begin een zeer interessante rol; het laat je een basis CRUD API genereren voor een domeinklasse, inclusief:

• De nodige uitzichten
• Controller-acties voor de standaard CRUD-bewerkingen
• Twee typen: dynamisch en statisch

Hier is hoe dat werkt met dynamische steigers:

class UserController {statische scaffold = true}

Door gewoon deze enkele regel te schrijven, genereert het framework 7 methoden tijdens runtime: tonen, bewerken, verwijderen, maken, opslaan en bijwerken. Deze worden gepubliceerd als de API voor die specifieke domeinentiteit.

Voorbeeld van statische steigers:

• Gebruik voor het maken van een aanzicht met steigers: "grails genereren-weergaven User“
• Gebruik voor het maken van de controller en weergave met steigers: "grails generation-controller Gebruiker“
• Om alles in één opdracht te maken, gebruik je: "grails genereren-all User“

Deze opdrachten genereren automatisch het benodigde sanitair voor dat specifieke domeinobject.

Laten we nu eens heel snel kijken hoe we deze bewerkingen kunnen gebruiken, bijvoorbeeld voor onze Gebruiker domeinobject.

Naar maak een nieuw "gebruiker" -record:

def user = nieuwe gebruiker (gebruikersnaam: "test", wachtwoord: "test123", e-mail: "[email protected]", leeftijd: 14) user.save ()

Naar haal een enkel record op:

def user = User.get (1) 

Dit krijgen API haalt het domeinobject op in een bewerkbare modus. Voor een alleen-lezen modus kunnen we de lezen API:

def user = User.read (1)

Naar update bestaande record:

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

En een eenvoudige verwijderingsoperatie voor een bestaand record:

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

5. GORM-zoekopdrachten

5.1. vind

Laten we beginnen met de vind API:

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

We kunnen ook een andere syntaxis gebruiken om de parameter door te geven:

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

We kunnen ook een benoemde parameter gebruiken:

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

5.2. findBy

Grails biedt een dynamische zoekfunctie die domeineigenschappen gebruikt om tijdens runtime een zoekopdracht uit te voeren en het eerste overeenkomende record te retourneren:

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

Meer uitdrukkingen vind je hier.

5.3. Criteria

We kunnen ook gegevens ophalen met behulp van enkele flexibele criteria:

def user = User.find {gebruikersnaam == "test"} def user = User.createCriteria () def resultaten = user.list {like ("userName", "te%") en {tussen ("age", 10, 20)} order ("userName", "desc")}

Een korte opmerking hier - wanneer u een criteriumquery gebruikt, gebruikt u "{}" in plaats van "()".

5.4. Voer Query / Update uit

GORM ondersteunt ook de HQL-querysyntaxis - voor leesbewerkingen:

def user = User.executeQuery ("selecteer u.userName van User u waar u.userName =?", ['test'])

Evenals schrijfbewerkingen:

def user = User.executeUpdate ("verwijder gebruiker u waar u.username =?", ['test'])

6. Conclusie

Dit is een zeer snelle introductie van Grails en GORM geweest - om te gebruiken als gids om met het framework aan de slag te gaan.