Bevezetés a Ninja keretrendszerbe

1. Áttekintés

Manapság számos olyan JEE alapú keretrendszer áll rendelkezésre, mint a Spring, a Play és a Grails a webalkalmazások fejlesztéséhez.

Okunk lehet, hogy egyet választunk közülük a többiek helyett. Választásunk azonban a felhasználástól és a megoldani kívánt problémától is függ.

Ebben a bevezető bemutatóban felfedezzük a Ninja web keretrendszerét, és létrehozunk egy egyszerű webalkalmazást. Ugyanakkor megvizsgálunk néhány alapvető funkciót, amelyet nyújt.

2. Ninja

A Ninja egy teljes veremű, mégis könnyű webkeret, amely a meglévő Java könyvtárakat használja a munka elvégzéséhez.

A HTML-től a JSON-megjelenítésig, a kitartástól a tesztelésig terjedő funkciókkal egyablakos megoldás a skálázható webalkalmazások felépítésére.

Ebből következik a konvenciókonfiguráció paradigma és kategorizálja a kódot a következő csomagokban: modellek, vezérlők, és szolgáltatások.

A Ninja népszerű Java könyvtárakat használ a legfontosabb funkciókhoz, például Jackson JSON / XML-megjelenítéshez, Guice a függőségkezeléshez, Hibernálás a kitartáshoz és a Flyway az adatbázis-migrációkhoz.

A gyors fejlesztés érdekében a SuperDevMode-ot kínálja a kód gyors újratöltésére. Tehát lehetővé teszi számunkra, hogy azonnal lássuk a változásokat a fejlesztői környezetben.

3. Beállítás

A Ninja szabványos eszközkészletet igényel egy webalkalmazás létrehozásához:

  • Java 1.8 vagy újabb
  • Maven 3 vagy újabb
  • IDE (Eclipse vagy IntelliJ)

Maven archetípust használunk a Ninja projekt gyors felállításához. Ez arra késztet minket, hogy adjunk meg egy csoport azonosítót, egy tárgy azonosítót és egy verziószámot, majd a projekt nevét:

mvn archetípus: generál -DarchetypeGroupId = org.ninjaframework \ -DarchetypeArtifactId = ninja-servlet-archetype-simple

Vagy egy meglévő Maven-projekthez hozzáadhatjuk a legújabb ninja-core függőséget a pom.xml:

 org.ninjaframework ninja-core 6.5.0 

Ezután futtatjuk a Maven parancsot a fájlok első fordításához:

mvn tiszta telepítés

Végül futtassuk az alkalmazást egy Ninja által biztosított Maven paranccsal:

mvn ninja: fuss

Voálá! Alkalmazásunk elindult, és a következő címen lesz elérhető: helyi gazda: 8080:

4. A projekt felépítése

Vessünk egy pillantást a Ninja által létrehozott Maven-szerű projektszerkezetre:

A keretrendszer néhány csomagot hoz létre konvenciók alapján.

A Java osztályok a következő kategóriába vannak besorolva konf, vezérlők, modellek, és szolgáltatások könyvtárak ben src / main / java.

Hasonlóképpen, src / test / java rendelkezik a megfelelő egység teszt osztályokkal.

A nézetek könyvtár alatt src / main / java tartalmazza a HTML fájlokat. És a src / main / java / vagyon könyvtár olyan erőforrásokat tartalmaz, mint képek, stíluslapok és JavaScript fájlok.

5. Vezérlő

Mindannyian készek vagyunk megvitatni a keret néhány alapvető jellemzőjét. A vezérlő olyan osztály, amely fogad egy kérést, és konkrét eredményekkel adja vissza a választ.

Először beszéljünk meg néhány követendő konvencióról:

  • Hozzon létre egy osztályt a vezérlők csomagot, és a nevet toldja meg Vezérlő
  • A kérést kiszolgáló metódusnak vissza kell adnia a Eredmény osztály

Hozzuk létre a ApplicationController osztály egy egyszerű módszerrel a HTML megjelenítésére:

@Singleton public class ApplicationController {public Result index () {return Results.html (); }}

Itt a index metódus HTML-t jelenít meg a html módszere Eredmények osztály. A Eredmény Az objektum tartalmaz mindent, ami a tartalom megjelenítéséhez szükséges, például válaszkód, fejlécek és sütik.

Jegyzet: Guice-é @Szingli az annotáció az alkalmazásban csak a vezérlő egyetlen példányát engedélyezi.

6. Nézet

A index módszerrel a Ninja megkeresi a HTML fájlt - index.ftl.html alatt views / ApplicationController Könyvtár.

A Ninja a Freemarker sablonmotort használja a HTML-megjelenítéshez. Tehát, az összes fájl alatt nézetek kell a .ftl.html kiterjesztés.

Hozzuk létre a énndex.ftl.html fájl a index módszer:

  Ninja: Indexfelhasználó Json 

Itt a Ninja által biztosítottakat használtuk i18n címkét a helloMsg ingatlan a üzenet.tulajdonságok fájl. Ezt később a továbbiakban az internacionalizálás részben tárgyaljuk.

7. Útvonal

Ezután meghatározzuk az elérési útvonal útvonalát index módszer.

Ninja a Útvonalak osztály a konf csomag az URL-cím leképezéséhez a vezérlő egy adott módszeréhez.

Adjunk hozzá egy útvonalat a index módszere ApplicationController:

public class Routes megvalósítja az ApplicationRoutes {@Override public void init (Router router) {router.GET (). route ("/ index"). with (ApplicationController :: index); }}

Ez az! Mindannyian elérhetjük a index oldal a localhost: 8080 / index:

8. JSON renderelés

Amint arról már volt szó, Ninja Jacksont használja a JSON-megjelenítéshez. A JSON-tartalom megjelenítéséhez használhatjuk a json módszere Eredmények osztály.

Tegyük hozzá a userJson módszer a ApplicationController osztályban, és egyszerűvé teszi a tartalmát HashMap a JSON-ban:

public Result userJson () {HashMap userMap = új HashMap (); userMap.put ("név", "Norman Lewis"); userMap.put ("email", "[email protected]"); return Eredmények.json (). render (felhasználó); }

Ezután hozzáadjuk a szükséges útvonalat a userJson:

router.GET (). route ("/ userJson"). az (ApplicationController :: userJson) segítségével;

Most a JSON rendszert használhatjuk localhost: 8080 / userJson:

9. Szolgáltatás

Létrehozhatunk egy szolgáltatást, amely az üzleti logikát elkülöníti a vezérlőtől, és ahol szükséges, beadhatja szolgáltatásunkat.

Először hozzunk létre egy egyszerű UserService felület az absztrakció meghatározásához:

nyilvános felület UserService {HashMap getUserMap (); }

Ezután megvalósítjuk a UserService interfész a UserServiceImpl osztály és felülírja a getUserMap módszer:

public class UserServiceImpl implementálja a UserService {@Orride public HashMap getUserMap () {HashMap userMap = new HashMap (); userMap.put ("név", "Norman Lewis"); userMap.put ("email", "[email protected]"); return userMap; }}

Ezután megkötözzük a UserService interfész a UserServiceImpl osztály a Ninja függőség-injektálási funkciójával, amelyet Guice biztosított.

Adjuk hozzá a kötést a Modul osztály elérhető a konf csomag:

A @Singleton public class modul kiterjeszti az AbstractModule {protected void configure () {bind (UserService.class) .to (UserServiceImpl.class); }}

Utoljára beadjuk a UserService függőség a ApplicationController osztály a @ Injekció kommentár:

public class ApplicationController {@Inject UserService userService; // ...}

Így mindannyian készen állunk a UserService’S getUserMap módszer a ApplicationController:

public Result userJson () {HashMap userMap = userService.getUserMap (); return Results.json (). render (userMap); }

10. Flash-hatókör

A Ninja a Flash Scope nevű szolgáltatás révén egyszerű, de hatékony módszert kínál a kérések sikereinek és hibaüzeneteinek kezelésére.

A vezérlőben való használatához hozzáadjuk a FlashScope argumentum a módszerhez:

public Result showFlashMsg (FlashScope flashScope) {flashScope.success ("Sikeres üzenet"); flashScope.error ("Hibaüzenet"); return Results.redirect ("/ home"); }

Megjegyzés: A átirányítás módszere Eredmények osztály átirányítja a célt a megadott URL-re.

Ezután hozzáadunk egy útválasztást /vaku hoz showFlashMsg módszert és módosítsa a nézetet a flash üzenetek megjelenítéséhez:

 $ {flash.error} $ {flash.success} 

Most láthatjuk a FlashScope akcióban localhost: 8080 / vaku:

11. Nemzetközivé válás

A Ninja beépített internacionalizálási funkciót kínál, amelyet könnyen konfigurálni lehet.

Először meghatározzuk a támogatott nyelvek listáját a application.conf fájl:

alkalmazás.nyelvek = fr, en

Ezután létrehozzuk az alapértelmezett tulajdonságfájlt - üzenetek.tulajdonságok angolul - kulcsérték-párokkal az üzenetekhez:

header.home = Otthon! helloMsg = Helló, üdvözlünk a Ninja Framework-ben!

Ehhez hasonlóan hozzáadhatjuk a nyelvi kódot a fájlnévhez egy nyelvspecifikus tulajdonságfájlhoz - például message_fr.properties fájl francia nyelvre:

header.home = Accueil! helloMsg = Bonjour, bienvenue dans Ninja Framework!

Miután a konfigurációk elkészültek, könnyen engedélyezhetjük az internacionalizálást a ApplicationController osztály.

Kétféle módszerünk van, akár a Lang osztály vagy a üzenetek osztály:

@Singleton public class ApplicationController {@Inject Lang lang; @ Inject Messages üzenet; // ...}

Ezután a Lang osztályban beállíthatjuk az eredmény nyelvét:

Eredmény eredménye = Eredmények.html (); lang.setLanguage ("fr", eredmény);

Hasonlóképpen, a üzenetek osztályban kaphatunk nyelvspecifikus üzenetet:

Opcionális nyelv = Opcionális.of ("fr"); Karakterlánc helloMsg = msg.get ("helloMsg", nyelv) .get ();

12. Kitartás

A Ninja támogatja a JPA 2.0-t, és a Hibernate funkciót használja a webalkalmazás állandóságának engedélyezéséhez. Emellett beépített H2 adatbázis-támogatást kínál a gyors fejlesztéshez.

12.1. Modell

Szükségünk van egy Entitás osztály, hogy csatlakozzon egy táblához az adatbázisban. Ehhez Ninja követi azt a megállapodást, hogy az entitásosztályokat keresi a modellek csomag. Tehát létrehozzuk a Felhasználó entitásosztály ott:

@Entity public class User {@Id @GeneratedValue (strategy = GenerationType.AUTO) Hosszú id; public String keresztnév; nyilvános karakterlánc e-mail; }

Ezután konfiguráljuk a hibernált állapotot, és beállítjuk az adatbázis-kapcsolat részleteit.

12.2. Konfiguráció

A hibernált beállításokhoz a Ninja a kitartás.xml fájl a src / main / java / META-INF Könyvtár:

    org.hibernate.jpa.HibernatePersistenceProvider 

Ezután hozzáadjuk az adatbázis-kapcsolat részleteit application.conf:

ninja.jpa.persistence_unit_name = dev_unit db.connection.url = jdbc: h2: ./ devDb db.connection.username = sa db.connection.password =

12.3. EntityManager

Utoljára beadjuk a EntityManager ban,-ben ApplicationController Guice-okat használva Szolgáltató osztály:

public class ApplicationController {@Inject Provider entitásManagerProvider; // ...}

Tehát készen állunk a EntityManager hogy kitartson a Felhasználó tárgy:

@Transactional public Eredmény insertUser (Felhasználó felhasználó) {EntityManager entitásManager = entitásManagerProvider.get (); entitásManager.persist (felhasználó); entitásManager.flush (); return Results.redirect ("/ home"); }

Hasonlóképpen használhatjuk a EntityManager hogy elolvassa a Felhasználó objektum a DB-ből:

@UnitOfWork public Result fetchUsers () {EntityManager entitásManager = entitásManagerProvider.get (); Q = entitásManager.createQuery ("SELECT x FROM Felhasználó x"); Lista felhasználók = (Lista) q.getResultList (); return Results.json (). render (felhasználók); }

Itt, Ninja @UnitOfWork az annotáció mindent kezel az adatbázis-kapcsolatokról anélkül, hogy tranzakciókat kezelne. Ennélfogva hasznos lehet csak olvasható lekérdezéseknél, ahol általában nem igényelünk tranzakciókat.

13. Érvényesítés

A Ninja a JSR303 specifikációinak betartásával beépített támogatást nyújt a babellenőrzéshez.

Vizsgáljuk meg a tulajdonságot egy tulajdonság megjegyzésével a Felhasználó entitás a @Nem nulla kommentár:

public class Felhasználó {// ... @NotNull public String keresztnév; }

Ezután módosítjuk a már tárgyaltakat insertUser módszer a ApplicationController az érvényesítés engedélyezéséhez:

@Transactional public Result insertUser (FlashScope flashScope, @ JSR303Validation User user, Validation validation) {if (validation.getViolations (). Size ()> 0) {flashScope.error ("Validációs hiba: Felhasználót nem lehet létrehozni"); } else {EntityManager entitásManager = entitiyManagerProvider.get (); entitásManager.persist (felhasználó); entitásManager.flush (); flashScope.success ("Felhasználó" "+ felhasználó +" 'sikeresen létrehozva "); } return Results.redirect ("/ home"); }

Használtuk a Ninja-okat @ JSR303Validálás kommentár a Felhasználó tárgy. Aztán hozzáadtuk a Érvényesítés érv, hogy validációkkal dolgozzon olyan módszerekkel, mint hasViolations, getViolations, és addViolation.

Utoljára a FlashScope Az objektum az érvényesítési hiba megjelenítésére szolgál a képernyőn.

Megjegyzés: A Ninja a babellenőrzéshez a JSR303 specifikációit követi. Ugyanakkor a JSR380 specifikáció (Bean Validation 2.0) az új szabvány.

14. Következtetés

Ebben a cikkben a Ninja web keretrendszert fedeztük fel - egy teljes veremű keretrendszert, amely a népszerű Java könyvtárak segítségével praktikus szolgáltatásokat nyújt.

Először is létrehoztunk egy egyszerű webalkalmazást a vezérlők, modellek, és szolgáltatások. Ezután engedélyeztük a JPA támogatását az alkalmazásban a kitartás érdekében.

Ugyanakkor láttunk néhány olyan alapvető funkciót, mint az Útvonalak, a JSON renderelés, az internacionalizáció és a Flash hatókörök.

Végül feltártuk a keretrendszer által nyújtott validációs támogatást.

Szokás szerint az összes kód implementáció elérhető a GitHubon.