Utvikling av Tjenester I Java, inkludert REST Api-Er, var ikke alltid lett eller produktiv Før Våren kom og endret landskapet. Mange år har gått siden da, og nye rammer har dukket opp i samfunnet.

En Av disse rammene var Micronaut. DET er utviklet AV OCI, samme selskap bak Grails, og deres mål er å hjelpe utviklere å lage mikrotjenester og serverløse applikasjoner.

Det Er Også Quarkus, et annet rammeverk som ble populært i løpet av det siste året. Utviklet Av RedHat, Lover Quarkus å levere rask oppstart og mindre minnebruk, to vanlige problemer når man utvikler REST-tjenester i Java.

med alle disse valgene er det et svært viktig spørsmål å stille: hvor enkelt er det å lage en tjeneste med hvert av disse tre rammene?

i denne opplæringen oppretter DU et sikkert HVILEPROGRAM ved Hjelp Av Spring, Micronaut og Quarkus for å se hvordan de skiller seg fra hverandre, og hvilken som passer best til dine behov.

Innholdsfortegnelse

spring boot

Hvis du vil, kan Du se Denne Opplæringen Som En Screencast. 👇

Forutsetninger for Din Java REST API

denne opplæringen bruker Maven 3+. Kontroller at den er installert og tilgjengelig for bruk før du fortsetter. Du kan sikkert ogsa bruke Gradle, men YMMV.Du skal bygge apper som godkjenner forespørsler ved Hjelp Av OAuth 2.0, sikret av Et Okta-program. Har Du Ikke En Okta-konto? Ikke bekymre deg, det tar mindre enn et minutt å lage en ny. Ikke bare det, Men Okta støtter standarder SOM JWT, OAuth 2.0 og OIDC. Vi gir støtte til kjente rammer som Java EE, Spring Boot og Spring Security. Heck, vi har til Og Med En maven plugin som automatiserer alt for deg.

det er ikke nødvendig å gjenoppfinne hjulet!

Opprett En Okta-Konto for Brukeradministrasjon

Åpne terminalen din, og utfør følgende kommando:

mvn com.okta:okta-maven-plugin:register

Du vil bli bedt om å legge inn følgende informasjon:

• Fornavn
• Etternavn
• E-Post
• Firma

når du har svart på spørsmålene, vil du motta en e-post for å aktivere din splitter nye konto. Etter å ha aktivert kontoen din, kjør følgende kommando:

mvn com.okta:okta-maven-plugin:spring-boot

denne kommandoen oppretter et program for deg med auth-kodestrøm og Spring Security ‘ s redirect URI for Okta.

for å huske det bedre, kan du opprette samme app manuelt:

• Gå til Oktas utviklerside og logg inn på kontoen din.
• Klikk På Programmer > Legg Til Søknad >Web> Neste.

du vil se følgende skjermbilde:

Før du fortsetter, gjør følgende endringer i programmet:

• Login redirect urier:
  • http://localhost:8080/login/oauth2/code/okta

  https://oidcdebugger.com/debug

Den implisitte tilskuddstypen (MED ID og Tilgang) token tillatt sjekket) er nødvendig for å hente et tilgangstoken i nettleseren din.

feltene som ikke er nevnt ovenfor, kan beholde standardverdiene.

når du er ferdig, klikker Du På Ferdig. Din app er klar!

det neste trinnet er å lære å generere et gyldig token ved hjelp av det.

Generer Tokens Ved Hjelp Av OpenID Connect Debugger

Okta lar deg administrere brukerne i skyen ved Hjelp Av Apiene. Den lar deg også til å sikre dine applikasjoner ved Hjelp Av OAuth 2.0 Og OpenID Connect (aka, OIDC). OAuth 2.0 gir en mekanisme for delegert autorisasjon som betyr at du ikke trenger å lagre brukerlegitimasjon i søknaden din. I stedet kan du delegere det til En oauth 2.0-leverandør (Okta, i dette tilfellet). OIDC gir et identitetslag på Toppen Av OAuth 2.0, og det er derfor selskaper som Okta kalles «identitetsleverandører» eller Idp.

du har registrert appen Din Med Okta og kan nå generere et token for å få tilgang til Det. En av login redirect-Uriene du registrerte er For OpenID Connect-nettstedet.

dine forespørsler vil bli validert ved hjelp av et token. For å generere dette token, vil Du bruke Openid Connect Debugger. Dette nettstedet vil gi deg en enkel måte å generere legitimasjon for brukerne På Okta søknad.

gå til https://oidcdebugger.com og fyll ut følgende informasjon:

• Autoriser URI: https://{yourOktaDomain}/oauth2/default/v1/authorize
• Omdirigere URI: https://oidcdebugger.com/debug
• Klient-ID: {yourOktaClientId}
• Omfang: openid email profile
• Tilstand: dev
• Nonce: (behold standardverdien)
• responstype: token

du kan finne verdien for {yourOktaDomain} i øvre høyre hjørne av kontos hjemmeside:



følg trinnene nedenfor for å finne din okta klient-id:

• Gå Til Programmer
• Velg Min Web App
• Klikk Generelt

Klient-Id vil være tilgjengelig i Klientlegitimasjon-delen:



når du har fullført alle feltene, klikker Du Send Forespørsel. Du blir omdirigert til Okta-påloggingssiden din.

når du har godkjent, blir du omdirigert til Oidc Debugger igjen, der du kan se det genererte token:



Du bruker dette token for å få sikker tilgang til tjenestene du skal bygge.

Nå som Du har En Okta-konto, og du vet hvordan du genererer tokens ved Hjelp Av Okta-programmet, la oss begynne å sammenligne rammene!

Bygg En Java REST API med Micronaut

det første skrittet for å utvikle Micronaut-tjenesten er å laste NED SDKMAN!. SDKMAN! er et verktøy for å håndtere parallelle versjoner av Flere Sdk-Er, som du vil bruke til å installere Micronaut-klienten.

DU kan laste NED SDKMAN! ved å kjøre følgende kommando:

curl -s https://get.sdkman.io | bash

nå kan Du installere Micronaut selv. Bare kjør følgende kommando i terminalen:

sdk install micronaut

etter at kommandoen er ferdig, har du den nyeste Micronaut-versjonen tilgjengelig på datamaskinen.

Du er klar til å begynne å utvikle programmet!

Utvikle Java-Tjenesten

Gå Til katalogen du vil opprette programmet ditt i og utfør følgende kommando:

mn create-app com.okta.rest.app --build maven

denne kommandoen vil opprette et prosjekt med Den grunnleggende strukturen I Et Micronaut-prosjekt. Micronaut bruker Gradle som standard, men siden du bruker --build maven, vil Den bruke Maven i stedet.

det neste trinnet er å legge til sikkerhetsbibliotekene i prosjektet. Redigerpom.xml filen og legg til følgende avhengigheter:

<dependency> <groupId>io.micronaut</groupId> <artifactId>micronaut-security</artifactId></dependency><dependency> <groupId>io.micronaut</groupId> <artifactId>micronaut-security-jwt</artifactId></dependency>

disse avhengighetene vil aktivere sikkerhet – spesielt OAuth 2.0 med JWT-i prosjektet. Nå som du har alle avhengighetene på plass, kan du begynne å lage sluttpunktet ditt.

Opprett følgende klasse isrc/main/java/com/okta/rest/controller:

package com.okta.rest.controller;import io.micronaut.http.MediaType;import io.micronaut.http.annotation.Controller;import io.micronaut.http.annotation.Get;import io.micronaut.http.annotation.Produces;import io.micronaut.security.annotation.Secured;import io.micronaut.security.rules.SecurityRule;import java.security.Principal;@Controller("/hello")public class HelloController { @Get @Secured(SecurityRule.IS_AUTHENTICATED) @Produces(MediaType.TEXT_PLAIN) public String hello(Principal principal) { return "Hello, " + principal.getName() + "!"; }}

@Controllerannotasjonen indikerer Til Micronaut at denne komponenten vil motta forespørsler i /hellobane.

klassen har bare en metode, kalt hello()@Get annotasjonen viser at metoden vil motta HTTP GET-forespørsler. Du trenger @Produces Fordi Micronauts standard returtype er ET json-objekt. Siden du returnerer enkel tekst, må du eksplisitt definere denne informasjonen i metoden.

den siste merknaden er @Secured. Det forteller Bare Micronaut at denne metoden bare er tilgjengelig for godkjente brukere.

du har nå en kontroller som er sikret, men du har ikke definert sikkerhetskonfigurasjonen ennå. La Oss konfigurere Micronaut for å koble Til Okta-applikasjonen din.

Endre navn påsrc/main/resources/application.yml tilapplication.properties og legg til følgende sikkerhetskonfigurasjon:

micronaut.security.enabled=truemicronaut.security.token.jwt.enabled=truemicronaut.security.token.jwt.signatures.jwks.okta.url=https://{yourOktaDomain}/oauth2/default/v1/keys

Erstatt {yourOktaDomain} med verdien Fra okta-kontoen din.

konfigurasjonen ovenfor muliggjør sikkerhet ved Hjelp Av OAuth 2.0. Du erklærer at din oauth 2.0-klient kommer Fra Okta, ved å spesifisere utstederen fra Okta-organisasjonen.

du aktiverer også bruk AV JSON web tokens, Eller JWTs. Siden Du vil lese informasjonen Fra Okta, må du deklarere hvor DU kan finne JWKS (JSON Web Key Set) for å validere JWT-signaturer.

Det er på tide å teste tjenesten din! Start programmet ved å kjøre følgende kommando:

./mvnw mn:run

kommandoen ovenfor vil gi et resultat som ligner på dette:

HTTP/1.1 401 UnauthorizedDate: Tue, 8 Jan 2019 15:47:36 GMTtransfer-encoding: chunkedconnection: close

som du kan se, gikk forespørselen Ikke gjennom. For å få det til å fungere, må du passere I oauth 2.0 access token hentet av Oidc Debugger. Tilordne tilgangstokenet til enTOKEN variabel i skallet ditt.

TOKEN=eyJraWQiOiJxOE1QMjFNNHZCVmxOSkxGbFFWNlN...

Utfør kommandoen nedenfor:

curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/hello

nå fungerer Det som forventet! Denne gangen mottar du hilsen som et svar:

Hello, [email protected]!

Du kan se At Micronaut krever svært lite kode for å opprette en sikker REST API. Hvis du teller kodelinjene, vil du finne at ~24% er avhengigheter I XML (8 linjer), Java-koden er bare 22 linjer med kode, og sikkerhetskonfigurasjonen tar 3 linjer. Micronauts innebygde oauth 2.0-støtte gjør det enkelt å integrere Med Okta, og de har til Og med En Veiledning For Okta i dokumentasjonen.

Flott! La oss nå se hvordan du lager den samme appen ved Hjelp Av Quarkus.

Bygg En Java REST API Med Quarkus

for å utvikle programmet ditt Ved Hjelp Av Quarkus trenger Du Bare maven installert, det er ingen andre avhengigheter som kreves.

La Oss begynne å lage din app! Gå til katalogen du vil opprette den i og utfør følgende kommando:

mvn io.quarkus:quarkus-maven-plugin:1.8.1.Final:create \ -DprojectGroupId=com.okta.rest \ -DprojectArtifactId=quarkus \ -DclassName="com.okta.rest.quarkus.HelloResource" \ -Dpath="/hello" \ -Dextensions="jwt"

kommandoen ovenfor oppretter et prosjekt ved Hjelp Av quarkus Maven-plugin. Det vil skape en ressurs som heter HelloResource, som skal motta forespørsler på/hello banen. Du legger også TIL jwt-utvidelsen Fra Quarkus på prosjektet.

når du har opprettet prosjektet, rediger src/java/com/okta/rest/quarkus/HelloResource.java og legg til brukerinformasjon ihello() – metoden:

package com.okta.rest.quarkus;import io.quarkus.security.Authenticated;import javax.ws.rs.GET;import javax.ws.rs.Path;import javax.ws.rs.Produces;import javax.ws.rs.core.Context;import javax.ws.rs.core.MediaType;import javax.ws.rs.core.SecurityContext;import java.security.Principal;@Path("/hello")public class HelloResource { @GET @Path("/") @Authenticated @Produces(MediaType.TEXT_PLAIN) public String hello(@Context SecurityContext context) { Principal userPrincipal = context.getUserPrincipal(); return "Hello, " + userPrincipal.getName() + "!"; }}

klassen ovenfor vil oppføre seg på samme måte som den du opprettet I Micronaut. Den leser brukerens informasjon basert på token som ble generert i forespørselen, og returnerer en hilsen til brukeren som er funnet.

Du har fortsatt ikke konfigurert Quarkus med utsteder og nøkler Fra Okta, så la oss gjøre det.

Rediger src/main/resources/application.properties og legg til følgende kode:

mp.jwt.verify.publickey.location=https://{yourOktaDomain}/oauth2/default/v1/keysmp.jwt.verify.issuer=https://{yourOktaDomain}/oauth2/default

Ferdig! Quarkus-versjonen av søknaden din er klar til å bli testet. Gå til prosjektmappen din og utfør følgende kommando:

./mvnw compile quarkus:dev

kommandoen ovenfor vil starte søknaden din.

Det første trinnet er å sørge for at du mottar en 401 - Unauthorized når du ikke bruker riktig legitimasjon.

Utfør følgende kommando i terminalen:

curl -X GET -I http://localhost:8080/hello

som forventet er resultatet ET HTTP 401-svar:

HTTP/1.1 401 Unauthorizedwww-authenticate: Bearer {token}Content-Length: 0

hvis du utfører denne samme forespørselen, inkludert token FRA Oidc Debugger, bør den returnere hilsen.

Utfør følgende kommando:

curl -H "Authorization: Bearer $TOKEN" http://localhost:8080/hello

det fungerte som en sjarm! I mitt tilfelle var resultatet:

Hello, [email protected]!

Quarkus krever enda færre linjer med kode enn Micronaut! Det genererer en app med avhengigheter inkludert, har 25 linjer Med Java-kode, og bare 2 linjer med konfigurasjon. Ja, kodelinjer er en dum sammenligning, men det viser også hvordan disse rammene krever svært lite kode for å utvikle sikre apper.

To ned, en å gå! Nå som du kunne implementere appen På Micronaut Og Quarkus, la oss avslutte ved å lage den samme appen ved Hjelp Av Spring Boot.

Bygg En Java REST API Med Spring Boot

Spring Boot har ingen forutsetninger for å begynne å lage appen din, så la oss begynne med å lage prosjektet!

Åpne terminalen din og utfør følgende kommando:

curl https://start.spring.io/starter.zip -d language=java \ -d bootVersion=2.3.4.RELEASE \ -d dependencies=web,okta \ -d packageName=com.okta.rest \ -d name=spring-boot \ -d type=maven-project \ -o spring-boot.zip

Kommandoen ovenfor vil opprette enspring-boot.zip fil Med En Spring Boot program som bruker Maven. Du kan pakke ut filen til enspring-boot katalog ved hjelp av kommandoen nedenfor.

unzip spring-boot.zip -d spring-boot

nå implementerer du kontrolleren som vil motta forespørslene.

Opprett encom.okta.rest.controller pakke og en HelloController klasse i den:

package com.okta.rest.controller;import org.springframework.security.core.annotation.AuthenticationPrincipal;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;import java.security.Principal;@RestControllerpublic class HelloController { @GetMapping("/hello") public String hello(@AuthenticationPrincipal Principal principal) { return "Hello, " + principal.getName() + "!"; }}

konfigurasjonen her er veldig lik de andre rammene. Du annoterer klassen med @RestController for å la Spring vite At Du vil motta forespørsler på klassen. @GetMapping vil motta HTTP GET-forespørsler på/hello banen. For å hente den godkjente brukeren bruker du@AuthenticationPrincipal annotasjonen.

Forskjellig fra de andre rammeverkene, trenger Du ikke å angi at dette endepunktet er godkjent siden Våren allerede kontrollerer denne informasjonen fra konfigurasjonene.

det siste trinnet er å legge til utstederinformasjonen, slik At Spring Securitys oidc-støtte automatisk kan oppdage endepunktene den trenger å kommunisere med.

Rediger src/main/resources/applications.properties og legg til følgende konfigurasjon:

okta.oauth2.issuer=https://{yourOktaDomain}/oauth2/default

la oss teste det! Start Våren Boot app ved Hjelp Av Maven.

./mvnw spring-boot:run

deretter åpner du en terminal og utfører kommandoen nedenfor:

curl -X GET -I http://localhost:8080/hello

svaret er EN HTTP 401-feil, siden du ikke inkluderte token:

HTTP/1.1 401Set-Cookie: JSESSIONID=316DCFD55C302A8D69EFD865411DFA77; Path=/; HttpOnlyWWW-Authenticate: BearerX-Content-Type-Options: nosniffX-XSS-Protection: 1; mode=blockCache-Control: no-cache, no-store, max-age=0, must-revalidatePragma: no-cacheExpires: 0X-Frame-Options: DENYContent-Length: 0Date: Thu, 09 Jan 2020 15:46:34 GMT

det fungerte! Som med de andre tjenestene, er resultatet av denne kommandoen følgende:

Hello, [email protected]!

Spring Boot klokker i minst mulig kode som kreves: 17 Linjer Med Java og bare 1 linje med konfigurasjon! Våren har alltid vært utmerket til å gjøre utviklernes liv enklere, så dette kommer ikke som noen overraskelse.

Det er det! Du implementerte en grunnleggende Java REST API i alle tre rammene!

Siste Tanker OM REST Apier Med Java: Micronaut, Quarkus og Spring Boot

når det gjelder å utvikle REST API, gjorde alle tre rammene jobben bra. Med bare litt kode og litt konfigurasjon, var du i stand til å utvikle et sikkert program ved Hjelp Av Okta og OAuth 2.0.Våren har eksistert i mange år, Den er allment populær, og har mange funksjoner rundt sitt økosystem. Personlig tror jeg fortsatt det er det beste alternativet tilgjengelig når du programmerer I Java.Micronaut og Quarkus vokser i popularitet og får fart i Java-samfunnet. Hvis du står overfor ytelsesproblemer, eller kanskje hvis du er vondt for en endring, kan du prøve en av dem og se hvordan det går.

Ytelse Er det mest fremhevede sammenligningspunktet mellom disse tre rammene. Hvis du leter etter rask oppstart i et serverløst miljø, eller evnen til å lage innfødte bilder Med GraalVM, Vil Micronaut og Quarkus trolig fungere bra for deg. Bare for moro skyld er oppstartstidene for hver av disse appene som følger (basert på gjennomsnittet fra tre forsøk): Micronaut: 474ms

• Quarkus: 1132ms
• Spring Boot: 1014ms

Jeg fikk disse tallene fra å kjøre hvert rammes Maven-mål for utvikling.

• Mikronaut:./mvnw mn:run
• Quarkus:./mvnw compile quarkus:dev
• Fjær Oppstart: ./mvnw spring-boot:run

disse kommandoene er ikke optimalisert for hastighet, så jeg pakket hvert program med./mvnw package og startet dem medjava -jar.

• Micronaut: 596ms
• Quarkus: 658ms
• Spring Boot: 1878ms

MERK: disse tallene ble beregnet på En 2019 MacBook Pro med En 2,4 GHz 8-Kjerne Intel Core I9 CPU og 64 GB RAM. OpenJDK 15 ble brukt utenJAVA_OPTS innstilling.

hvis du leter etter enda raskere oppstartstider, kan Du bruke GraalVM. I stedet for å kjøre timingstester selv, så jeg på hvert prosjekts dokumentasjon.

• Micronaut: 12ms I henhold Til Å Lage din første Micronaut Graal-applikasjon.Quarkus: 14ms I Henhold Til Quarkus Og GraalVM: Oppstart Dvalemodus Ved Supersonisk Hastighet, Subatomær Størrelse På InfoQ. Quarkus docs viser ikke oppstartstid.
• Spring Boot: 44ms i Henhold Til Våren Graal Innfødte 0.6.0 utgitt.

Til slutt vil du kunne produktivt utvikle et sikkert program, uavhengig av valget du gjør.

Vil du ta en titt på kildekoden? Du finner Den på GitHub på okta-java-rest-api-sammenligning-eksempel.

vil du lære Mer Om Java, REST Api-Er og sikre programmer? Her er noen andre innlegg fra bloggen vår som du kan finne nyttig:

• Watch GraalVM Slå Java Til Binærfiler
• Oauth 2.0 Java Guide: Sikre Din App i 5 Minutter
• Java Microservices Med Spring Boot Og Spring Cloud
• Hvordan Utvikle En Quarkus App Med Java Og Oidc Autentisering
• Enkel Godkjenning Med Spring Security

For flere innlegg som dette, følg @oktadev på twitter. Vi publiserer også jevnlig screencasts til Vår YouTube-kanal!23. September 2020: Oppgradert Til Micronaut 2.0.2, Quarkus 1.8.1 og Spring Boot 2.3.4. Se kodeendringene i eksempelappen på GitHub. Endringer i dette innlegget kan ses i oktadeveloper / okta-blog#423. 21. Mai 2020: Lagt til oppstartstider for java -jar og kjører Med GraalVM. Endringer i denne artikkelen kan ses i oktadeveloper / okta-blog#304. 20. Mai 2020: Oppgradert Til Micronaut 1.3.5, Quarkus 1.4.2 og Spring Boot 2.3.0. Se kodeendringene i eksempelappen på GitHub. Endringer i denne artikkelen kan ses i oktadeveloper / okta-blog#301. 30. Januar 2020: Oppdatert for å optimalisere Micronaut basert på tilbakemeldinger fra Micronaut-teamet. Også re-beregnet oppstartstider basert på et gjennomsnitt på tre forsøk. Se kodeendringene i eksempelappen på GitHub. Endringer i denne artikkelen kan ses i oktadeveloper / okta-blog#176.