Bevezetés a gerendákba
Bevezetés a Grailekbe
A webes alkalmazások fejlesztése soha nem volt egyszerű és gyors. És sok fejlesztő szerte a világon próbálja valahogy megoldani ezt a helyzetet. De míg néhányan keresnek, mások már megtalálják az utat. "Nem kell ezüst golyó, amikor már megtaláltuk a Szent Grálot" - mondja a Grails fejlesztők.
Próbáljuk megérteni, hogy mi lehetne vágyunk arra, hogy új megközelítést dolgozzunk ki a webes alkalmazások fejlesztésének folyamatában.
Általában a Java webes fejlesztése nagyon unalmas folyamatot jelent, és egyáltalán nem kell beszélni a sebességről. Képzelje el, hogy hány akciót kell végrehajtani egy új oldal hozzáadásához az alkalmazáshoz:
- Oldalsablon létrehozása. A sablon ebben az esetben egy ábrázolás.
- Hozzon létre egy DTO osztályt (Data Transfer Object), valójában ez egy modell osztály az MVC számára.
- Hozzon létre egy Assembler-osztályt, amely képes lesz DTO-objektumunk létrehozására domainobjektumokból.
- Hozzon létre egy üzleti homlokzatot és annak megvalósítását (bár ez nem mindig szükséges). Az üzleti homlokzatok olyan objektumok, amelyek komplex alkalmazási logikát végeznek, gyakran az üzleti homlokzat módszereit transzatlanti módon végzik.
- Hozzon létre egy DAO-felületet (Data Access Object) és annak végrehajtását. DAO objektumokat használnak az adatbázis kezeléséhez.
- Hozzon létre egy szabályozóosztályt, amely kezeli a bejövő kéréseket, kihasználja a homlokzat szükséges módszereit, összegyűjti a modellt és megjeleníti egymást (azaz az MVC alkotóelemeit), és visszaküldi az eredményt.
- És állítsd be az összes létrehozott osztályt a Tavasszal.
Valójában ez a folyamat egy általános esetet ír le, és nem mindig szükségünk van például a DTO- vagy Assembler-osztályokra. A legfájdalmasabb a konfigurációs folyamat. Mivel sok XML-kódot kell létrehoznunk, amely leírja és inicializálja objektumainkat, valamint a köztük lévő kapcsolatokat.
Mint a Graalban
Az alábbi diagram nem az egyetlen, és talán a Java és a Spring nem ismerő programozók nem értik nagyon jól, hogy ez hogyan működik. De a legfontosabb dolog, amint látható, a folyamat összetettsége és időtartama. Ezzel szemben a jelenlegi Grails alkalmazás új oldala létrehozásának folyamata a következő:
- Hozzon létre egy új sablonmintát.
- Hozzon létre egy új vezérlőt.
- Hozzon létre egy új szolgáltatást. A Grails szolgáltatás részeként egy olyan osztályra van szükség, amely komplex üzleti logikát kell végrehajtania, és a szolgáltatási módszerek tranzakciósak lehetnek.
Az utolsó lépés nem mindig szükséges. És ami a legfontosabb, nincs szükség XML-re!
Sokkal könnyebb, ugye?
Tehát mielőtt elkezdené a példákat és részleteket, meg kell értenie az alapvető dolgokat.
A Grails alapja:
1. ábra: Graill építészet
A Grailben számos olyan fogalom létezik, amelyet először olvashatsz:
Kezdjük a sorrendben. A domain objektumok a webes alkalmazás téglái, a domain fogalmai. Így például, ha e-boltot írunk, akkor valószínűleg olyan tárgyak lesznek, mint a "Felhasználó", "Rendelés", "Áruk" és mások. Domainobjektumok esetén a Grails automatikusan táblákat hoz létre az adatbázisban a kulcsokkal, korlátokkal, indexekkel és mindent - mindent. Az adatbázisra vonatkozó kérések alapvetően ezeken az objektumokon keresztül is megtörténnek, például az ActiveRecord használata Ruby on Rails-en.
Amikor egy felhasználó megadja webhelyünk URL-címét, akkor az első lépés az, hogy lekérdezzük a kérelem vezérlőjét. A vezérlő fogadja a felhasználói adatokat, létrehoz egy modell alapján, és elküldi a kijelzőre.
Szolgáltatások - speciális szervezetek, amelyek feladata az alkalmazás üzleti logikájának végrehajtása. Amint már említettük, a Java alkalmazásokban az üzleti logikát az üzleti logika végrehajtására használják.
A sablonok általában és mindenhol HTML-klisék, amelyeken oldalak generálódnak. A Grails alkalmazásban a sablonok létrehozásának egyszerűsítése érdekében beépített nyelv (GSP) (Groovy Server Pages) van, amely olyan címkéket tartalmaz, amelyek lehetővé teszik a különböző műveletek végrehajtását, például az iterációt, a feltételeket, az adatkiadást és mások. A saját címkék könyvtárainak létrehozásával azonban kibővítheti a címkékészletet.
A Grails címkekönyvtár egy olyan osztály, amelynek metódusai a sablonból GSP-címkékként hívhatók le. Ha a sablonokban gyakran ugyanazokat a műveleteket kell végrehajtani, akkor létre kell hoznia egy speciális címkét, és át kell adnia ezeket a műveleteket. Így elkerülheti a rutinszerű munkát és újrahasznosítja a meglévő kódot, valamint megkönnyítheti az elrendezés tervező által a sablonokkal dolgozó életet.
Korábban említésre került, hogy a Tavasz a Grails egyik eleme. A tavaszi összetételnek különleges funkciói vannak (Quartz), hogy feladatokat végezzenek ütemterv szerint, vagyis bizonyos időközönként elvégezzék a szükséges munkát (természetesen elvégezheti a feladatokat és pontosan meghatározott időpontban). A feladatok ilyen módon történő létrehozásával sokkal kevésbé függ az operációs rendszertől, mint például a Cron használata esetén.
Most elmehetsz a gyakorlatba. Hozzon létre egy egyszerű alkalmazást - egy könyvtárat. Könyvtárunk egyszerűen megőrzi a könyvek listáját, és lehetőséget nyújt a könyvek listájának megtekintésére, törlésére, szerkesztésére és hozzáadására.
A rutin feladatok elvégzéséhez - egy egyszerű alkalmazásvázlat, tartományobjektumok, vezérlők és mások létrehozásához - a parancs segédprogramokat tartalmaz. Nem fogjuk kidolgozni a parancsokat, de a legfontosabbakat a pályázatírás során figyelembe fogjuk venni. És az első csapat, akiről megismerkedünk, a create-app.
bash-3.2 $ grails create-app homeLibrary
Licenc az Apache Standard License 2.0 alatt
A Grails home beállítása: /Library/grails-1.0.1
Base Directory: / demo / grails
Környezetfejlesztés
Megjegyzés: Nincs plugin szkript
Szkript futtatása /Library/grails-1.0.1/scripts/CreateApp.groovy
[mkdir] Létrehoztatott dir: / demo / grails / homeLibrary / src
[mkdir] Létrehozta dir: / demo / grails / homeLibrary / src / java
[mkdir] Létrehozta dir: / demo / grails / homeLibrary / src / groovy
[mkdir] Létrehozva dir: / demo / grails / homeLibrary / grails-app
[mkdir] Létrehoztatott dir: / demo / grails / homeLibrary / grails-app / vezérlők
[mkdir] Létrehoztatott dir: / demo / grails / homeLibrary / grails-app / services
[mkdir] Létrehoztatott dir: / demo / grails / homeLibrary / grails-app / domain
[mkdir] Létrehozva dir: / demo / grails / homeLibrary / grails-app / taglib
[mkdir] Létrehozta dir: / demo / grails / homeLibrary / grails-app / utils
[mkdir] Létrehoztatott dir: / demo / grails / homeLibrary / grails-app / views
[mkdir] Létrehozta dir: / demo / grails / homeLibrary / grails-app / views / layouts
[mkdir] Létrehozva dir: / demo / grails / homeLibrary / grails-app / i18n
[mkdir] Létrehozva dir: / demo / grails / homeLibrary / grails-app / conf
[mkdir] Létrehozta dir: / demo / grails / homeLibrary / test
[mkdir] Létrehozta dir: / demo / grails / homeLibrary / test / unit
[mkdir] Létrehoztatott dir: / demo / grails / homeLibrary / test / integration
[mkdir] Létrehoztatott dir: / demo / grails / homeLibrary / scriptek
[mkdir] Létrehozta dir: / demo / grails / homeLibrary / web-app
[mkdir] Létrehoztatott dir: / demo / grails / homeLibrary / web-app / js
[mkdir] Létrehoztatott dir: / demo / grails / homeLibrary / web-app / css
[mkdir] Létrehoztatott dir: / demo / grails / homeLibrary / web-app / images
[mkdir] Létrehozva dir: / demo / grails / homeLibrary / web-app / META-INF
[mkdir] Létrehoztatott dir: / demo / grails / homeLibrary / lib
[mkdir] Létrehozva dir: / demo / grails / homeLibrary / grails-app / conf / spring
[mkdir] Létrehozta dir: / demo / grails / homeLibrary / grails-app / conf / hibernált
[tulajdonságfájl] Új tulajdonságfájl létrehozása: /demo/grails/homeLibrary/application.properties
[propertyfile] A tulajdonságfájl frissítése: /demo/grails/homeLibrary/application.properties
Created Grails Alkalmazás / demo / grails / homeLibrary
Miután végrehajtotta a "grail create-app homeLibrary" parancsot, megvan a jövőbeli webes alkalmazásunk vázlata. A Graalokban van egy olyan dolog, mint az egyezmény a konfigurációról. Ez azt jelenti, hogy minden egyes fájl esetében van egy hely, ahol kell lennie, és minden osztálynak világosan meg kell határoznia a nevét (lásd a 2. ábrát). Például a vezérlőosztályokat tartalmazó fájloknak rendelkezniük kell egy Vezérlő postfix-del.
2. ábra. Az alkalmazás szerkezete
Az adatbázis konfigurálása
A következő lépésként állítsa be az alkalmazást az adatbázis működéséhez, legyen MySQL, de minden olyan adatbázis, amelyen a Hibernate működhet (jelenleg minden népszerű DBMS támogatást nyújt). Ehhez nyissa meg a conf / DataSource.groovy fájlt:
A vezetőünk
Mint látható. ez a fájl három szakaszból áll. adatforrás, hibernálás és környezetek. Az adatforrás részben a hozzáférési paramétereket közvetlenül a DBMS-re állítja be. Mivel a MySQL-t használjuk, ennek megfelelően megváltoztatjuk az illesztőprogram nevét "com.mysql.jdbc.Driver" -re, és az archívumot a meghajtóval a projekt "lib" könyvtárába kell helyezni. Ez a könyvtár a használt Java-könyvtárak tárolására szolgál. A következő rész lehetőséget ad a Hibernate konfigurálására, és ebben a szakaszban nem érdekes, ezért közvetlenül a környezetek - környezetek beállításához.
A Grails alkalmazás három különböző környezetben (módban) végezhető el: a fejlesztési mód, a tesztelési mód és a késztermék. Minden egyes üzemmód esetében megadhatjuk az URL-t, a bejelentkezési adatokat, a jelszót a DBMS-hez való csatlakozáshoz és így tovább. Alapértelmezés szerint az alkalmazás fejlesztési módban fut. Ha szükség van rá, saját magad létrehozhat további üzemmódokat. Mivel már MySQL-t választottunk adatbázisként, meghatározzuk a kapcsolódási sort: jdbc: mysql: //127.0.0.1: 3306 / home_library.
Mint már említettük, a domain objektumok az alkalmazás téglái, alapelvei. Mivel alkalmazásunk könyvek listájának tárolására készült, létrehozunk egy Domain Book objektumot.
bash-3.2 $ grails create-domain-class könyv
Licenc az Apache Standard License 2.0 alatt
A Grails home beállítása: /Library/grails-1.0.1
Base Directory: / demo / grails / homeLibrary
Környezetfejlesztés
Megjegyzés: Nincs plugin szkript
Futtatható szkript /Library/grails-1.0.1/scripts/CreateDomainClass.groovy
Könyv létrehozva
Készített tesztek a könyv számára
Amint láthatja, ezzel segítettünk a csapatnak. Figyelembe véve azt a tényt, hogy a Könyvosztály minden egyes példánya egy adott könyvre vonatkozó információt tartalmaz, a szükséges mezőket megfelelően hozzá kell adni:
String name // A könyv neve
int polcNumber // Polc száma
név (nullable: hamis, üres: hamis, méret: 1..200)
szerző (nullable: hamis, üres: hamis, mérete: 1,50)
Most, amikor elindítja az alkalmazást a domainobjektumunk alapján, a Grails létrehoz egy "könyv" táblát az adatbázisban. A domainobjektumok létrehozásának és az adatbázisba való kapcsolódásnak ez a módja kevésbé időigényes, mint a szokásos Java jelölések vagy leképezési fájlok. Bizonyosodjon meg róla, hogy végrehajtod a "grails run-app" parancsot, és nézd meg, mi változott az adatbázisban.
mysql> show create table book \ G
Táblázat létrehozása: CREATE TABLE `book` (
`id` bigint (20) NOT NULL auto_increment,
`version` bigint (20) NOT NULL,
`author` varchar (50) NOT NULL,
`name` varchar (200) NOT NULL,
`shelf_number` int (11) NOT NULL,
) ENGINE = MyISAM DEFAULT CHARSET = latin1
1 sor a készletben (0.00 sec)
Amint látja, a táblázatban minden általunk definiált mező és korlátozás létezik. Az elsődleges kulcsot és a "verzió" szolgáltatás mezőt is automatikusan hozzáadták. Ami a fejlesztői környezetet illeti a DataSource.groovy konfigurációs fájlban, a "dbCreate" beállítás értéke "create-drop", majd minden alkalmazásban elindul a táblák törlése és újbóli létrehozása. Természetesen minden adat elvész. Ennek elkerülése érdekében az értéket frissíteni kell. Ebben az esetben, ha bármilyen változtatás történik a domainobjektumainkban, akkor az ALTER SQL lekérdezéseket végrehajtjuk a meglévő táblázatokban, és ennek megfelelően az adatvesztés csak akkor történik meg, ha bármely mező vagy osztály törlődik.
Vezérlő és sablonok
Most, hogy már van egy domainobjektumunk - Könyv, létrehozhatunk egy felületet a könyvek kezeléséhez. Itt számos módon - írhatunk mindent kézzel, fel tudjuk használni az úgynevezett állványzat, és létrehoz egy meglévő domainhez osztály, amire szükség van, mégpedig - a sablonok és vezérlő (állványzat - vezérlő viselkedés, ha nyilvánvalóan nincsenek módszerek és minták, de a vezérlő létrehozhat, törölhet, és szerkesztheti az adatokat. például, mi is létrehozhatunk egy üres vezérlő, a mező «def = állványzat Book», és így most már tudja végigvinni ezt az egyszerű vezérlő akció a tárgy Bo ok). A Grails képességeinek bemutatásához próbálj meg menni a harmadik útra, kódot és sablonokat generálni. Ismét a gerillák segédprogram jön a mi mentés. Végezze el a "grails generate-all Book" parancsot, és futtassa az alkalmazást.
A böngésző megnyitásával a főoldalon egy leírást és egy linket tartalmazó listát láthatunk az újonnan létrehozott vezérlővel (lásd a 3. ábrát).
3. ábra: Kezdőlap
Átnézi azt, győződjön meg róla, hogy alkalmazásunk valóban új rekordokat hozhat létre, szerkeszthet és törölhet (lásd a 4. ábrát).
4. ábra: Egyszerű CRUD alkalmazás (Retrive frissítés létrehozása törlés)
A könyvek azonnali megkezdéséhez a conf / UrlMappings.groovy konfigurációs fájlt szerkesztjük:
// alkalmazzunk korlátozásokat itt
// Az alapértelmezett viselkedés felülírása
// a műveletek törlése, mentése és frissítése csak elfogadja
def allowedMethods = [delete: "POST", mentés: "POST", frissítés: "POST"]
ha (! params.max) params.max = 10
[bookList: Book.list (params)]
def könyv = Book.get (params.id)
flash.message = "Book $ létrehozva"
Mivel a meghívás módja nincs kifejezetten megadva, az alapértelmezett metódust "index" -nek nevezik (ha kívánja, akkor felülbírálhatja a módszert, amelyet alapértelmezés szerint az alábbiak szerint hívnak: add def defaultAction = 'show' a vezérlőnek). Amint az a fenti kódból látható, az "index" módszer egyszerűen átirányítja a felhasználót a HTTP fejlécek használatával ugyanazon osztály - "lista" másik módszerére. Minden POST és GET paraméter elérhető a params mezőn keresztül, amely egy asszociatív tömb.
A "listában" módszerrel az összes meglévő könyv listáját az adatbázisból visszajuttatják és modellként visszaküldik. A Grails a "list.gsp" sablont a "view / book /" könyvtárban találja meg, és az újonnan létrehozott modellt bent tartja. Amint láthatja, itt is működik az "Egyezmény a konfigurációról" szabály, amikor maga a keret tudja, hol találja meg a szükséges sablonokat. Miután létrehoztuk sablonunk és modellünk HTML kódját, a Sitemesh elkezd dolgozni. Sablonunkban speciális GSP-tagot használtunk "”. Ez a címke azt mutatja, hogy a végső oldal megjelenítéséhez a "fő" elrendezést kell használni (minden elrendezés a "nézetek / elrendezések" könyvtárban van). És most a Sitemesh alkalmazza a megadott elrendezést a már feldolgozott oldalsablonra és kinyomtatja az eredményt.
Amint látja, minden nagyon egyszerű és átlátható, ami valójában a fejlesztők keresett. Sajnálatos módon egyetlen grafikonban nem lehet figyelembe venni a Grail összes funkcióját, ezért olyan dolgokat, mint a szolgáltatások, a címkék könyvtárai, ütemezett feladatok, a Java kóddal való interakció, az adatbázisokkal végzett finom műveletek és még sok más nem vették figyelembe.
Összefoglalva, szeretném értékelni e keret előnyeit és hátrányait. A Grail használatával olyan nagyvállalati szintű webes alkalmazás létrehozása, amely komplex üzleti logikával rendelkezik, olyan nehéz, mint a hagyományos Java eszközök használata. Ez a fő hátránya. De a legtöbb hétköznapi feladat megoldásához teljes eszközkészlet található. Természetesen az előnyök a fejlesztés egyszerűsége, a bejövő alkalmazások bármely Java webes kiszolgálón (azaz konténereken vagy alkalmazáskiszolgálókon) való indítása, valamint a meglévő Java-kód használatának lehetősége minimális költséggel az alkalmazkodáshoz.