streamalism.org

1. Oversikt

I denne opplæringen tar vi en rask titt på Finagle, Twitters RPC-bibliotek.

Vi bruker den til å bygge en enkel klient og server.

2. Byggesteiner

Før vi går inn i implementeringen, må vi bli kjent med de grunnleggende konseptene vi vil bruke til å bygge applikasjonen vår. De er allment kjent, men kan ha en litt annen betydning i Finagles verden.

2.1. Tjenester

Tjenester er funksjoner representert av klasser som tar imot forespørsler og returnerer a Framtid inneholder det endelige resultatet av operasjonen eller informasjon om feilen.

2.2. Filtre

Filtre er også funksjoner. De tar en forespørsel og en tjeneste, gjør noen operasjoner på forespørselen, sender den til tjenesten, gjør noen operasjoner på den resulterende Framtid, og til slutt returnere finalen Framtid. Vi kan tenke på dem som aspekter, ettersom de kan implementere logikk som skjer rundt utførelsen av en funksjon og endre dens input og output.

2.3. Fremtid

Futures representerer de endelige resultatene av de asynkrone operasjonene. De kan være i en av de tre statene: ventende, lyktes eller mislyktes.

3. Service

Først implementerer vi en enkel HTTP-helsetjeneste. Det tar navneparameteren fra forespørselen og svarer og legger til den vanlige "Hei" -meldingen.

For å gjøre det, må vi lage en klasse som utvider abstraktet Service klasse fra Finagle-biblioteket, implementere sin søke om metode.

Det vi gjør ligner på å implementere et funksjonelt grensesnitt. Interessant, men vi kan faktisk ikke bruke den spesifikke funksjonen fordi Finagle er skrevet i Scala, og vi utnytter Java-Scala-interoperabiliteten:

offentlig klasse GreetingService utvider tjenesten {@Override public Future gjelder (Be om forespørsel) {String greeting = "Hello" + request.getParam ("name"); Reader reader = Reader.fromBuf (new Buf.ByteArray (greeting.getBytes (), 0, greeting.length ())); returner Future.value (Response.apply (request.version (), Status.Ok (), reader)); }}

4. Filtrer

Deretter skriver vi et filter som vil logge data om forespørselen til konsollen. Lik Service, må vi implementere Filter‘S søke om metode som tar imot forespørsel og returnerer a Framtid svar, men denne gangen tar det også tjenesten som den andre parameteren.

Det grunnleggende Filter klasse har fire typeparametere, men veldig ofte trenger vi ikke endre typer forespørsler og svar inne i filteret.

For det vil vi bruke SimpleFilter som slår sammen de fire typeparametrene i to. Vi vil skrive ut litt informasjon fra forespørselen og deretter bare påkalle søke om metode fra den leverte tjenesten:

offentlig klasse LogFilter utvider SimpleFilter {@Override public Future gjelder (forespørsel forespørsel, tjenestetjeneste) {logger.info ("forespørsel vert:" + forespørsel.host (). getOrElse (() -> "")); logger.info ("Be om params:"); request.getParams (). forEach (entry -> logger.info ("\ t" + entry.getKey () + ":" + entry.getValue ())); retur service. søk (forespørsel); }} 

5. Server

Nå kan vi bruke tjenesten og filteret til å bygge en server som faktisk vil lytte etter forespørsler og behandle dem.

Vi gir denne serveren en tjeneste som inneholder både filteret og tjenesten lenket sammen med og så metode:

Service serverService = ny LogFilter (). Og deretter (ny GreetingService ()); Http.serve (": 8080", serverService);

6. Oppdragsgiver

Til slutt trenger vi en klient for å sende en forespørsel til serveren vår.

For det oppretter vi en HTTP-tjeneste ved hjelp av det praktiske newService metode fra Finagle's Http klasse. Det vil være direkte ansvarlig for å sende forespørselen.

I tillegg bruker vi det samme loggfilteret vi implementerte før, og kjedet det med HTTP-tjenesten. Så trenger vi bare å påkalle søke om metode.

Den siste operasjonen er asynkron, og de endelige resultatene lagres i Framtid forekomst. Vi kunne vente på dette Framtid å lykkes eller mislykkes, men det vil være en blokkerende operasjon, og vi vil kanskje unngå det. I stedet kan vi implementere en tilbakeringing som skal utløses når Framtid lykkes:

Service clientService = ny LogFilter (). Og deretter (Http.newService (": 8080")); Request request = Request.apply (Method.Get (), "/? Name = John"); request.host ("lokal vert"); Fremtidig respons = clientService.apply (forespørsel); Await.result (respons .onSuccess (r -> {assertEquals ("Hello John", r.getContentString ()); returner BoxedUnit.UNIT;}) .onFailure (r -> {kast ny RuntimeException (r);})) ;

Merk at vi kommer tilbake BoxedUnit.UNIT. Går tilbake Enhet er Scalas måte å takle tomrom metoder, så vi gjør det her for å opprettholde interoperabilitet.

7. Oppsummering

I denne opplæringen lærte vi hvordan vi bygger en enkel HTTP-server og en klient ved hjelp av Finagle, samt hvordan vi kan etablere kommunikasjon mellom dem og utveksle meldinger.

Som alltid kan kildekoden med alle eksemplene bli funnet på GitHub.