streamalism.org

1. Prehľad

V tomto tutoriále sa dozvieme, ako vytvoriť jednoduchú webovú aplikáciu pomocou programu Grails.

Grails (presnejšie jeho najnovšia hlavná verzia) je rámec postavený na vrchole projektu Spring Boot a na vývoj webových aplikácií používa jazyk Apache Groovy.

Je inšpirovaný rámcom Rails pre Ruby a je postavená na filozofii konvencie prekonania konfigurácie, ktorá umožňuje znížiť štandardný kód.

2. Inštalácia

V prvom rade poďme na oficiálnu stránku s prípravou prostredia. V čase tohto tutoriálu je najnovšia verzia 3.3.3.

Zjednodušene možno povedať, že existujú dva spôsoby inštalácie Grails: pomocou nástroja SDKMAN alebo stiahnutím distribúcie a pridaním binárnych súborov do premennej prostredia PATH.

Krok za krokom sa nebudeme venovať nastaveniu, pretože je dobre zdokumentované v dokumente Grails Docs.

3. Anatómia aplikácie Grály

V tejto časti lepšie pochopíme štruktúru aplikácie Grails. Ako sme už spomenuli, Grails uprednostňuje konvencie pred konfiguráciou, a preto umiestnenie súborov definuje ich účel. Pozrime sa, čo máme v grails-app adresár:

• aktíva - miesto, kde ukladáme súbory so statickými prostriedkami, ako sú štýly, súbory javascript alebo obrázky
• konf - obsahuje konfiguračné súbory projektu:
  • aplikácia.yml obsahuje štandardné nastavenia webových aplikácií, ako sú zdroj údajov, typy MIME a ďalšie nastavenia súvisiace s grálami alebo jarami
  • resources.groovy obsahuje definície jarných bôbov
  • logback.groovy obsahuje konfiguráciu protokolovania
• radiče - zodpovedný za vybavovanie žiadostí a generovanie odpovedí alebo ich delegovanie na názory. Podľa konvencie, keď názov súboru končí * Kontrolórrámec vytvára predvolené mapovanie adries URL pre každú akciu definovanú v triede radiča
• doména - obsahuje obchodný model aplikácie Grails. Každá trieda, ktorá tu žije, bude GORMom namapovaná na databázové tabuľky
• i18n - používa sa na podporu internacionalizácie
• init - vstupný bod aplikácie
• služby - obchodná logika aplikácie tu bude žiť. Podľa dohody vytvorí Grails pre každú službu jarné jednolôžkové fazule
• taglib - miesto pre vlastné knižnice značiek
• názory - obsahuje zobrazenia a šablóny

4. Jednoduchá webová aplikácia

V tejto kapitole vytvoríme jednoduchú webovú aplikáciu na správu študentov. Začnime vyvolaním príkazu CLI na vytvorenie kostry aplikácie:

grails create-app

Keď sa vygeneruje základná štruktúra projektu, prejdime k implementácii skutočných komponentov webovej aplikácie.

4.1. Doménová vrstva

Keď implementujeme webovú aplikáciu na prácu so študentmi, začnime s generovaním triedy domény s názvom Študent:

grály create-domain-class com.baeldung.grails.Student

A na záver pridajme krstné meno a priezvisko vlastnosti:

trieda Študent {String firstName String lastName}

Grails uplatňuje svoje konvencie a nastaví objektovo-relačné mapovanie pre všetky triedy nachádzajúce sa v grails-app / doména adresár.

Navyše vďaka vlastnosti GormEntity všetky triedy domén budú mať prístup ku všetkým operáciám CRUD, ktoré použijeme v nasledujúcej časti na implementáciu služieb.

4.2. Servisná vrstva

Naša aplikácia zvládne nasledujúce prípady použitia:

• Prezeranie zoznamu študentov
• Vytváranie nových študentov
• Odstraňujú sa existujúci študenti

Implementujme tieto prípady použitia. Začneme generovaním triedy služieb:

grály create-service com.baeldung.grails.Student

Poďme k grails-app / services adresár, nájdite našu novovytvorenú službu v príslušnom balíku a pridajte všetky potrebné metódy:

@Transactional class StudentService {def get (id) {Student.get (id)} def list () {Student.list ()} def save (student) {student.save ()} def delete (id) {Student.get (id) .delete ()}}

Upozorňujeme, že služby predvolene nepodporujú transakcie. Túto funkciu môžeme povoliť pridaním @ Transakčné anotácia k triede.

4.3. Vrstva radiča

Aby sme obchodnú logiku sprístupnili používateľskému rozhraniu, vytvorme StudentController vyvolaním nasledujúceho príkazu:

grály create-controller com.baeldung.grails.Student

Predvolene, Grál vstrekuje fazuľa podľa mien. Znamená to, že si môžeme ľahko podať injekciu StudentService singleton instance do nášho radiča vyhlásením inštančnej premennej s názvom študentiSlužba.

Teraz môžeme definovať akcie na čítanie, vytváranie a mazanie študentov.

trieda StudentController {def studentService def index () {respond studentService.list ()} def show (Long id) {respond studentService.get (id)} def create () {respond new Student (params)} def save (Student student) {studentService.save (student) akcia presmerovania: "index", metóda: "GET"} def delete (Long id) {studentService.delete (id) akcia presmerovania: "index", metóda: "GET"}}

Podľa dohody, the index () akcia z tohto radiča bude namapovaná na URI / student / index, the šou() akcia na / študent / prehliadka a tak ďalej.

4.4. Zobraziť vrstvu

Po nastavení akcií radiča môžeme teraz pokračovať vo vytváraní zobrazení používateľského rozhrania. Vytvoríme tri stránky servera Groovy pre zoznam, vytváranie a odstraňovanie študentov.

Podľa konvencie Grails vykreslí zobrazenie na základe názvu a akcie radiča. Napríklad,index () akcia od StudentController sa odhodlá k /grails-app/views/student/index.gsp

Začnime s implementáciou pohľadu / grails-app /views / student / index.gsp, kde sa zobrazí zoznam študentov. Použijeme značku vytvoriť tabuľku HTML zobrazujúcu všetkých študentov vrátených z index () činnosť v našom kontrolóri.

Podľa odpovede, keď odpovieme zoznamom objektov, Grails pridá k názvu modelu príponu „Zoznam“ aby sme mali prístup k zoznamu študentských objektov s premennou zoznam študentov:

Vytvoriť

Teraz prejdeme k výhľadu / grails-app /názory/študent / create.gsp, ktorý umožňuje používateľovi vytvárať nových študentov. Použijeme zabudovaný tag, ktorý zobrazuje formulár pre všetky vlastnosti daného fazule:

Nakoniec vytvoríme pohľad / grails-app /názory/študent / show.gsp na prezeranie a prípadné mazanie študentov.

Okrem iných značiek využijeme aj , ktorý berie fazuľu ako argument a zobrazuje všetky jej polia:

Zoznam študentov

4.5. Jednotkové testy

Grails využíva hlavne Spock na testovacie účely. Ak nie ste oboznámení so Spockom, dôrazne odporúčame prečítať si najskôr tento návod.

Začnime s jednotkovým testovaním index () akcia našej StudentController.

Vysmejeme sa zoznam () metóda z StudentService a vyskúšať, či index () vráti očakávaný model:

void "Test akcie indexu vráti správny model" () {given: controller.studentService = Mock (StudentService) {list () >> [nový študent (meno: 'John', priezvisko: 'Doe')]} keď: „Vykoná sa akcia indexu“ controller.index () potom: „Model je správny“ model.studentList.size () == 1 model.studentList [0] .firstName == 'John' model.studentList [0]. priezvisko == 'Srnka}}

Teraz otestujme odstrániť () akcia. Overíme, či odstrániť () bol vyvolaný z StudentService a overte presmerovanie na indexovú stránku:

void "Test akcie odstránenia pomocou inštancie" () {given: controller.studentService = Mock (StudentService) {1 * delete (2)} when: "Inštancia domény je odovzdaná akcii odstránenia" request.contentType = FORM_CONTENT_TYPE požiadavka .method = 'DELETE' controller.delete (2) then: "Užívateľ je presmerovaný na index" response.redirectedUrl == '/ student / index'}

4.6. Integračné testy

Ďalej sa pozrime, ako vytvoriť integračné testy pre vrstvu služby. Hlavne otestujeme integráciu s databázou nakonfigurovanou v grails-app / conf / application.yml.

Grails štandardne používa databázu H2 v pamäti pre tento účel.

Najskôr začnime s definovaním pomocnej metódy na vytváranie údajov na vyplnenie databázy:

private Long setupData () {new Student (firstName: 'John', lastName: 'Doe') .save (flush: true, failOnError: true) new Student (firstName: 'Max', lastName: 'Foo') .save ( flush: true, failOnError: true) Študent študent = nový Študent (meno: 'Alex', priezvisko: 'Bar') .save (flush: true, failOnError: true) student.id}

Vďaka @Rollback anotácia k našej triede testov integrácie, každá metóda bude prebiehať v samostatnej transakcii, ktorá bude vrátená späť na konci testu.

Zoznámte sa s tým, ako sme implementovali test integrácie pre naše zoznam () metóda:

void "test list" () {setupData () when: List studentList = studentService.list () then: studentList.size () == 3 studentList [0] .lastName == 'Doe' studentList [1] .lastName == 'Foo' studentList [2] .lastName == 'Bar'}

Poďme tiež vyskúšať odstrániť () metóda a overiť, či sa celkový počet študentov zníži o jedného:

void "test delete" () {Long id = setupData () expect: studentService.list (). size () == 3 when: studentService.delete (id) sessionFactory.currentSession.flush () then: studentService.list () .size () == 2}

5. Spustenie a nasadenie

Spustenie a nasadenie aplikácií je možné vykonať vyvolaním jediného príkazu cez Grails CLI.

Na spustenie aplikácie použite:

grails run-app

Grails predvolene nastaví Tomcat na porte 8080.

Prejdime k // localhost: 8080 / student / index ako naša webová aplikácia vyzerá:

Ak chcete svoju aplikáciu nasadiť do kontajnera servletu, použite:

vojna grálov

vytvoriť vojnový artefakt pripravený na nasadenie.

6. Záver

V tomto článku sme sa zamerali na to, ako vytvoriť webovú aplikáciu Grails pomocou filozofie konvencie nad konfiguráciou. Tiež sme videli, ako vykonať jednotkové a integračné testy s rámcom Spock.

Ako vždy, všetky tu použité kódy nájdete na GitHub.