streamalism.org

1. Overzicht

Ratpack is een set lichtgewicht Java-bibliotheken voor schaalbare HTTP-applicaties bouwen met reactieve, asynchrone en niet-blokkerende functies.

Bovendien biedt Ratpack ook integratie met technologieën en frameworks zoals Google Guice, Spring Boot, RxJava en Hystrix.

In deze tutorial gaan we verkennen hoe Ratpack te gebruiken met Groovy.

2. Waarom Groovy?

Groovy is een krachtige, dynamische taal die in de JVM draait.

Daarom maakt Groovy scripting en domeinspecifieke talen heel gemakkelijk. Met Ratpack zorgt dit voor een snelle ontwikkeling van webapplicaties.

Ratpack biedt eenvoudige integratie met Groovy via het ratpack-groovy en ratpack-groovy-test bibliotheken.

3. Ratpack-applicatie met behulp van Groovy Script

De Ratpack Groovy API's zijn gebouwd in Java, zodat ze gemakkelijk kunnen worden geïntegreerd met zowel Java- als Groovy-applicaties. Ze zijn beschikbaar in de ratpack.groovy pakket.

In combinatie met Groovy's scriptcapaciteiten en Grape-afhankelijkheidsbeheer, kunnen we in slechts een paar regels snel een door Ratpack aangedreven webtoepassing maken:

@Grab ('io.ratpack: ratpack-groovy: 1.6.1') importeer statische ratpack.groovy.Groovy.ratpack ratpack {handlers {krijg {render 'Hallo wereld van Ratpack met Groovy !!' }}}

Dit is onze eerste handler, het afhandelen van een GET-verzoek. Het enige wat we hoefden te doen was wat basis-DSL toe te voegen om de Ratpack-server in te schakelen.

Laten we dit nu uitvoeren als een Groovy-script om de applicatie te starten. Standaard is de applicatie beschikbaar op // localhost: 5050:

$ curl -s localhost: 5050 Hallo wereld van Ratpack met Groovy !!

We kunnen de poort ook configureren met Serverconfiguratie:

ratpack {serverConfig {poort (5056)}}

Ratpack biedt ook een functie voor hot herladen, wat betekent dat we kunnen veranderen Ratpack. Groovy, en bekijk vervolgens de wijzigingen op het moment dat de applicatie ons volgende HTTP-verzoek bedient.

4. Ratpack-Groovy afhankelijkheidsbeheer

Er zijn verschillende manieren om in te schakelen ratpack-groovy ondersteuning.

4.1. Druif

We kunnen de ingebouwde afhankelijkheidsmanager Grape van Groovy gebruiken.

Het is net zo eenvoudig als het toevoegen van een annotatie aan onze Ratpack. Groovy script:

@Grab ('io.ratpack: ratpack-groovy: 1.6.1') importeer statische ratpack.groovy.Groovy.ratpack

4.2. Afhankelijkheid van Maven

Voor het bouwen in Maven is alles wat we nodig hebben de afhankelijkheid voor het ratpack-groovy bibliotheek:

 io.ratpack ratpack-groovy $ {ratpack.version} 

4.3. Grijpen

We kunnen inschakelen ratpack-groovy integratie, door Ratpack's Gradle-plug-in voor Groovy toe te voegen in build.gradle:

plug-ins {id 'io.ratpack.ratpack-groovy' versie '1.6.1'}

5. Ratpack-handlers in Groovy

Handlers bieden een manier om webverzoeken en -antwoorden af ​​te handelen. In deze afsluiting zijn de verzoek- en antwoordobjecten toegankelijk.

We kunnen webverzoeken afhandelen met behulp van HTTP-methoden zoals GET en POST:

handlers {get ("greet /: name") {ctx -> render "Hallo" + ctx.getPathTokens (). get ("name") + "!!!" }} 

We kunnen dit webverzoek testen via // localhost: 5050 / greet /:

$ curl -s localhost: 5050 / greet / Norman Hallo Norman !!!

In de code van de handler, ctx is de Context registry-object dat toegang verleent tot padvariabelen, verzoek- en antwoordobjecten.

Handlers hebben ook ondersteuning voor het omgaan met JSON via Jackson.

Laten we JSON teruggeven, geconverteerd van een Groovy-kaart:

get ("data") {render Jackson.json ([title: "Mr", name: "Norman", country: "USA"])} 

$ curl -s localhost: 5050 / data {"title": "Mr", "name": "Norman", "country": "USA"}

Hier, Jackson.json wordt gebruikt om de conversie uit te voeren.

6. Ratpack belooft in Groovy

Zoals we weten, maakt Ratpack de asynchrone en niet-blokkerende functies in de applicatie mogelijk. Dit wordt geïmplementeerd met Ratpack Promises.

Beloften zijn vergelijkbaar met die in JavaScript en lijken een beetje op Java Toekomst. We kunnen een Belofte als representatie van een waarde die in de toekomst beschikbaar zal zijn:

post ("user") {Promise user = parse (Jackson.fromJson (User)) user.then {u -> render u.name}}

De laatste actie hier is de dan actie, die bepaalt wat er met de uiteindelijke waarde moet worden gedaan. In dit geval sturen we het terug als reactie op de POST.

Laten we deze code in meer detail begrijpen. Hier, Jackson. Van Json parseert de JSON van de hoofdtekst van het verzoek met behulp van de ObjectMapperGebruiker. Dan is het ingebouwde Context.ontleden methode bindt het aan de Belofte voorwerp.

De belofte werkt asynchroon. Wanneer de dan bewerking wordt uiteindelijk uitgevoerd, wordt het antwoord geretourneerd:

curl -X POST -H 'Content-type: application / json' --data \ '{"id": 3, "title": "Mrs", "name": "Jiney Weiber", "country": "UK "} '\ // localhost: 5050 / medewerker Jiney Weiber

We moeten opmerken dat de Promise-bibliotheek behoorlijk rijk is, waardoor we acties kunnen koppelen met behulp van functies zoals kaart en flatMap.

7. Integratie met een database

Het hebben van asynchrone handlers is het meest voordelig wanneer onze handlers op services moeten wachten. Laten we dit demonstreren door onze Ratpack-applicatie te integreren met een H2-database.

We kunnen ofwel de Ratpack's gebruiken HikariModule class die een extensie is van HikariCP JDBC-verbindingspool, of Groovy Sql voor database-integratie.

7.1. HikariModule

Om HikariCP-ondersteuning toe te voegen, moeten we eerst de volgende Hikari- en H2-maven-afhankelijkheden toevoegen aan onze pom.xml:

 io.ratpack ratpack-hikari $ {ratpack.version} com.h2database h2 $ {h2.version} 

Of we kunnen de volgende afhankelijkheden toevoegen aan onze build.gradle:

afhankelijkheden {compileer ratpack.dependency ('hikari') compileer "com.h2database: h2: $ h2.version"}

Nu zullen we verklaren HikariModule onder de bindingen sluiting voor de verbindingspool:

import ratpack.hikari.HikariModule ratpack {bindingen {module (HikariModule) {config -> config.dataSourceClassName = 'org.h2.jdbcx.JdbcDataSource' config.addDataSourceProperty ('URL', "jdbc: h2: mem: devDB; INIT = UITVOEREN VANUIT 'classpath: /User.sql' ")}}} 

Ten slotte zijn we helemaal klaar om het te gebruiken voor eenvoudige databasebewerkingen met Java's Verbinding en PreparedStatement:

get ('fetchUserName /: id') {Context ctx -> Connection connection = ctx.get (DataSource.class) .getConnection () PreparedStatement queryStatement = connection.prepareStatement ("SELECTEER NAAM VAN GEBRUIKER WAAR ID =?") queryStatement.setInt (1, Integer.parseInt (ctx.getPathTokens (). Get ("id"))) ResultSet resultSet = queryStatement.executeQuery () resultSet.next () render resultSet.getString (1)} 

Laten we eens kijken of de handler werkt zoals verwacht:

$ curl -s localhost: 5050 / fetchUserName / 1 Norman Potter

7.2. Groovy SQL Klasse

We kunnen Groovy gebruiken SQL voor snelle databasebewerkingen, via methoden zoals rijen en executeInsert:

get ('fetchUsers') {def db = [url: 'jdbc: h2: mem: devDB'] def sql = Sql.newInstance (db.url, db.user, db.password) def gebruikers = sql.rows (" SELECTEER * VAN GEBRUIKER "); render (Jackson.json (gebruikers))} 

$ curl -s localhost: 5050 / fetchUsers [{"ID": 1, "TITLE": "Mr", "NAME": "Norman Potter", "COUNTRY": "USA"}, {"ID": 2, "TITLE": "Miss", "NAME": "Ketty Smith", "COUNTRY": "FRANCE"}]

Laten we een HTTP POST-voorbeeld schrijven met SQL:

post ('addUser') {parse (Jackson.fromJson (Gebruiker)). dan {u -> def db = [url: 'jdbc: h2: mem: devDB'] Sql sql = Sql.newInstance (db.url, db .user, db.password) sql.executeInsert ("INSERT IN TO USER VALUES (?,?,?,?)", [u.id, u.title, u.name, u.country]) render "User $ u .naam ingevoegd "}}

$ curl -X POST -H 'Content-type: application / json' --data \ '{"id": 3, "title": "Mrs", "name": "Jiney Weiber", "country": " UK "} '\ // localhost: 5050 / addUser Gebruiker Jiney Weiber ingevoegd

8. Testen van eenheden

8.1. De tests opzetten

Zoals besproken, biedt Ratpack ook de ratpack-groovy-test bibliotheek voor testen van een ratpack-groovy toepassing.

Om het te gebruiken, kunnen we het toevoegen als Maven-afhankelijkheid in ons pom.xml:

 io.ratpack ratpack-groovy-test 1.6.1 

Als alternatief kunnen we de Gradle-afhankelijkheid toevoegen in onze build.gradle:

testCompile ratpack.dependency ('groovy-test')

Dan moeten we een Groovy-hoofdklasse maken RatpackGroovyApp.groovy om ons de Ratpack. Groovy script.

openbare klasse RatpackGroovyApp {openbare statische leegte main (String [] args) {File file = new File ("src / main / groovy / com / baeldung / Ratpack.groovy"); def shell = nieuwe GroovyShell () shell.evaluate (bestand)}}

Bij het uitvoeren van Groovy-tests als JUnit-tests, de klas roept de Ratpack. Groovy script met GroovyShell. Het zal op zijn beurt de Ratpack-server starten om te testen.

Laten we nu onze klas Groovy Test schrijven RatpackGroovySpec.groovy samen met de code om de Ratpack-server te starten via de RatpackGroovyApp:

class RatpackGroovySpec {ServerBackedApplicationUnderTest ratpackGroovyApp = nieuwe MainClassApplicationUnderTest (RatpackGroovyApp.class) @Delegate TestHttpClient client = TestHttpClient.testHttpClient (ratpackGroovyApp)}

Ratpack biedt MainClassApplicationUnderTest om de applicatieklasse te bespotten voor het starten van de server.

8.2. Onze tests schrijven

Laten we onze tests schrijven, te beginnen met een heel eenvoudige test om te controleren of de applicatie kan starten:

@Test void "test of app is gestart" () {when: get ("") then: assert response.statusCode == 200 assert response.body.text == "Hallo wereld van Ratpack met Groovy !!" }

Laten we nu nog een test schrijven om het antwoord van het fetchUsers krijg handler:

@Test void "test fetchUsers" () {when: get ("fetchUsers") then: assert response.statusCode == 200 assert response.body.text == '[{"ID": 1, "TITLE": "Mr "," NAME ":" Norman Potter "," COUNTRY ":" USA "}, {" ID ": 2," TITLE ":" Miss "," NAME ":" Ketty Smith "," COUNTRY ":" FRANKRIJK "}] '}

Het Ratpack-testframework zorgt voor het starten en stoppen van de server voor ons.

9. Conclusie

In dit artikel hebben we een paar manieren gezien om HTTP-handlers voor Ratpack te schrijven met Groovy. We hebben ook beloften en database-integratie onderzocht.

We hebben gezien hoe Groovy sluitingen, DSL's en Groovy's SQL maak onze code beknopt, efficiënt en leesbaar. Tegelijkertijd maakt de testondersteuning van Groovy het testen van eenheden en integratie eenvoudig.

Met deze technieken kunnen we de dynamische taalfuncties en expressieve API's van Groovy gebruiken om snel krachtige, schaalbare HTTP-applicaties met Ratpack te ontwikkelen.

Zoals gewoonlijk is de voorbeeldcode te vinden op GitHub.