Inleiding tot Jooby

1. Overzicht

Jooby is een schaalbaar en snel micro-webraamwerk dat bovenop de meest gebruikte NIO-webservers. Het is heel eenvoudig en modulair, duidelijk ontworpen voor de moderne webarchitectuur. Het wordt geleverd met ondersteuning voor Javascript en Kotlin te.

Standaard, Jooby wordt geleverd met geweldige ondersteuning voor Netty, Jetty en Undertow.

In dit artikel leren we over het algemeen Jooby projectstructuur en hoe u een eenvoudige webapplicatie bouwt met Jooby.

2. Applicatie-architectuur

Een eenvoudige Jooby applicatiestructuur zal hieronder leuk vinden:

├── openbaar | └── welcome.html ├── conf | ├── application.conf | └── logback.xml └── src | ├── hoofd | | └── java | | └── com | | └── baeldung | | └── jooby | | └── App.java | └── test | └── java | └── com | └── baeldung | └── jooby | └── AppTest.java ├── pom.xml

Punt om op te merken is dat in openbaar directory kunnen we statische bestanden zoals css / js / html etc. in de conf directory, kunnen we elk configuratiebestand plaatsen dat een applicatie nodig heeft, zoals logback.xml of application.conf enz.

3. Maven Afhankelijkheid

We kunnen een eenvoudig maken Jooby applicatie door de volgende afhankelijkheid toe te voegen aan onze pom.xml:

 org.jooby jooby-netty 1.1.3 

Als we willen kiezen Steiger of Undertow we kunnen de volgende afhankelijkheid gebruiken:

 org.jooby jooby-jetty 1.1.3 org.jooby jooby-onderstroom 1.1.3 

U kunt de nieuwste versie van het Jooby project in de Central Maven Repository.

Jooby heeft ook een speciaal Maven-archetype. We kunnen het gebruiken om een ​​voorbeeldproject te maken met alle benodigde afhankelijkheden vooraf gebouwd.

We kunnen het volgende script gebruiken om het voorbeeldproject te genereren:

mvn-archetype: genereer -B -DgroupId = com.baeldung.jooby -DartifactId = jooby -Dversion = 1.0 -DarchetypeArtifactId = jooby-archetype -DarchetypeGroupId = org.jooby -DarchetypeVersion = 1.1.3

4. Een applicatie bouwen

4.1. De server initiëren

Om de embedded server te starten, hebben we het volgende codefragment nodig:

public class App breidt Jooby uit {public static void main (String [] args) {run (App :: new, args); }}

Eenmaal gestart, draait de server aan standaard poort8080.

We kunnen de back-end-server ook configureren met aangepaste poort en aangepaste HTTPS haven:

{poort (8081); securePort (8443); }

4.2. Implementatie van de router

Het is heel eenvoudig om een ​​padgebaseerde router te maken in Jooby. We kunnen bijvoorbeeld een router maken voor pad ‘/Log in‘Op de volgende manier:

{get ("/ login", () -> "Hallo van Baeldung"); }

Op een vergelijkbare manier, als we met andere willen omgaan HTTP methoden zoals POST, PUT, enz.We kunnen het onderstaande codefragment gebruiken:

{post ("/ save", req -> {Mutant token = req.param ("token"); return token.intValue ();}); }

Hier halen we het token van de verzoekparameter op uit het verzoek. Standaard worden alle verzoekparameters getypt in Jooby‘S Mutant data type. Op basis van de verwachting kunnen we het converteren naar elk ondersteund primitief gegevenstype.

We kunnen elke url-parameter op de volgende manier controleren:

{get ("/ user / {id}", req -> "Hallo gebruiker:" + req.param ("id"). value ()); get ("/ user /: id", req -> "Hallo gebruiker:" + req.param ("id"). value ()); }

We kunnen al het bovenstaande gebruiken. Het is ook mogelijk om parameters te vinden die beginnen met een vaste inhoud. We kunnen bijvoorbeeld een URL-parameter vinden die begint met ‘uid: ' op de volgende manier:

{get ("/ uid: {id}", req -> "Hallo gebruiker met id: uid" + req.param ("id"). waarde ()); }

4.3. MVC Pattern Controller implementeren

Voor een bedrijfstoepassing, Jooby wordt geleverd met een MVC API, net als alle andere MVC-frameworks zoals Spring MVC.

We kunnen bijvoorbeeld een pad met de naam ‘/Hallo‘ :

@Path ("/ hallo") openbare klasse GetController {@GET openbare String hallo () {return "Hallo Baeldung"; }}

Op dezelfde manier kunnen we een handler maken om andere HTTP-methoden mee af te handelen @POST, @PUT, @DELETE, enz. annotatie.

4.4. Omgaan met statische inhoud

Om statische inhoud zoals HTML, Javascript, CSS, afbeelding, enz. Te kunnen weergeven, moeten we die bestanden in de openbaar directory.

Eenmaal geplaatst, kunnen we vanaf de router elke URL naar deze bronnen toewijzen:

{activa ("/ medewerker", "form.html"); }

4.5. Verwerkingsformulier

Jooby's Verzoek interface verwerkt standaard elk formulierobject zonder handmatige typen te gebruiken.

Laten we aannemen dat we werknemersgegevens moeten indienen via een formulier. Bij de eerste stap moeten we een Werknemer bean-object dat we zullen gebruiken om de gegevens te bewaren:

openbare klasse Werknemer {String-id; String naam; String e-mail; // standaard constructeurs, getters en setters}

Nu moeten we een pagina maken om het formulier te maken:

Vervolgens maken we een post-handler om dit formulier te adresseren en de ingediende gegevens op te halen:

post ("/ submitForm", req -> {Employee employee = req.params (Employee.class); // ... return "medewerkersgegevens succesvol opgeslagen";});

Punt om op te merken is dat we het formulier moeten aangeven enctype net zo application / x-www-form-urlencoded ter ondersteuning van de dynamische formulierbinding.

Door Request.file (String bestandsnaam) we kunnen het geüploade bestand ophalen:

post ("/ upload", req -> {Upload upload = req.file ("file"); // ... upload.close ();});

4.6. Een filter implementeren

Uit de doos, Jooby biedt de flexibiliteit om zowel globale filters als padgebaseerde filters te definiëren.

Implementeren van filter in Jooby is een beetje lastig sinds we moeten het URL-pad twee keer configureren, een keer voor het filter en nog een keer voor de handler.

Als we bijvoorbeeld een filter moeten implementeren voor een URL-pad met de naam ‘/filter', we moeten het filter expliciet in dit pad implementeren:

get ("/ filter", (req, resp, chain) -> {// ... chain.next (req, resp);});

De syntaxis lijkt veel op Servlet filter. Het is mogelijk om het verzoek te beperken en het antwoord in het filter zelf terug te sturen door te bellen Response.send (resultaat resultaat) methode.

Zodra het filter is geïmplementeerd, moeten we de aanvraaghandler implementeren:

get ("/ filter", (req, resp) -> {resp.send ("filter response");});

4.7. Sessie

Jooby wordt geleverd met twee soorten sessie-implementatie; in-memory en op cookies gebaseerd.

Het implementeren van sessiebeheer in het geheugen is vrij eenvoudig. We hebben de opties om een ​​van de high-throughput session stores te kiezen die beschikbaar zijn Jooby Leuk vinden EhCache, Guava, HazleCast, Cassandra, Couchbase, Redis, MongoDB, en Memcached.

Om bijvoorbeeld een op Redis gebaseerde sessieopslag te implementeren, moeten we de volgende Maven-afhankelijkheid toevoegen:

 org. jooby jooby-jedis 1.1.3 

Nu kunnen we het onderstaande codefragment gebruiken om sessiebeheer in te schakelen:

{use (new Redis ()); sessie (RedisSessionStore.class); get ("/ session", req -> {Session session = req.session (); session.set ("token", "value"); return session.get ("token"). value ();}); }

Een punt om op te merken is dat we kunnen configureren Redis url als de ‘Db ' eigenschap in de application.conf.

Om sessiebeheer op basis van cookies mogelijk te maken, moeten we dit aangeven cookieSession (). Als een op cookies gebaseerde benadering is geselecteerd, moeten we dit aangeven applicatie.geheim eigenschap in de application.conf het dossier. Aangezien elke cookie die wordt ondertekend, wordt ondertekend met deze geheime sleutel, is het altijd raadzaam om een ​​lang willekeurig stringfragment als een geheime sleutel te gebruiken.

Bij zowel in-memory als op cookies gebaseerde benadering moeten we de noodzakelijke configuratieparameter in het application.conf bestand, anders zal de applicatie een IllegalStateException in de beginfase.

5. Testen

Het testen van een MVC-route is inderdaad eenvoudig, omdat een route voor een bepaalde klasse aan een strategie is gebonden. Dit maakt het gemakkelijk om unit-tests uit te voeren op alle routes.

We kunnen bijvoorbeeld snel een testcase maken voor de standaard-URL:

openbare klasse AppTest {@ClassRule openbare statische JoobyRule app = nieuwe JoobyRule (nieuwe app ()); @Test openbare ongeldige gegeven_defaultUrl_expect_fixedString () {get ("/"). Then (). AssertThat (). Body (equalTo ("Hallo wereld!")) .StatusCode (200) .contentType ("text / html; charset = UTF -8 "); }}

Punt om op te merken is dat het gebruik van @ClassRule annotatie zal slechts één instantie van de server creëren voor alle testgevallen. Als we afzonderlijke instanties van de servers moeten bouwen voor elke testcase, moeten we de @Regel annotatie zonder de statische modifier.

We kunnen ook gebruik maken van Jooby's MockRouter om het pad op dezelfde manier te testen:

@Test openbare leegte gegeven_defaultUrl_with_mockrouter_expect_fixedString () gooit Throwable {String resultaat = nieuwe MockRouter (nieuwe app ()). Get ("/"); assertEquals ("Hallo wereld!", resultaat); }

6. Conclusie

In deze tutorial hebben we de Jooby project en zijn essentiële functionaliteit.

Zoals altijd is de volledige broncode beschikbaar op GitHub.