streamalism.org

1. Hva er Micronaut

Micronaut er et JVM-basert rammeverk for å bygge lette, modulære applikasjoner. Utviklet av OCI, det samme selskapet som opprettet Grails, Micronaut er det siste rammeverket designet for å gjøre det raskt og enkelt å lage mikrotjenester.

Mens Micronaut inneholder noen funksjoner som ligner på eksisterende rammer som Spring, har den også noen nye funksjoner som skiller den fra hverandre. Og med støtte for Java, Groovy og Kotlin, tilbyr det en rekke måter å lage applikasjoner på.

2. Hovedtrekk

En av de mest spennende funksjonene i Micronaut er kompilering av tidsavhengighetsinjeksjonsmekanisme. De fleste rammeverk bruker refleksjon og fullmakter for å utføre avhengighetsinjeksjon ved kjøretid. Micronaut bygger imidlertid dataene for avhengighetsinjeksjon ved kompileringstidspunktet. Resultatet er raskere oppstart av applikasjoner og mindre minnefotavtrykk.

En annen funksjon er førsteklasses støtte for reaktiv programmering, både for klienter og servere. Valget av en spesifikk reaktiv implementering overlates til utvikleren ettersom både RxJava og Project Reactor støttes.

Micronaut har også flere funksjoner som gjør det til et utmerket rammeverk for utvikling av cloud-native applikasjoner. Den støtter flere verktøy for oppdagelse av tjenester som Eureka og Consul, og fungerer også med forskjellige distribuerte sporingssystemer som Zipkin og Jaeger.

Det gir også støtte for å lage AWS lambda-funksjoner, noe som gjør det enkelt å lage serverløse applikasjoner.

3. Komme i gang

Den enkleste måten å komme i gang er å bruke SDKMAN:

> sdk installere micronaut 1.0.0.RC2

Dette installerer alle de binære filene vi trenger for å bygge, teste og distribuere Micronaut-applikasjoner. Det gir også Micronaut CLI-verktøyet, som lar oss enkelt starte nye prosjekter.

De binære gjenstandene er også tilgjengelige på Sonatype og GitHub.

I de følgende avsnittene vil vi se på noen funksjoner i rammeverket.

4. Avhengighetsinjeksjon

Som nevnt tidligere håndterer Micronaut avhengighetsinjeksjon ved kompileringstid, noe som er annerledes enn de fleste IoC-containere.

Imidlertid er det fortsatt støtter fullt ut JSR-330-merknader så det å jobbe med bønner ligner på andre IoC-rammer.

For å autowire en bønne i koden vår, bruker vi @Injiser:

@Injiser privat EmployeeService-tjeneste;

De @Injiser kommentar fungerer akkurat som @Autowired og kan brukes på felt, metoder, konstruktører og parametere.

Som standard er alle bønner brukt som en prototype. Vi kan raskt lage singletonbønner ved hjelp av @Singleton. Hvis flere klasser implementerer samme bønnegrensesnitt, @Hoved kan brukes til å dekonflikte dem:

@Primary @Singleton offentlig klasse BlueCar implementerer bil {}

De @Krever merknader kan brukes når bønner er valgfrie, eller for kun å utføre automatisk ledning når visse betingelser er oppfylt.

I denne forbindelse oppfører den seg som Spring Boot @Betinget kommentarer:

@Singleton @Requires (beans = DataSource.class) @Requires (property = "enabled") @Requires (missingBeans = EmployeeService) @Requires (sdk = Sdk.JAVA, value = "1.8") offentlig klasse JdbcEmployeeService implementerer EmployeeService {}

5. Bygg en HTTP-server

La oss nå se på å lage en enkel HTTP-serverapplikasjon. For å starte, bruker vi SDKMAN til å lage et prosjekt:

> mn create-app hallo-world-server-build maven

Dette vil opprette et nytt Java-prosjekt ved hjelp av Maven i en katalog som heter hei-verdens-server. Inne i denne katalogen finner vi hovedkildekoden til applikasjonen, Maven POM-filen og andre støttefiler for prosjektet.

Standardprogrammet som er veldig enkelt:

public class ServerApplication {public static void main (String [] args) {Micronaut.run (ServerApplication.class); }}

5.1. Blokkerer HTTP

På egenhånd vil ikke dette programmet gjøre mye. La oss legge til en kontroller som har to sluttpunkter. Begge vil returnere en hilsen, men en vil bruke FÅ HTTP verb, og den andre vil bruke POST:

@Controller ("/ greet") offentlig klasse GreetController {@Inject private GreetingService greetingService; @Get ("/ {name}") offentlig strenghilsen (strengnavn) {return greetingService.getGreeting () + navn; } @Post (value = "/ {name}", forbruker = MediaType.TEXT_PLAIN) offentlig String setGreeting (@Body String name) {return greetingService.getGreeting () + name; }}

5.2. Reaktiv IO

Som standard vil Micronaut implementere disse endepunktene ved hjelp av tradisjonell blokkerende I / U. Derimot, vi kan raskt implementere ikke-blokkerende endepunkter ved å bare endre returtypen til hvilken som helst reaktiv ikke-blokkerende type.

For eksempel, med RxJava kan vi bruke Observerbar. På samme måte kan vi komme tilbake når vi bruker Reactor Mono eller Flux datatyper:

@Get ("/ {name}") offentlig monohilsen (strengnavn) {retur Mono.just (greetingService.getGreeting () + navn); }

For både blokkerende og ikke-blokkerende endepunkter er Netty den underliggende serveren som brukes til å håndtere HTTP-forespørsler.

Normalt håndteres forespørslene i hoved I / O-trådgruppen som opprettes ved oppstart, slik at de blokkeres.

Imidlertid, når en ikke-blokkerende datatype returneres fra et kontrollerendepunkt, bruker Micronaut Netty-hendelsessløyfetråden, noe som gjør at hele forespørselen ikke blokkeres.

6. Bygg en HTTP-klient

La oss nå bygge en klient for å konsumere sluttpunktene vi nettopp opprettet. Micronaut tilbyr to måter å opprette HTTP-klienter på:

• En erklærende HTTP-klient
• En programmatisk HTTP-klient

6.1 Deklarativ HTTP-klient

Den første og raskeste måten å lage er å bruke en deklarativ tilnærming:

@Client ("/ greet") offentlig grensesnitt GreetingClient {@Get ("/ {name}") String greet (String name); }

Legg merke til hvordan vi implementerer ingen kode for å ringe tjenesten vår. I stedet forstår Micronaut hvordan man ringer til tjenesten fra metodesignaturen og kommentarene vi har gitt.

For å teste denne klienten kan vi lage en JUnit-test som bruker APIen for innebygd server til å kjøre en innebygd forekomst av serveren vår:

offentlig klasse GreetingClientTest {private EmbeddedServer-server; privat GreetingClient-klient; @Før offentlig ugyldig oppsett () {server = ApplicationContext.run (EmbeddedServer.class); klient = server.getApplicationContext (). getBean (GreetingClient.class); } @Efter offentlig annullering () {server.stop (); } @Test offentlig ugyldig testGreeting () {assertEquals (client.greet ("Mike"), "Hello Mike"); }}

6.2. Programmatisk HTTP-klient

Vi har også muligheten til å skrive en mer tradisjonell klient hvis vi trenger mer kontroll over oppførselen og implementeringen:

@Singleton offentlig klasse ConcreteGreetingClient {private RxHttpClient httpClient; offentlig ConcreteGreetingClient (@Client ("/") RxHttpClient httpClient) {this.httpClient = httpClient; } offentlig strenghilsen (strengnavn) {HttpRequest req = HttpRequest.GET ("/ greet /" + name); returner httpClient.retrieve (req) .blockingFirst (); } offentlig Single greetAsync (strengnavn) {HttpRequest req = HttpRequest.GET ("/ async / greet /" + name); returner httpClient.retrieve (req) .first ("En feil som oppstod"); }}

Standard HTTP-klient bruker RxJava, så det kan enkelt fungere med blokkerende eller ikke-blokkerende samtaler.

7. Micronaut CLI

Vi har allerede sett Micronaut CLI-verktøyet i aksjon ovenfor da vi brukte det til å lage vårt eksempelprosjekt.

I vårt tilfelle opprettet vi et frittstående program, men det har også flere andre muligheter.

7.1. Federation Prosjekter

I Micronaut er en føderasjon bare en gruppe frittstående applikasjoner som lever under samme katalog. Ved å bruke føderasjoner kan vi enkelt administrere dem sammen og sikre at de får de samme standardinnstillingene og innstillingene.

Når vi bruker CLI-verktøyet for å generere en føderasjon, tar det alle de samme argumentene som opprett app kommando. Det vil skape en prosjektstruktur på toppnivå, og hver enkeltstående app blir opprettet i underkatalogen derfra.

7.2. Funksjoner

Når vi oppretter et frittstående program eller en føderasjon, kan vi bestemme hvilke funksjoner appen vår trenger. Dette bidrar til å sikre at minimalt sett med avhengigheter er inkludert i prosjektet.

Vi spesifiserer funksjoner ved hjelp av -funksjoner argument og levere en kommaseparert liste over funksjonsnavn.

Vi kan finne en liste over tilgjengelige funksjoner ved å kjøre følgende kommando:

> mn profilinfotjeneste Tilbyr funksjoner: -------------------- * annotation-api - Legger til Java-merking API * config-konsul - Legger til støtte for distribuert konfigurasjon med konsul * discovery-consul - Legger til støtte for Service Discovery med Consul * discovery-eureka - Legger til støtte for Service Discovery med Eureka * groovy - Oppretter en Groovy-applikasjon [...] Flere tilgjengelige funksjoner

7.3. Eksisterende prosjekter

Vi kan også bruke CLI-verktøyet til å modifisere eksisterende prosjekter. Gjør det mulig for oss å lage bønner, klienter, kontrollere og mer. Når vi kjører mn kommando fra et eksisterende prosjekt, har vi et nytt sett med kommandoer tilgjengelig:

> min hjelp | Kommandonavn Kommando Beskrivelse ---------------------------------------------- - create-bean Oppretter en singleton bean create-client Oppretter et klientgrensesnitt create-controller Oppretter en controller og tilhørende test create-job Oppretter en jobb med planlagt metode

8. Konklusjon

I denne korte introduksjonen til Micronaut har vi sett hvor enkelt det er å bygge både blokkerende og ikke-blokkerende HTTP-servere og klienter. Vi har også utforsket noen funksjoner i CLI.

Men dette er bare en liten smak av funksjonene den tilbyr. Det er også full støtte for serverløse funksjoner, oppdagelse av tjenester, distribuert sporing, overvåking og beregninger, en distribuert konfigurasjon og mye mer.

Og mens mange av funksjonene er hentet fra eksisterende rammer som Grails og Spring, har den også mange unike funksjoner som hjelper den å skille seg ut alene.

Som alltid kan vi finne eksemplene på koden ovenfor i GitHub-repoen.