streamalism.org

1. Áttekintés

Ebben az oktatóanyagban megtudhatjuk, hogyan hozhatunk létre egy egyszerű webalkalmazást a Grails segítségével.

A Grails (pontosabban ez a legújabb nagyobb verzió) a Spring Boot projekt tetejére épített keretrendszer, amely az Apache Groovy nyelvet használja webalkalmazások fejlesztésére.

A Rails Framework for Ruby és a konvenciókonfiguráció filozófiája köré épül, amely lehetővé teszi a kazánlap kódjának csökkentését.

2. Beállítás

Először térjünk át a hivatalos oldalra a környezet előkészítése érdekében. A bemutató idején a legújabb verzió a 3.3.3.

Egyszerűen fogalmazva, a Grails telepítésének két módja van: SDKMAN-on keresztül vagy a terjesztés letöltésével és bináris fájlok hozzáadásával a PATH környezeti változóhoz.

A beállítással nem foglalkozunk lépésről lépésre, mert ez jól dokumentálva van a Grails Docs-ban.

3. A Grails alkalmazás anatómiája

Ebben a részben jobban megismerjük a Grails alkalmazás szerkezetét. Mint korábban említettük, Grails a konvenciót részesíti előnyben a konfiguráció helyett, ezért a fájlok helye határozza meg céljukat. Lássuk, mi van a grails-kb Könyvtár:

• eszközök - olyan hely, ahol statikus eszközök fájljait tároljuk, például stílusokat, javascript fájlokat vagy képeket
• konf - tartalmaz projektkonfigurációs fájlokat:
  • alkalmazás.yml szabványos webalkalmazás-beállításokat tartalmaz, mint például az adatforrás, a mime-típusok és más Grails vagy Spring funkcióval kapcsolatos beállítások
  • források.groovy tavaszi babmeghatározásokat tartalmaz
  • logback.groovy naplózási konfigurációt tartalmaz
• vezérlők - felelős a kérelmek kezeléséért és a válaszok generálásáért, vagy a nézetekre delegálásáért. Megállapodás szerint, amikor a fájlnév végződik *Vezérlő, a keretrendszer létrehoz egy alapértelmezett URL-hozzárendelést a vezérlő osztályban definiált minden művelethez
• tartomány - tartalmazza a Grails alkalmazás üzleti modelljét. Minden itt élő osztályt a GORM térképez fel az adatbázis táblákra
• i18n - nemzetköziesedési támogatásra használják
• benne - az alkalmazás belépési pontja
• szolgáltatások - itt fog élni az alkalmazás üzleti logikája. Megállapodás alapján Grails létrehoz egy tavaszi szingulbabot minden egyes szolgáltatáshoz
• taglib - az egyéni címkekönyvtárak helye
• nézetek - nézeteket és sablonokat tartalmaz

4. Egyszerű webalkalmazás

Ebben a fejezetben létrehozunk egy egyszerű webalkalmazást a hallgatók kezeléséhez. Kezdjük azzal, hogy meghívjuk a CLI parancsot egy alkalmazásváz létrehozásához:

grails create-app

Amikor a projekt alapstruktúrája elkészült, térjünk át a tényleges webalkalmazás-összetevők megvalósítására.

4.1. Domainréteg

Mivel a hallgatók kezelésére egy webalkalmazást valósítunk meg, kezdjük az úgynevezett domain osztály előállításával Diák:

grails create-domain-class com.baeldung.grails.Student

És végül tegyük hozzá a keresztnév és vezetéknév tulajdonságai:

osztály Tanuló {String keresztnév String vezetéknév}

Grails alkalmazza a konvencióit, és objektum-relációs leképezést állít fel az összes osztályban, amely itt található grails-app / domain Könyvtár.

Sőt, a GormEntity tulajdonságnak köszönhetően minden tartományosztály hozzáférhet az összes CRUD művelethez, amelyet a következő szakaszban használunk a szolgáltatások megvalósításához.

4.2. Szolgáltatási réteg

Alkalmazásunk a következő felhasználási eseteket fogja kezelni:

• A hallgatók listájának megtekintése
• Új hallgatók létrehozása
• Meglévő hallgatók eltávolítása

Végezzük el ezeket a felhasználási eseteket. Kezdjük egy szolgáltatási osztály létrehozásával:

grails create-service com.baeldung.grails.Student

Térjünk át a grails-app / szolgáltatások könyvtárban keresse meg újonnan létrehozott szolgáltatásunkat a megfelelő csomagban, és adja hozzá az összes szükséges módszert:

@ Tranzakciós osztály StudentService {def get (id) {Student.get (id)} def list () {Student.list ()} def save (hallgató) {student.save ()} def törlés (id) {Student.get (id) .delete ()}}

Vegye figyelembe, hogy a szolgáltatások alapértelmezés szerint nem támogatják a tranzakciókat. A. Hozzáadásával engedélyezhetjük ezt a funkciót @ Tranzakció jegyzet az osztálynak.

4.3. Vezérlő réteg

Annak érdekében, hogy az üzleti logika elérhető legyen a felhasználói felület számára, hozzunk létre egy StudentController a következő parancs meghívásával:

grails create-controller com.baeldung.grails.Student

Alapértelmezés szerint, Grails név szerint injektálja a babot. Ez azt jelenti, hogy könnyen beadhatjuk a StudentService singleton példányt a vezérlőnkbe egy úgynevezett példányváltozó deklarálásával hallgatókSzolgáltatás.

Most meghatározhatunk műveleteket a hallgatók olvasásához, létrehozásához és törléséhez.

osztály StudentController {def studentService def index () {válasz studentService.list ()} def show (hosszú id) {válasz studentService.get (id)} def create () {válasz új hallgató (paraméterek)} def mentés (hallgató hallgató) {studentService.save (hallgató) átirányítási művelet: "index", módszer: "GET"} def törlés (hosszú azonosító) {studentService.delete (id) átirányítási művelet: "index", módszer: "GET"}}

Egyezményesen, a index() Ennek a vezérlőnek a művelete leképezésre kerül az URI-ra / hallgató / index, a előadás() akció a / hallgató / műsor stb.

4.4. Réteg megtekintése

A vezérlő műveleteinek beállítása után folytathatjuk az UI nézetek létrehozását. Három Groovy Server oldalt hozunk létre a hallgatók felsorolásához, létrehozásához és eltávolításához.

Megállapodás alapján a Grails megjeleníti a nézetet a vezérlő neve és művelete alapján. Például,az index () akciótól StudentController meg fogja oldani /grails-app/views/student/index.gsp

Kezdjük a nézet megvalósításával / grails-app /megtekintés / hallgató / index.gsp, amely megjeleníti a hallgatók listáját. Használjuk a címkét létrehozni egy HTML táblázatot, amely megjeleníti a index() művelet a vezérlőnkben.

Megegyezés szerint, amikor objektumok listájával válaszolunk, Grails hozzáadja a „List” utótagot a modell nevéhez hogy a változóval hozzáférhessünk a tanulói objektumok listájához studentList:

Teremt

Most folytatjuk a nézetet / grails-app /nézetek/hallgató / create.gsp, amely lehetővé teszi a felhasználó számára új Diákok létrehozását. Mi a beépítettet fogjuk használni tag, amely egy adott bab minden tulajdonságának űrlapját jeleníti meg:

Végül hozzuk létre a nézetet / grails-app /nézetek/hallgató / show.gsp a hallgatók megtekintésére és végül törlésére.

Egyéb címkék mellett kihasználjuk , amely egy babot vesz fel argumentumként, és megjeleníti az összes mezőjét:

A hallgatók listája

4.5. Egység tesztek

Grails főként a Spock előnyeit használja ki tesztelés céljából. Ha még nem ismeri a Spockot, javasoljuk, hogy először olvassa el ezt az oktatóanyagot.

Kezdjük az egység tesztelésével index() akciónk StudentController.

Gúnyolni fogjuk lista() módszer től StudentService és tesztelje index() a várt modellt adja vissza:

void "Az index művelet tesztelése a helyes modellt adja vissza" () {megadott: controller.studentService = Gúny (StudentService) {lista () >> [új tanuló (keresztnév: 'John', vezetéknév: 'Doe')]}} "Az indexművelet végrehajtásra kerül" controller.index (), majd: "A modell helyes" model.studentList.size () == 1 model.studentList [0] .firstName == 'John' model.studentList [0]. vezetéknév == 'Doe'}

Most teszteljük a töröl() akció. Ellenőrizzük, hogy töröl() innen hívták StudentService és ellenőrizze az átirányítást az index oldalra:

void "A törlési művelet tesztelése egy példánnyal" () {given: controller.studentService = Gúny (StudentService) {1 * delete (2)} amikor: "A tartományi példány át lett adva a törlési műveletnek" request.contentType = FORM_CONTENT_TYPE kérelem .method = 'DELETE' controller.delete (2), majd: "A felhasználót indexre irányítják" response.redirectedUrl == '/ student / index'}

4.6. Integrációs tesztek

Ezután nézzük meg, hogyan hozhatunk létre integrációs teszteket a szolgáltatási réteg számára. Főként az itt konfigurált adatbázissal teszteljük az integrációt grails-app / conf / application.yml.

Alapértelmezés szerint Grails a memóriában lévő H2 adatbázist használja erre a célra.

Először is kezdjük egy segítő módszer meghatározásával az adatbázis feltöltésére szolgáló adatok létrehozásához:

private Long setupData () {new Student (keresztnév: 'John', vezetéknév: 'Doe') .save (flush: true, failOnError: true) new Student (firstName: 'Max', lastName: 'Foo') .save ( flush: true, failOnError: true) Student student = new Student (firstName: 'Alex', lastName: 'Bar') .save (flush: true, failOnError: true) student.id}

Köszönhetően a @Rollback kommentár az integrációs teszt osztályunkon, mindegyik módszer külön tranzakcióban fog futni, amelyet a teszt végén visszagörgetnek.

Vessen egy pillantást arra, hogy miként hajtottuk végre az integrációs tesztet lista() módszer:

void "tesztlista" () {setupData () mikor: List studentList = studentService.list (), akkor: studentList.size () == 3 studentList [0] .lastName == 'Doe' studentList [1] .lastName == 'Foo' studentList [2] .lastName == 'Bar'}

Vizsgáljuk meg a töröl() módszer, és érvényesítse, ha a hallgatók teljes számát eggyel csökkentik:

void "test delete" () {Hosszú id = setupData () várható: studentService.list (). size () == 3 mikor: studentService.delete (id) sessionFactory.currentSession.flush () majd: studentService.list () .size () == 2}

5. Futás és telepítés

Az alkalmazások futtatása és telepítése egyetlen parancs meghívásával történhet a Grails CLI-n keresztül.

Az alkalmazás futtatásához használja:

grails run-app

Alapértelmezés szerint Grails beállítja a Tomcat-ot a 8080-as porton.

Navigáljunk ide // localhost: 8080 / student / index hogy lássa, hogyan néz ki webalkalmazásunk:

Ha az alkalmazást egy servlet-tárolóba kívánja telepíteni, akkor használja:

megőrli a háborút

bevetésre kész háborús tárgy létrehozása.

6. Következtetés

Ebben a cikkben arra összpontosítottunk, hogyan hozzunk létre egy Grails webalkalmazást a konvenciókonfiguráció filozófiája segítségével. Láttuk azt is, hogyan kell elvégezni az egység- és integrációs teszteket a Spock keretrendszerrel.

Mint mindig, az itt használt összes kód megtalálható a GitHubon.