Hvordan Quarkus kombinerer MicroProfile og Spring

Hei alle sammen, og velkommen til det tredje innlegget i serien om Quarkus!

Når man utvikler Java-mikrotjenester, er det ofte en antakelse at Eclipse MicroProfile og Spring Boot er separate og uavhengige API-er. Som standard bruker programmerere gjerne de API-ene de allerede er kjent med, da det tar tid å lære seg nye rammeverk og runtime-komponenter. I dag skal vi prøve å forenkle læringen av noen populære MicroProfile API-er for Spring-utviklere og vise hvordan man kan bruke både Spring API og nye, nyttige funksjoner samtidig. Quarkus.

For å bli litt mer detaljert, vil vi først se på bruksområdene og detaljene rundt hvordan Quarkus støtter Spring API-er, for å vise Spring-utviklere hvordan de kan bruke MicroProfile API-er i sitt daglige arbeid. Deretter vil vi snakke om MicroProfile API-er som vil være nyttige for Spring-utviklere når de lager mikrotjenester.

Hvorfor Quarkus? For det første, det er live coding, som betyr at eventuelle endringer i MicroProfile API-er, Spring API og andre Java API-er automatisk lastes inn med bare én kommando: mvn quarkus:dev. For det andre, i vårt eksempel kjører tjenesten Person (som er kompilert fra Spring, MicroProfile og JPA API-er til en binær fil ved hjelp av en native GraalVM-image) på bare 0,055 sekunder og bruker omtrent 90 MB i minne (RSS) på RESTful-applikasjonens endepunkt. Og selve kompileringen gjøres med bare én kommando: mvn package -Pnative. Vi vil ikke gå i dybden om MicroProfile, men bare prøve å hjelpe Spring-utviklere til å forstå hvordan man kan bruke Spring API-er sammen med MicroProfile API-er i Quarkus.

Containere og Kubernetes

For ikke å overbelaste denne artikkelen, vil vi her se på høy-nivå aspekter av støtte

da dette er viktig å forstå. Quarkus posisjonerer seg som Java-stek for Kubernetes, og har som mål å minimere minnebruken og oppstartstiden for Java-applikasjoner og tjenester, hvilket igjen øker tettheten av deres distribusjon på verten og reduserer de totale kostnadene. KubernetesQuarkus støtter også

autogenerering av Kubernetes-ressurser og tilbyr veiledninger for distribusjon på Kubernetes- og Red Hat OpenShift-plattformer. Dessuten genererer Quarkus automatisk Dockerfile.jvm (JVM-pakking) og Dockerfile.native (native binær pakking) filer som er nødvendige for å lage containere. for distribusjon på Kubernetes-plattformer og Red Hat OpenShift. I tillegg genererer Quarkus automatisk Dockerfile.jvm (JVM-pakking) og Dockerfile.native (native binærpakking)-filer som er nødvendige for å lage containere.

Og til slutt, med Kubernetes som målplattform, bruker Quarkus ikke Java-rammeverk når en tilsvarende funksjonalitet er implementert på Kubernetes-plattformen selv. Tabell 1 viser en funksjonskartlegging mellom Kubernetes og typiske Java-rammeverk som brukes av Spring-utviklere.

Tabell 1. Funksjonskartlegging mellom Java-rammeverk og Kubernetes.

Funksjonalitet
Tradisjonell Spring Boot
Kubernetes

Service discovery
Eureka
DNS

Konfigurasjon
Spring Cloud Config
Config Maps / Secrets

Lastbalansering
Ribbon (på klientsiden)
Tjeneste, Replikasjonskontroller (på serversiden)

Kompilering og kjøring av koden fra eksempelet

I denne artikkelen refererer vi til prosjektprøven, der API-er fra Spring og MicroProfile brukes sammen, samt den samme Java-klassen. Koden fra dette eksempelet kan kompileres og kjøres fra kommandolinjen, se nærmere i filen README.md.

API-er fra Spring Framework

Dependency Injection

Quarkus støtter en rekke API-er for Contexts and Dependency Injection (CDI) og API-er for Spring Dependency Injection (Spring DI). Hvis du jobber med MicroProfile, Java EE og Jakarta EE, så er du allerede godt kjent med CDI. På den annen side kan Spring-utviklere bruke Quarkus Extension for Spring DI API for å sikre kompatibilitet med Spring DI. Eksempler på bruk av støttede Spring DI API-er er gitt i tabell 2.

I prosjektet fra vårt eksempel bruker både CDI og Spring Dependency Injection. Ytterligere informasjon og eksempler om dette kan finnes i Quarkus-håndboken, som kalles Spring DI Guide.

Tabell 2. Eksempler på bruk av støttede API-er for Spring DI.

Støttede funksjoner for Spring DI
Eksempler

Constructor Injection

public PersonSpringController(
   PersonSpringRepository personRepository,  // injected      
   PersonSpringMPService personService) {    // injected
      this.personRepository = personRepository;
      this.personService = personService;
}

Field Injection
Autowired
Verdi

@Autowired
@RestClient
SalutationRestClient salutationRestClient;

@Value("${fallbackSalutation}")
String fallbackSalutation;

Bean
@Configuration

@Configuration
public class AppConfiguration {
   @Bean(name = "capitalizeFunction")
   public StringFunction capitalizer() {
      return String::toUpperCase;
   }
}

Komponent

@Component("noopFunction")
public class NoOpSingleStringFunction implements StringFunction {
   @Override
   public String apply(String s) {
      return s;
   }
}

Service

@Service
public class MessageProducer {
   @Value("${greeting.message}")
   String message;

   public String getPrefix() {
      return message;
   }
}

Web-rammeverk

Brukere av MicroProfile vil sette pris på at Quarkus støtter JAX-RS, MicroProfile Rest Client, JSON-P og JSON-B som hovedmodell for webprogrammering. Spring-utviklere vil bli glade for den nylig introduserte støtten for Spring Web API i Quarkus, spesielt grensesnittene som ansvarer for REST. På samme måte som med Spring DI, er hovedmålet med støtten for Spring Web API å gjøre det mulig for Spring-utviklere å bruke Spring Web-grensesnitt sammen med MicroProfile API-grensesnitt. Eksempler på bruk av støttede Spring Web API er gitt i tabell 3, og mer informasjon og eksempler om dette kan finnes i Quarkus-guiden kalt Spring Web Guide.

Tabell 3. Eksempler på bruk av støttede Spring Web API-grensesnitt.

Støttede funksjoner for Spring Web
Eksempler

@RestController
@RequestMapping

@RestController
@RequestMapping("/person")
public class PersonSpringController {
   ...
   ...
   ...
}

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@RequestBody
@ResponseStatus
@ExceptionHandler
@RestControllerAdvice (delvis)

@GetMapping(path = "/greet/{id}",
   produces = "text/plain")
   public String greetPerson(
   @PathVariable(name = "id") long id) {
   ...
   ...
   ...
}

Spring Data JPA

Brukere av MicroProfile vil også sette pris på at Quarkus støtter JPA med Hibernate ORM. Det er også gode nyheter for Spring-utviklere: Quarkus støtter de kjente annotasjonene og typene for Spring Data JPA. Eksempler på bruk av støttede API-er for Spring Data JPA er gitt i tabell 4.
I prosjektet fra vårt eksempel brukes av API-er for Spring Data JPA, og mer informasjon er tilgjengelig i Quarkus-guiden kalt Spring Data JPA Guide.

Tabell 4. Eksempler på bruk av støttede API-grensesnitt for Spring Data JPA.

Støttede funksjoner for Spring Data JPA
Eksempler

CrudRepository

public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}

Repository
JpaRepository
PagingAndSortingRepository

public class PersonRepository extends 

    Repository {

    Person save(Person entity);

    Optional findById(Person entity);
}

Repository Fragments

public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}

Avledede spørringsmetoder

public interface PersonRepository extends CrudRepository {

    List findByName(String name);
    
    Person findByNameBySsn(String ssn);
    
    Optional 
       findByNameBySsnIgnoreCase(String ssn);

    Boolean existsBookByYearOfBirthBetween(
            Integer start, Integer end);
}

Brukerdefinerte spørringer

public interface MovieRepository
         extends CrudRepository {

    Movie findFirstByOrderByDurationDesc();

    @Query("select m from Movie m where m.rating = ?1")
    Iterator findByRating(String rating);

    @Query("from Movie where title = ?1")
    Movie findByTitle(String title);
}

API-er for MicroProfile

Feiltoleranse

Feil toleranse-konstruksjoner er essensielle for å forhindre kaskadefeil og skape pålitelige mikrotjenestearkitekturer. Spring-utviklere har i mange år brukt kretsbrytere for feil toleranse. Hystrix. Men Hystrix har ikke blitt oppdatert på lenge, mens MicroProfile sin Feil Toleranse nå er aktivt utviklet og har flere års produksjonsbruk bak seg. Derfor anbefales det å bruke MicroProfile Feil Toleranse API-er for å øke påliteligheten til tjenestene i Quarkus, med eksempler på bruk som finnes i tabell 5. Ytterligere informasjon om dette kan finnes i Quarkus-håndboken. Feil Toleranse Guide.

Tabell 5. Eksempler på bruk av støttede MicroProfile Feil Toleranse API-er.

Funksjoner i MicroProfile Feil Toleranse
Description
Eksempler

@Asynchronous

Utføre logikk i en separat tråd

@Asynchronous
@Retry
public Future getSalutation() {
   ...
   return future;
}

@Bulkhead

Begrense antall samtidige forespørseler

@Bulkhead(5)
public void fiveConcurrent() {
   makeRemoteCall(); //...
}

@CircuitBreaker

Intelligent feilbehandling og gjenoppretting etter feil

@CircuitBreaker(delay=500   // millisekunder
   failureRatio = .75,
   requestVolumeThreshold = 20,
   successThreshold = 5)
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

@Fallback

Kalle alternativ logikk ved feil

@Timeout(500) // millisekunder
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

public String fallback() {
   return "hello";
}

Retry

Gjenta ved forespørselfeil

@Retry(maxRetries=3)
public String getSalutation() {
   makeRemoteCall(); //...
}

Timeout

Kontrolltid ved feil

@Timeout(value = 500) // millisekunder
@Fallback(fallbackMethod = "fallback")
public String getSalutation() {
   makeRemoteCall(); //...
}

Sjekk av tjenester (Service Health)

Kubernetes-plattformer overvåker tilstanden til containere ved hjelp av spesielle tjenester. For at den underliggende plattformen skal kunne overvåke tjenester, bruker Spring-utviklere vanligvis tilpassede HealthIndicator og Spring Boot Actuator. I Quarkus kan dette gjøres med MicroProfile Health, som som standard utfører liveness check, men kan konfigureres til å sjekke både liveness og readiness samtidig. Eksempler på bruk av støttede MicroProfile Health API-er finnes i tabell 6, og ytterligere informasjon er tilgjengelig i Quarkus-håndboken. Helseguide.

Tabell 6. Eksempler på bruk av støttede MicroProfile Health API-er.

Funksjoner i MicroProfile Health
Description
Eksempler

@Liveness

Plattformen utfører omstart av defekte containeriserte applikasjoner
Endpoint:
host:8080/health/live

@Liveness
public class MyHC implements HealthCheck {
  public HealthCheckResponse call() {

   ...
   return HealthCheckResponse
     .named("myHCProbe")
     .status(ready ? true:false)
     .withData("mydata", data)
     .build();  
}

@Readiness

Plattformen vil ikke sende trafikk til den containeriserte applikasjonen hvis den ikke er klar
Endpoint:
host:8080/health/ready

@Readiness
public class MyHC implements HealthCheck {
  public HealthCheckResponse call() {

   ...
   return HealthCheckResponse
     .named("myHCProbe")
     .status(live ? true:false)
     .withData("mydata", data)
     .build();  
}

Metrikker

Applikasjoner leverer målinger enten for operasjonelle formål (for å overvåke SLA-yteindikatorer) eller for ikke-operasjonelle (forretnings-SLA). Spring-utviklere leverer målinger med Spring Boot Actuator og Micrometer. På sin side bruker Quarkus MicroProfile Metrics for å levere grunnleggende målinger (JVM og operativsystem), leverandørmålinger (Quarkus) og applikasjonsmålinger. MicroProfile Metrics krever at implementeringen støtter utdataformater som JSON og OpenMetrics (Prometheus). Eksempler på bruk av MicroProfile Metrics API er gitt i tabell 7.

I prosjektet fra vårt eksempel MicroProfile Metrics brukes til å levere applikasjonsmålinger. Ytterligere informasjon finnes i Quarkus-håndboken. Måleguide.

Tabell 7. Eksempler på bruk av MicroProfile Metrics API.

Funksjoner i MicroProfile Metrics
Description
Eksempler

@Counted

Indikerer en counter teller, som teller antall kall til det annoterte objektet.

@Counted(name = "fallbackCounter", 
  displayName = "Fallback Counter", 
  description = "Fallback Counter")
public String salutationFallback() {
   return fallbackSalutation;
}

@ConcurrentGauge

Indikerer en gauge sensor som teller antall parallelle kall til det annoterte objektet.

@ConcurrentGuage(
  name = "fallbackConcurrentGauge", 
  displayName="Fallback Concurrent", 
  description="Fallback Concurrent")
public String salutationFallback() {
   return fallbackSalutation;
}

@Gauge

Indikerer en gauge sensor som måler verdien av det annoterte objektet.

@Metered(name = "FallbackGauge",
   displayName="Fallback Gauge",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}

@Metered

Indikerer en meter sensor som overvåker frekvensen av kall til det annoterte objektet.

@Metered(name = "MeteredFallback",
   displayName="Metered Fallback",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}

Måling

Annotering som inneholder metadata-informasjon som mottas når en forespørsel om opprettelse eller produksjon av en måling sendes.

@Metric
@Metered(name = "MeteredFallback",
   displayName = "Metered Fallback",
   description = "Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}

Tidsmålt

Indikerer en timer som overvåker varigheten av det annoterte objektet.

@Timed(name = "TimedFallback",
   displayName="Timed Fallback",
   description="Fallback delay")
public String salutationFallback() {
   return fallbackSalutation;
}

Metrikkendepunkt (Metrics Endpoints)

Applikasjonsmetrikker localhost:8080/metrics/application
Grunnleggende metrikker localhost:8080/metrics/base
Leverandørmetrikker localhost:8080/metrics/vendor
Alle metrikker localhost:8080/metrics

Rest-klient MicroProfile

Mikrotjenester tilbyr ofte RESTful-endepunkter, som krever tilsvarende klient-API-er for å fungere. For å bruke RESTful-endepunkter, bruker Spring-utviklere vanligvis RestTemplate. Quarkus tilbyr imidlertid MicroProfile Rest Client API-er for dette formålet, med eksempler på bruk vist i tabell 8.

I prosjektet fra vårt eksempel Bruken av RESTful-endepunkter skjer ved hjelp av MicroProfile Rest Client. Mer informasjon og eksempler finner du i Quarkus-guiden. Rest Client Guide.

Tabell 8. Eksempler på bruk av MicroProfile Rest Client API-er.

Funksjoner i MicroProfile Rest Client
Description
Eksempler

@RegisterRestClient

Registrerer et typet Java-grensesnitt som en REST-klient

@RegisterRestClient
@Path("/")
public interface MyRestClient {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String getSalutation();
}

@RestClient

Markerer injeksjon av et instans av det typede REST-klientgrensesnittet

@Autowired // or @Inject
@RestClient
MyRestClient restClient;

Invokasjon

Kaller REST-endepunktet

System.out.println(
   restClient.getSalutation());

mp-rest/url

Angir REST-endepunktet

application.properties:
org.example.MyRestClient/mp-rest/url=
   http://localhost:8081/myendpoint

Resultater

I denne bloggen, som først og fremst er nyttig for Spring-utviklere, vil vi kort gå gjennom hvordan Quarkus bruker Spring API-er sammen med MicroProfile API-er for å utvikle Java-mikrotjenester og deretter kompilere dem til et innfødt binært format som sparer hundrevis av megabyte med RAM og starter på et øyeblikk.

Som du allerede har forstått, kan du finne mer informasjon om støtten til Spring og MicroProfile API-er, samt mye annen nyttig informasjon i Quarkus-guidene.

Kilde: habr.com