Hur Quarkus förenar MicroProfile och Spring

Hej alla, och här är det tredje inlägget i serien om Quarkus!

När man utvecklar Java-mikrotjänster anses det ofta att Eclipse MicroProfile och Spring Boot är separata och oberoende API:er. Som standard tenderar programmerare att använda de API:er de redan är bekanta med, eftersom det tar tid att lära sig nya ramverk och runtime-komponenter. Idag ska vi försöka förenkla inlärningen av några populära MicroProfile API för Spring-utvecklare och vi kommer att visa hur man kan använda Spring API och nya användbara funktioner samtidigt. Quarkus.

Om vi går in lite mer detaljerat, så först ska vi titta på användningsområdena och detaljerna kring hur Quarkus stöder Spring API:er, för att visa Spring-utvecklare hur de kan använda MicroProfile API i sitt dagliga arbete. Därefter kommer vi att gå igenom MicroProfile API som kommer att vara till nytta för Spring-utvecklare vid skapandet av mikrotjänster.

Varför just Quarkus? För det första möjliggör det live coding, vilket innebär automatisk omstart av alla ändringar i MicroProfile API, Spring API och andra Java API, och det görs med endast ett kommando: mvn quarkus:dev. För det andra, det vi diskuterar i vårt exempel Person-tjänsten (som kompileras från API:erna Spring, MicroProfile och JPA till en binär fil med hjälp av GraalVM:s inbyggda bild) startar på bara 0,055 sekunder och upptar cirka 90 MB i RAM (RSS) på den RESTful-applikations slutpunkten. Självklart så görs själva kompileringen med bara ett kommando: mvn package -Pnative.

Vi ska inte gå in på detaljer kring MicroProfile, utan bara försöka hjälpa Spring-utvecklare att förstå hur API:er från Spring kan användas tillsammans med MicroProfile API i Quarkus.

Containrar och Kubernetes

För att inte överbelasta den här artikeln kommer vi här bara att gå igenom hög-nivå aspekter av stödet Kubernetes, eftersom det är viktigt att förstå. Quarkus marknadsförs som en Java-stack för Kubernetes, som syftar till att minimera minnesanvändning och starttider för Java-applikationer och tjänster, och därmed öka deras kapacitet i en värd och minska de totala kostnaderna.

Quarkus stöder också autogenerering av Kubernetes-resurser och erbjuder manualen för distribution på Kubernetes-plattformar och Red Hat OpenShift. Dessutom genererar Quarkus automatiskt Dockerfile.jvm (JVM-packaging) och Dockerfile.native (native binary packaging) filer som krävs för att skapa containrar.

Och slutligen, med Kubernetes som målmiljö för distribution, använder Quarkus inte Java-ramverk när motsvarande funktionalitet implementeras på Kubernetes-plattformens nivå. Tabell 1 visar en karta över funktionalitetens överensstämmelse mellan Kubernetes och typiska Java-ramverk som används av Spring-utvecklare.

Tabell 1. Karta över funktionalitetens överensstämmelse mellan Java-ramverk och Kubernetes.

Funktionalitet
Traditionell Spring Boot
Kubernetes

Tjänstupptäckning
Eureka
DNS

Konfiguration
Spring Cloud Config
Config Maps / Secrets

Lastbalansering
Ribbon (på klientsidan)
Tjänst, Replication Controller (på serversidan)

Kompilera och kör koden från exemplet

I denna artikel hänvisar vi till exempelprojektet, där API:erna från både Spring och MicroProfile används tillsammans, samt den specifika Java-klassen. Koden från det här exemplet kan kompileras och köras från kommandoraden; se README.md-filen för mer information.

API:er från Spring Framework

Beroendeinjektion

Quarkus stöder en mängd olika API:er för Contexts and Dependency Injection (CDI) och API:er för Spring Dependency Injection (Spring DI). Om du arbetar med MicroProfile, Java EE och Jakarta EE, är du redan väl bekant med CDI. Å andra sidan kan Spring-utvecklare använda Quarkus Extension for Spring DI API för att säkerställa kompatibilitet med Spring DI. Exempel på användning av de stödda Spring DI API:erna ges i Tabell 2.

I projektet från vårt exempel använder både CDI och Spring Dependency Injection. Mer information och exempel om detta finns i Quarkus-guiden som kallas Spring DI Guide.

Tabell 2. Exempel på användning av stödda API:er för Spring DI.

Stödda funktioner för Spring DI
Exempel

Konstruktörsinjektion

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

Fältinjektion
Autowired
Värde

@Autowired
@RestClient
SalutationRestClient salutationRestClient;

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

Bön
@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;
   }
}

Tjänst

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

   public String getPrefix() {
      return message;
   }
}

Webb-ramverk

MicroProfile-användare kommer att uppskatta att Quarkus stödjer JAX-RS, MicroProfile Rest Client, JSON-P och JSON-B som sin primära modell för webbprogrammering. Spring-utvecklare kommer att bli glada över det nyligen tillagda stödet för Spring Web API i Quarkus, särskilt för de gränssnitt som ansvarar för REST. På samma sätt som med Spring DI är huvudmålet med stödet för Spring Web API att Spring-utvecklare ska kunna använda Spring Web API:er tillsammans med MicroProfile API:er. Exempel på hur de stödda Spring Web API:erna används ges i tabell 3, och mer information och exempel om detta finns i Quarkus-guiden som heter Spring Web Guide.

Tabell 3. Exempel på hur de stödda Spring Web API:erna används.

Stödda funktioner för Spring Web
Exempel

@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

MicroProfile-användare kommer också att uppskatta att Quarkus stödjer JPA genom Hibernate ORM. För Spring-utvecklare finns det också goda nyheter: Quarkus stödjer de vanliga annoteringarna och typerna i Spring Data JPA. Exempel på hur de stödda Spring Data JPA API:erna används ges i tabell 4.
I projektet från vårt exempel används API:er från Spring Data JPA, och mer information finns i Quarkus-guiden som heter Spring Data JPA Guide.

Tabell 4. Exempel på hur de stödda Spring Data JPA API:erna används.

Stödda funktioner för Spring Data JPA
Exempel

CrudRepository

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

Repository
JpaRepository
PagingAndSortingRepository

public class PersonRepository extends 

    Repository {

    Person save(Person entity);

    Optional findById(Person entity);
}

Repository Fragment

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

Härledda frågemetoder

public interface PersonRepository extends CrudRepository {

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

    Boolean existsBookByYearOfBirthBetween(
            Integer start, Integer end);
}

Användardefinierade frågor

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 från MicroProfile

Felsäkerhet (Fault tolerance)

Funktionalitet för felhantering är mycket viktig för att förhindra kaskadfel och skapa pålitliga mikrotjänstarkitekturer. Spring-utvecklare har under många år använt kretsbrytare för felhantering. Hystrix. Men Hystrix har inte uppdaterats på länge, medan MicroProfile:s felhantering nu aktivt utvecklas och har flera års produktionserfarenhet bakom sig. Därför rekommenderas användning av MicroProfile Fault Tolerance API:er i Quarkus för att öka tjänsternas tillförlitlighet, med exempel som ges i tabell 5. Ytterligare information finns i Quarkus-handboken. Felhanteringsguide.

Tabell 5. Exempel på användning av stödda MicroProfile Fault Tolerance API:er.

Funktioner för MicroProfile Fault Tolerance
Beskrivning
Exempel

@Asynkron

Utför logik i en separat tråd

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

@Bulkhead

Begränsning av antalet samtidiga förfrågningar

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

@CircuitBreaker

Intelligent felhantering och återhämtning efter fel

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

@Fallback

Anropa alternativ logik vid fel

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

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

Retry

Upprepa vid fel i förfrågan

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

Timeout

Kontrolltid för väntan vid fel

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

Tjänsteövervakning (Service Health)

Kubernetes-plattformar övervakar hälsan hos containrar med speciella tjänster. För att den underliggande plattformen ska kunna övervaka tjänster använder Spring-utvecklare vanligtvis anpassade HealthIndicator och Spring Boot Actuator. I Quarkus kan detta göras med MicroProfile Health, som som standard utför hälsokontroller (liveness check) men också kan ställas in för att samtidigt kontrollera liveness och readiness (beredskap). Exempel på användning av stödda MicroProfile Health API:er ges i tabell 6, och ytterligare information finns i Quarkus-handboken. Hälsoguide.

Tabell 6. Exempel på användning av stödda MicroProfile Health API:er.

Funktioner för MicroProfile Health
Beskrivning
Exempel

@Liveness

Plattformen utför omstart av trasiga containrar av applikationer
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 kommer inte att skicka trafik till containeriserade applikationer om de inte är redo
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();  
}

Mätvärden

Applikationer tillhandahåller metrik antingen för operativa syften (för att övervaka SLA-prestanda) eller för icke-operativa (affärs-SLA-mått). Spring-utvecklare tillhandahåller metrik via Spring Boot Actuator och Micrometer. Å sin sida använder Quarkus MicroProfile Metrics för att tillhandahålla grundläggande metrik (JVM och operativsystem), leverantörsmetrik (Quarkus) och applikationsmetrik. MicroProfile Metrics kräver att implementeringen stödjer utdataformaten JSON och OpenMetrics (Prometheus). Exempel på användning av MicroProfile Metrics API finns i tabell 7.

I projektet från vårt exempel MicroProfile Metrics används för att tillhandahålla applikationsmetrik. Mer information finns i Quarkus-handledningen Metrikguide.

Tabell 7. Exempel på användning av MicroProfile Metrics API.

Funktioner för MicroProfile Metrics
Beskrivning
Exempel

@Counted

Anger en counter som räknar antalet anrop på den annoterade objektet

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

@ConcurrentGauge

Anger en gauge som räknar antalet samtidiga anrop på den annoterade objektet

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

@Gauge

Anger en gauge som mäter värdet på den annoterade objektet

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

@Metered

Anger en meter som spårar frekvensen av anropet till den annoterade objektet

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

Metrik

Annotation som innehåller metadata-information när en begäran om att skapa eller producera en metrik görs

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

Tidsinställd

Anger en timer som spårar varaktigheten av den annoterade objektet

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

Metrikslutpunkter (Metrics Endpoints)

Applikationsmetrier localhost:8080/metrics/application
Grundläggande metrier localhost:8080/metrics/base
Leverantörsmetrier localhost:8080/metrics/vendor
Alla metrier localhost:8080/metrics

Restklient för MicroProfile

Mikrotjänster erbjuder ofta RESTful slutanrop som kräver motsvarande klient-API:er. För att använda RESTful slutanrop tillämpar Spring-utvecklare vanligtvis RestTemplate. Quarkus erbjuder istället MicroProfile Rest Client API:er, vars exempel finns i tabell 8.

I projektet från vårt exempel användningen av RESTful slutanrop görs med MicroProfile Rest Client. Mer information och exempel hittar du i Quarkus-handboken Rest Client Guide.

Tabell 8. Exempel på användning av MicroProfile Rest Client API:er.

Funktioner i MicroProfile Rest Client
Beskrivning
Exempel

@RegisterRestClient

Registrerar ett typat Java-gränssnitt som en REST-klient

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

@RestClient

Markerar en instans av det typade REST-klientgränssnittet för injektion

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

Anrop

Anropar REST-slutpunkten

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

mp-rest/url

Anger REST-slutpunkten

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

Sammanfattning

I den här bloggen, som främst är till nytta för Spring-utvecklare, har vi kortfattat gått igenom hur Quarkus använder API:erna från Spring tillsammans med MicroProfiles API:er för att utveckla Java-mikrotjänster och sedan kompilera dem till nativa binärkod som sparar hundratals megabyte RAM och startar på några millisekunder.

Som du redan har förstått, finns det mer information om stödet för Spring- och MicroProfile-API:er samt mycket annan nyttig information i Quarkus-handböcker.

Källa: habr.com