Inleiding tot Ratpack

1. Overzicht

Ratpack is een set van JVM gebaseerde bibliotheken gebouwd voor moderne high-performance real-time applicaties. Het is bovenop ingebed Netty gebeurtenisgestuurde netwerkengine en is volledig compatibel met het reactieve ontwerppatroon.

In dit artikel zullen we leren hoe we Ratpack kunnen gebruiken en we zullen er een kleine applicatie mee bouwen.

2. Waarom Ratpack?

De belangrijkste voordelen van Ratpack:

  • het is erg licht, snel en schaalbaar
  • het verbruikt minder geheugen dan andere frameworks zoals DropWizard; een interessant resultaat van de benchmarkvergelijking vindt u hier
  • omdat het bovenop is gebouwd NettyRatpack is volledig gebeurtenisgestuurd en niet-blokkerend van aard
  • het heeft ondersteuning voor Guice afhankelijkheidsbeheer
  • net als Voorjaar Laars, Ratpack heeft zijn eigen testbibliotheken om snel testcases op te zetten

3. Een applicatie aanmaken

Om te begrijpen hoe Ratpack werkt, beginnen we met het maken van een kleine applicatie.

3.1. Afhankelijkheden van Maven

Laten we eerst de volgende afhankelijkheden toevoegen aan onze pom.xml:

 io.ratpack ratpack-core 1.4.5 io.ratpack ratpack-test 1.4.5 

U kunt de nieuwste versie bekijken op Maven Central.

Merk op dat hoewel we Maven gebruiken als ons build-systeem, het volgens Ratpack-aanbeveling beter is om te gebruiken Grijpen als een build-tool, aangezien Ratpack eersteklas Gradle-ondersteuning biedt via de Gradle-plug-in van Ratpack.

We kunnen het volgende build Gradle-script gebruiken:

buildscript {repositories {jcenter ()} afhankelijkheden {classpath "io.ratpack: ratpack-gradle: 1.4.5"}} pas plug-in toe: "io.ratpack.ratpack-java" repositories {jcenter ()} afhankelijkheden {testCompile 'junit: junit: 4.11 'runtime "org.slf4j: slf4j-simple: 1.7.21"} test {testLogging {events' gestart ',' geslaagd '}} 

3.2. De applicatie bouwen

Zodra ons buildbeheer is geconfigureerd, moeten we een klasse maken om het embedded te starten Netty server en bouw een eenvoudige context om de standaardverzoeken af ​​te handelen:

public class Applicatie {public static void main (String [] args) gooit uitzondering {RatpackServer.start (server -> server.handlers (chain -> chain .get (ctx -> ctx.render) ("Welkom bij Baeldung ratpack !!! ")))); }}

Zoals we kunnen zien, door te gebruiken RatpackServer we kunnen nu de server starten (standaard poort 5050). De handlers method neemt een functie die een Chain-object ontvangt, dat alle respectieve inkomende verzoeken in kaart brengt. Deze "Handler Chain API" wordt gebruikt voor het bouwen van de responsafhandelingsstrategie.

Als we dit codefragment uitvoeren en in de browser klikken op // localhost: 5050, "Welkom bij Baeldung ratpack !!!" moet worden weergegeven.

Evenzo kunnen we een HTTP POST-verzoek toewijzen.

3.3. Omgaan met URL-padparameters

In het volgende voorbeeld moeten we een URL-padparameter vastleggen in onze applicatie. In Ratpack gebruiken we PathTokens om ze vast te leggen:

RatpackServer.start (server -> server .handlers (keten -> keten .get (": naam", ctx -> ctx.render ("Hallo" + ctx.getPathTokens (). Get ("naam") + "!! ! "))));

Hier brengen we de naam URL-parameter. Wanneer een verzoek maar wil // localhost: 5050 / John zou komen, zal het antwoord zijn "Hallo John !!!".

3.4. Verzoek- / antwoordkopwijziging met / zonder filter

Soms moeten we de inline HTTP-responsheader aanpassen op basis van onze behoefte. Ratpack heeft MutableHeaders om uitgaande reacties aan te passen.

We moeten bijvoorbeeld de volgende kopteksten in het antwoord wijzigen: Access-Control-Allow-Origin, Accepteer-taal, en Accept-Charset:

RatpackServer.start (server -> server.handlers (chain -> chain.all (ctx -> {MutableHeaders headers = ctx.getResponse (). GetHeaders (); headers.set ("Access-Control-Allow-Origin", " * "); headers.set (" Accept-Language "," en-us "); headers.set (" Accept-Charset "," UTF-8 "); ctx.next ();}). get (" : name ", ctx -> ctx .render (" Hallo "+ ctx.getPathTokens (). get (" naam ") +" !!! "))));

Door het gebruiken van MutableHeaders we stellen de drie headers in en duwen ze in de Ketting.

Op dezelfde manier kunnen we ook de inkomende aanvraagheaders controleren:

ctx.getRequest (). getHeaders (). get ("// TODO")

Hetzelfde kan worden bereikt door een filter te maken. Ratpack heeft een Handler koppel, die kan worden geïmplementeerd om een ​​filter te maken. Het heeft maar één methode handvat(), die de stroom kost Context als parameter:

public class RequestValidatorFilter implementeert handler {@Override public void handle (Context ctx) genereert uitzondering {MutableHeaders headers = ctx.getResponse (). getHeaders (); headers.set ("Access-Control-Allow-Origin", "*"); ctx.next (); }}

We kunnen dit filter op de volgende manier gebruiken:

RatpackServer.start (server -> server.handlers (chain -> chain .all (nieuw RequestValidatorFilter ()) .get (ctx -> ctx.render ("Welkom bij baeldung ratpack !!!")))); }

3.5. JSON-parser

Ratpack gebruikt intern sneller-jackson voor JSON-parsing. We kunnen de Jackson-module gebruiken om elk object naar JSON te parseren.

Laten we een eenvoudige POJO-klasse maken die zal worden gebruikt voor het parseren:

openbare klasse Medewerker {privé Lange id; private String-titel; private String naam; // getters en setters}

Hier hebben we een eenvoudige POJO-klasse gemaakt met de naam Werknemer, die drie parameters heeft: id, titel, en naam. Nu gaan we dit gebruiken Werknemer object om te converteren naar JSON en hetzelfde te retourneren wanneer een bepaalde URL wordt geraakt:

Lijst werknemers = nieuwe ArrayList (); werknemers.add (nieuwe werknemer (1L, "Mr", "John Doe")); werknemers.add (nieuwe werknemer (2L, "Mr", "White Snow")); RatpackServer.start (server -> server.handlers (chain -> chain .get ("data / medewerkers", ctx -> ctx.render (Jackson.json (medewerkers)))));

Zoals we kunnen zien, voegen we er handmatig twee toe Werknemer objecten in een lijst en ze parsen als JSON met behulp van Jackson module. Zo snel als de / data / medewerkers URL is geraakt, het JSON-object wordt geretourneerd.

Punt om op te merken is dat we gebruiken niet ObjectMapper helemaal aangezien de Jackson-module van Ratpack het nodige in een oogwenk doet.

3.6. In-Memory Database

Ratpack biedt eersteklas ondersteuning voor in-memory databases. Het gebruikt HikariCP voor het poolen van JDBC-verbindingen. Om het te kunnen gebruiken, moeten we Ratpack's HikariCP-module-afhankelijkheid toevoegen aan het pom.xml:

 io.ratpack ratpack-hikari 1.4.5 

Als we gebruiken Grijpen, hetzelfde moet worden toegevoegd in het Gradle-buildbestand:

compileer ratpack.dependency ('hikari')

Nu moeten we een SQL-bestand maken met DDL-instructies in de tabel, zodat de tabellen worden gemaakt zodra de server actief is. We maken het DDL.sql bestand in het src / main / resources directory en voeg er enkele DDL-statements aan toe.

Omdat we de H2-database gebruiken, moeten we daarvoor ook afhankelijkheden toevoegen.

Nu, door HikariModule te gebruiken, kunnen we de database tijdens runtime initialiseren:

RatpackServer.start (server -> server.registry (Guice.registry (bindings -> bindings.module (HikariModule.class, config -> {config.setDataSourceClassName ("org.h2.jdbcx.JdbcDataSource"); config.addDataSourceProperty (" URL "," jdbc: h2: mem: baeldung; INIT = RUNSCRIPT VAN 'classpath: /DDL.sql' ");}))). Handlers (...));

4. Testen

Zoals eerder vermeld, biedt Ratpack eersteklas ondersteuning voor jUnit-testcases. Door MainClassApplicationUnderTest te gebruiken, kunnen we eenvoudig testcases maken en de endpoints testen:

@RunWith (JUnit4.class) openbare klasse ApplicationTest {MainClassApplicationUnderTest appUnderTest = nieuwe MainClassApplicationUnderTest (Application.class); @Test openbare leegte gegevenDefaultUrl_getStaticText () {assertEquals ("Welkom bij baeldung ratpack !!!", appUnderTest.getHttpClient (). GetText ("/")); } @Test openbare leegte gegevenDynamicUrl_getDynamicText () {assertEquals ("Hallo dummybot !!!", appUnderTest.getHttpClient (). GetText ("/ dummybot")); } @Test openbare leegte gegevenUrl_getListOfEmployee () gooit JsonProcessingException {Lijst werknemers = nieuwe ArrayList (); ObjectMapper-mapper = nieuwe ObjectMapper (); werknemers.add (nieuwe werknemer (1L, "Mr", "John Doe")); werknemers.add (nieuwe werknemer (2L, "Mr", "White Snow")); assertEquals (mapper.writeValueAsString (medewerkers), appUnderTest.getHttpClient (). getText ("/ data / medewerkers")); } @After public void shutdown () {appUnderTest.close (); }}

Houd er rekening mee dat we het draaien handmatig moeten beëindigen MainClassApplicationUnderTest bijvoorbeeld door de dichtbij() methode omdat het JVM-bronnen onnodig kan blokkeren. Dat is waarom we hebben gebruikt @Na annotatie om de instantie met geweld te beëindigen zodra de testcase is uitgevoerd.

5. Conclusie

In dit artikel hebben we gezien hoe eenvoudig Ratpack is.

Zoals altijd is de volledige broncode beschikbaar op GitHub.