streamalism.org

1. Oversikt

Ratpack er et sett med lette Java-biblioteker for bygge skalerbare HTTP-applikasjoner med reaktive, asynkrone og ikke-blokkerende funksjoner.

I tillegg gir Ratpack også integrasjon med teknologier og rammer som Google Guice, Spring Boot, RxJava og Hystrix.

I denne veiledningen vil vi utforske hvordan du bruker Ratpack med Groovy.

2. Hvorfor Groovy?

Groovy er et kraftig, dynamisk språk som kjører i JVM.

Derfor gjør Groovy skripting og domenespesifikke språk veldig enkelt. Med Ratpack gir dette rask utvikling av webapplikasjoner.

Ratpack gir enkel integrering med Groovy gjennom ratpack-groovy og ratpackgroovy-test biblioteker.

3. Ratpack-applikasjon ved hjelp av Groovy Script

Ratpack Groovy API-er er bygget i Java, slik at de enkelt kan integreres med både Java- og Groovy-applikasjoner. De er tilgjengelige i ratpack.groovy pakke.

I kombinasjon med Groovys skripterevner og Grape-avhengighetsadministrasjon kan vi faktisk lage en Ratpack-drevet webapplikasjon på bare noen få linjer:

@Grab ('io.ratpack: ratpack-groovy: 1.6.1') importerer statisk ratpack.groovy.Groovy.ratpack ratpack {handlers {get {render 'Hello World from Ratpack with Groovy !!' }}}

Dette er vår første handler, håndtering av en GET-forespørsel. Alt vi måtte gjøre var å legge til noen grunnleggende DSL for å aktivere Ratpack-serveren.

La oss nå kjøre dette som et Groovy-skript for å starte applikasjonen. Som standard vil applikasjonen være tilgjengelig den // lokal vert: 5050:

$ curl -s localhost: 5050 Hello World fra Ratpack med Groovy !!

Vi kan også konfigurere porten ved hjelp av ServerConfig:

ratpack {serverConfig {port (5056)}}

Ratpack tilbyr også en varm omlastingsfunksjon, noe som betyr at vi kan endre oss Ratpack.groovy, og se deretter endringene i det øyeblikket applikasjonen serverer vår neste HTTP-forespørsel.

4. Ratpack-Groovy Dependency Management

Det er flere måter å aktivere ratpack-groovy Brukerstøtte.

4.1. Drue

Vi kan bruke Groovys innebygde avhengighetsleder Grape.

Det er så enkelt som å legge til en kommentar til vår Ratpack.groovy manus:

@Grab ('io.ratpack: ratpack-groovy: 1.6.1') importerer statisk ratpack.groovy.Groovy.ratpack

4.2. Maven avhengighet

For å bygge i Maven er alt vi trenger å legge til avhengighet for ratpack-groovy bibliotek:

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

4.3. Gradle

Vi kan aktivere det ratpack-groovy integrering, ved å legge til Ratpack’s Gradle-plugin for Groovy i build.gradle:

plugins {id 'io.ratpack.ratpack-groovy' versjon '1.6.1'}

5. Ratpack Handlers i Groovy

Behandlere gir en måte å håndtere forespørsler og svar på nettet på. Forespørsel og svarobjekter kan nås i denne lukkingen.

Vi kan håndtere nettforespørsler ved hjelp av HTTP-metoder som GET og POST:

behandlere {get ("greet /: name") {ctx -> gjengi "Hello" + ctx.getPathTokens (). get ("name") + "!!!" }} 

Vi kan teste denne nettforespørselen gjennom // localhost: 5050 / hilsen /:

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

I koden til behandleren, ctx er den Kontekst registerobjekt som gir tilgang til banevariabler, forespørsels- og responsobjekter.

Handlere har også støtte for å håndtere JSON gjennom Jackson.

La oss returnere JSON, konvertert fra et Groovy-kart:

få ("data") {gjengi Jackson.json ([tittel: "Mr", navn: "Norman", land: "USA"])} 

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

Her, Jackson.json brukes til å gjøre konverteringen.

6. Ratpack løfter i Groovy

Som vi vet muliggjør Ratpack de asynkrone og ikke-blokkerende funksjonene i applikasjonen. Dette er implementert med Ratpack Promises.

Løfter er lik de som brukes i JavaScript, og ligner litt på Java Framtid. Vi kan tenke oss en Love som representasjon av en verdi som vil være tilgjengelig i fremtiden:

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

Den siste handlingen her er deretter handling, som bestemmer hva du skal gjøre med den endelige verdien. I dette tilfellet returnerer vi det som et svar på POSTEN.

La oss forstå denne koden mer detaljert. Her, Jackson. Fra Json analyserer JSON til forespørselsorganet ved hjelp av ObjectMapperBruker. Så, den innebygde Kontekst.analysere metoden binder den til Love gjenstand.

Løftet fungerer asynkront. Når deretter operasjonen til slutt utføres, svaret returneres:

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

Vi må merke oss at Promise-biblioteket er ganske rikt, slik at vi kan kjede handlinger ved hjelp av funksjoner som kart og flatMap.

7. Integrasjon med en database

Å ha asynkrone håndterere er mest fordelaktig når våre håndterere må vente på tjenester. La oss demonstrere dette ved å integrere Ratpack-applikasjonen vår med en H2-database.

Vi kan enten bruke Ratpack's HikariModule klasse som er en utvidelse av HikariCP JDBC tilkoblingsbasseng, eller Groovy Sql for databaseintegrasjon.

7.1. HikariModule

For å legge til HikariCP-støtte, la oss først legge til følgende Hikari- og H2-avhengighetsavhengigheter i vår pom.xml:

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

Eller vi kan legge til følgende avhengigheter i vår build.gradle:

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

Nå skal vi erklære HikariModule under bindinger stenging for tilkoblingsbassenget:

importer ratpack.hikari.HikariModule ratpack {bindings {module (HikariModule) {config -> config.dataSourceClassName = 'org.h2.jdbcx.JdbcDataSource' config.addDataSourceProperty ('URL', "jdbc: h2: mem: devDB; INIT = KJØRING FRA 'classpath: /User.sql' ")}}} 

Til slutt er vi klar til å bruke den til enkle databasebehandlinger ved bruk av Java Forbindelse og PreparedStatement:

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

La oss sjekke at føreren fungerer som forventet:

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

7.2. Groovy Kvm Klasse

Vi kan bruke Groovy Kvm for raske databaseoperasjoner, gjennom metoder som rader og executeInsert:

get ('fetchUsers') {def db = [url: 'jdbc: h2: mem: devDB'] def sql = Sql.newInstance (db.url, db.user, db.password) def users = sql.rows (" VELG * FRA BRUKER "); gjengi (Jackson.json (brukere))} 

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

La oss skrive et HTTP POST-eksempel med Kvm:

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

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

8. Enhetstesting

8.1. Sette opp testene

Som diskutert, gir Ratpack også ratpackgroovy-test bibliotek for testing a ratpack-groovy applikasjon.

For å bruke den, kan vi legge den til som Maven-avhengighet i vår pom.xml:

 io.ratpack ratpack-groovy-test 1.6.1 

Alternativt kan vi legge til Gradle-avhengighet i vår build.gradle:

testCompile ratpack.dependency ('groovy-test')

Da må vi lage en Groovy-hovedklasse RatpackGroovyApp.groovy for å la oss teste Ratpack.groovy manus.

offentlig klasse RatpackGroovyApp {public static void main (String [] args) {File file = new File ("src / main / groovy / com / baeldung / Ratpack.groovy"); def shell = new GroovyShell () shell.evaluate (file)}}

Når du kjører Groovy-tester som JUnit-tester, klassen vil påkalle Ratpack.groovy skript ved hjelp av GroovyShell. I sin tur vil den starte Ratpack-serveren for testing.

La oss nå skrive vår Groovy Test-klasse RatpackGroovySpec.groovy sammen med koden for å starte Ratpack-serveren gjennom RatpackGroovyApp:

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

Ratpack gir MainClassApplicationUnderTest for å spotte applikasjonsklassen for å starte serveren.

8.2. Skrive våre tester

La oss skrive testene våre, og starte med en veldig grunnleggende test for å sjekke om applikasjonen kan starte:

@Test ugyldig "test om app startes" () {når: get ("") så: hevder respons.statusCode == 200 hevder respons.body.text == "Hello World fra Ratpack med Groovy !!" }

La oss nå skrive en ny test for å verifisere svaret fra fetchUsers få handler:

@Test ugyldig "test fetchUsers" () {når: get ("fetchUsers") da: 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 ":" FRANCE "}] '}

Ratpack testrammeverket tar seg av å starte og stoppe serveren for oss.

9. Konklusjon

I denne artikkelen har vi sett noen måter å skrive HTTP-håndtere for Ratpack ved hjelp av Groovy. Vi utforsket også løfter og integrering av databaser.

Vi har sett hvordan Groovy stenger, DSL og Groovy Kvm gjøre koden vår kortfattet, effektiv og lesbar. Samtidig gjør Groovys teststøtte enhetstesting og integrasjonstesting grei.

Med disse teknikkene kan vi bruke Groovys dynamiske språkfunksjoner og uttrykksfulle API-er for raskt å utvikle høyytelses, skalerbare HTTP-applikasjoner med Ratpack.

Som vanlig kan eksempelkoden bli funnet på GitHub.