Kuidas Quarkus ühendab MicroProfile'i ja Springi

Tere kõigile, ja see on kolmas postitus Quarkuse seeriast!

Java-mikroteenuste arendamisel arvatakse sageli, et Eclipse MicroProfile ja Spring Boot on eraldi ja omavahel sõltumatud API-d. Üldiselt kasutavad arendajad neid API-sid, millega nad juba harjunud on, kuna uute raamistike ja runtime-komponentide õppimine nõuab palju aega. Täna püüame lihtsustada mõnede populaarsete MicroProfile API-de omandamist Spring-arendajatele ja näitame, kuidas samal ajal kasutada Springi API-d ja uusi kasulikke võimalusi. Quarkus.

Natukene täpsemalt öeldes vaatame kõigepealt üle, kuidas Quarkus toetab Springi API-liideseid, et näidata Springi arendajatele, kuidas saavad MicroProfile API-sid oma igapäevases töös rakendada. Siis räägime MicroProfile API-dest, mis on kasulikud Springi arendajatele mikroteenuste loomisel.

Miks just Quarkus? Esiteks on see live coding, see tähendab, et MicroProfile API, Spring API ja teiste Java API muutuste automaatne uuesti laadimine toimub ühe käsuga: mvn quarkus:dev. Teiseks, antud näites on Person teenus (mis kompileeritakse Springi, MicroProfile ja JPA API-dest binaarfailiks kasutades GraalVM-i natiivset pilti) käivitatav vaid 0.055 sekundi jooksul ja vajab umbes 90 MB mälu (RSS) RESTful rakenduse lõpp-punktis. Samuti saab selle kompileerimise teha ühe käsuga: mvn package -Pnative.

Me ei hakka MicroProfile'i üksikasjadesse süvenema, vaid püüame aidata Springi arendajatel mõista, kuidas Quarkuses saab kasutada Springi API-sid koos MicroProfile API-dega.

Konteinerid ja Kubernetes

Kuna ei tahaks seda artiklit üle koormata, vaatleme siin ainult kõrgtaseme aspekte. KubernetesKuna see on oluline mõista. Quarkust positsioneeritakse Java-stäkina Kubernetesile, mille eesmärk on minimeerida mälukulu ja Java rakenduste ja teenuste käivitusaega, mis omakorda suurendab nende koha tihedust ja vähendab üldkulusid.

Quarkus toetab ka automaatselt genereeritud Kubernetes ressursse ja pakub juhiseid Kubernetes ja Red Hat OpenShift platvormidele juurutamiseks. Lisaks genereerib Quarkus automaatselt Dockerfile.jvm (JVM pakendamine) ja Dockerfile.native (natiivne binaarpakendamine) failid, mis on vajalikud konteinerite loomiseks.

Ja lõpuks, keskendudes Kubernetesile kui sihtkeskkonnale, ei kasuta Quarkus Java raamistikke olukordades, kus sarnane funktsionaalsus on rakendatud Kubernetes'i tasemel. Tabelis 1 on esitatud Kubernetes'i ja tavaliste Java raamistike, mida Spring arendajad kasutavad, funktsionaalne vastavuskaart.

Tabel 1. Java raamistike ja Kubernetes'i funktsionaalse vastavuse kaart.

Funktsionaalsus
Traditsiooniline Spring Boot
Kubernetes

Teenuse avastamine
Eureka
DNS

Seadistus
Spring Cloud Config
Config Maps / Secrets

Koormuse tasakaalustamine
Ribbon (kliendi poolel)
Teenuse, replikatsioonikontroller (serveri poolel)

Koodi kompileerimine ja käivitamine näitest

Selles artiklis viitame projektinäitele, kus kasutatakse koos Springi ja MicroProfile'i API-sid ning isegi seda sama Java klassi. Selle näite koodi saab kompileerida ja käivitada käsurealt, lisainfot vt README.md failist.

Spring Framework'i API-d

Sõltuvuse süstimine

Quarkus toetab mitmeid Context and Dependency Injection (CDI) API-sid ja Spring Dependency Injection (Spring DI) API-sid. Kui töötate MicroProfile'i, Java EE ja Jakarta EE, siis olete juba CDI-ga hästi tuttav. Teisest küljest saavad Springi arendajad kasutada Quarkus Extension for Spring DI API, et tagada ühilduvus Spring DI-ga. Toetatud Spring DI API-de kasutamise näited on esitatud tabelis 2.

Uues meie näidisprojekti kasutatakse nii CDI-d kui ka Spring Dependency Injection'i. Lisainfot ja näiteid selle kohta leiate Quarkus'i juhendist, mille nimetus on Spring DI Guide.

Tabel 2. Näited toetatud Spring DI API-de kasutamisest.

Toetatud Spring DI funktsioonid
Näited

Constructor Injection

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

Field Injection
Autowired
Väärtus

@Autowired
@RestClient
SalutationRestClient salutationRestClient;

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

Bean
@Configuration

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

Component

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

Teenused

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

   public String getPrefix() {
      return message;
   }
}

Veebiraamistik

MicroProfile'i kasutajatele meeldib, et Quarkus toetab JAX-RS-i, MicroProfile Rest Client-i, JSON-P-d ja JSON-B-d peamise veebiprogrammeerimise mudelina. Spring-i arendajatele tuleb rõõmuna Quarkuse uus tugi Spring Web API-le, eriti REST-iga seotud liideste osas. Nagu Spring DI puhul, on Spring Web API toe peamine eesmärk, et Spring-i arendajad saaksid kasutada Spring Web API-sid koos MicroProfile API-dega. Toetatud Spring Web API-de kasutamise näited on esitatud tabelis 3, samas kui lisainfot ja näiteid selle teema kohta leiate Quarkuse juhendist, mille pealkiri on Spring Web Guide.

Tabel 3. Toetatud Spring Web API-de kasutamise näited.

Toetatud Spring Web omadused
Näited

@RestController
@RequestMapping

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

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

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

Spring Data JPA

MicroProfile'i kasutajatele meeldib ka, et Quarkus toetab JPA-d, kasutades Hibernate ORM-i. Ka Spring-i arendajatele on häid uudiseid: Quarkus toetab üldtunnustatud Spring Data JPA annotatsioone ja tüüpe. Toetatud Spring Data JPA API-de kasutamise näited on toodud tabelis 4.
Uues meie näidisprojekti kasutatakse Spring Data JPA API-sid, samas kui lisainformation on saadaval Quarkuse juhendis pealkirjaga Spring Data JPA Guide.

Tabel 4. Toetatud Spring Data JPA API-de kasutamise näited.

Toetatud Spring Data JPA omadused
Näited

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 {
   ...
}

Derived query methods

public interface PersonRepository extends CrudRepository {

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

    Boolean existsBookByYearOfBirthBetween(
            Integer start, Integer end);
}

Kasutaja määratud päringud

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);
}

MicroProfile API-d

Rikketolerantsus (Fault tolerance)

Veakuskonstruktsioonid on kriitilise tähtsusega, et vältida kaskaadvõrke ja luua usaldusväärseid mikroteenuste arhitektuure. Spring-arendajad on juba aastaid kasutanud veakindlustamiseks circuit-breakereid. Hystrix. Kuid Hystrix ei ole pikka aega uuendatud, samas kui MicroProfile'i vigaaktseptsioon on aktiivselt arenenud ja sellel on juba mitu aastat tootmises kasutamist. Seetõttu soovitatakse Quarkuses teenuste usaldusväärsuse suurendamiseks kasutada MicroProfile Fault Tolerance API-sid, mille kasutusnäiteid on esitatud tabelis 5. Lisainfot selle kohta leiate Quarkus'i juhendist. Fault Tolerance Guide.

Tabel 5. Näited MicroProfile Fault Tolerance toetatavate API-de kasutamisest.

MicroProfile Fault Tolerance funktsioonid
Kirjeldus
Näited

@Asynchronous

Loogika täitmine eraldi niidis

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

@Bulkhead

Samaaegsete päringute arvu piiramine

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

@CircuitBreaker

Nutikas tõrgete töötlemine ja taastumine

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

@Fallback

Alternatiivse loogika kutsumine tõrke korral

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

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

Retry

Päringu ebaõnnestumisel edasine proovimine

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

Timeout

Ooteaja kontrollimine ebaõnnestumise korral

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

Teenuste kontrollimine (Service Health)

Kubernetes platvormid jälgivad konteinerite tõhusust spetsiaalsete teenuste abil. Et alampiirkond saaks teenuseid jälgida, kasutavad Spring-arendajad tavaliselt kohandatavaid HealthIndicator ja Spring Boot Actuator. Quarkuses saab seda teha MicroProfile Health abil, mis vaikimisi teostab töövõimekuse kontrollimist (liveness check), kuid saab seadistada ka samaaegseks liveness ja readiness (valmiduse) kontrollimiseks. Näited toetatud MicroProfile Health API kasutamisest on esitatud tabelis 6 ning lisainformatsioon on esitatud Quarkus'i juhendis. Health Guide.

Tabel 6. Näited MicroProfile Health toetatavate API-de kasutamisest.

MicroProfile Health funktsioonid
Kirjeldus
Näited

@Liveness

Platvorm taaskäivitab riknenud konteineriseeritud rakendused
Lõpp-punkt:
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

Platvorm ei suuna liiklust konteinerisse, kui see ei ole valmis
Lõpp-punkt:
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õõtmised

Rakendused pakuvad mõõdikuid kas operatiivsetel eesmärkidel (SLA-taseme jõudluse jälgimine) või mitteoperatiivsetel eesmärkidel (äri-SLA mõõdikud). Spring-arendajad pakuvad mõõdikuid Spring Boot Actuator'i ja Micrometeri kaudu. Quarkus kasutab omakorda MicroProfile Metrics'i, et anda esmaseid mõõdikuid (JVM ja opsüsteem), teenusepakkuja mõõdikud (Quarkus) ja rakenduse mõõdikud. MicroProfile Metrics nõuab, et rakendus toetaks väljundvorminguid JSON ja OpenMetrics (Prometheus). Näiteid MicroProfile Metrics API kasutamisest on esitatud tabelis 7.

Uues meie näidisprojekti MicroProfile Metrics kasutatakse rakenduse mõõdikute esitamiseks. Täiendavaid andmeid leiate Quarkuse juhendist Mõõdikute juhend.

Tabel 7. Näited MicroProfile Metrics API kasutamisest.

MicroProfile Metrics'i funktsioonid
Kirjeldus
Näited

@Counted

Määrab teadaande counter, mis loendab antud objekti kõnesid

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

@ConcurrentGauge

Määrab teadaande gauge, mis loendab antud objekti paralleelseid kõnesid

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

@Gauge

Määrab teadaande gauge, mis mõõdab antud objekti väärtust

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

@Metered

Määrab teadaande meter, mis jälgib antud objekti kõne sagedust

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

Mõõdik

Annotatsioon, mis sisaldab teavet metaandmete kohta, mil rakendatakse mõõdiku loomise või saatmise päring

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

Ajastatud

Määrab ajasturi, mis jälgib antud objekti kestust

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

Metrika lõpp-punktid (Metrics Endpoints)

Rakenduste metrikad localhost:8080/metrics/application
Põhimetriika localhost:8080/metrics/base
Teenusepakkuja metrikad localhost:8080/metrics/vendor
Kõik metrikad localhost:8080/metrics

MicroProfile REST klient

Mikroteenused pakuvad sageli RESTful lõpp-punkte, mille jaoks on vajalikud vastavad kliendiliidese API-d. RESTful lõpp-punktide kasutamiseks kasutavad Springi arendajad tavaliselt RestTemplate'i. Quarkus pakub selle ülesande lahendamiseks MicroProfile REST Client'i API-liideseid, mille kasutamise näited on toodud tabelis 8.

Uues meie näidisprojekti RESTful lõpp-punktide kasutamine toimub MicroProfile REST Client'i abil. Lisateavet ja näiteid selle teema kohta leiate Quarkus'i juhendist REST Klientide Juhend.

Tabel 8. Näited MicroProfile REST Client'i API-liideste kasutamisest.

MicroProfile REST Client'i funktsioonid
Kirjeldus
Näited

@RegisterRestClient

Registreerib tüübitud Java liidese REST kliendina

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

@RestClient

Märgistab tüübitud REST klientliidese eksemplari sisestamise

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

Kutsumine

Kutsuda REST lõpp-punkt

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

mp-rest/url

Määratleb REST lõpp-punkti

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

Summary

Selles blogis, mis on ennekõike kasulik Spring arendajatele, vaatame lühidalt, kuidas Quarkus kasutada Springi API-liideseid koos MicroProfile API-liideseid, et arendada Java mikroteenuseid ja seejärel kompileerida need kohandatud binaarkoodiks, mis säästab sadu megabaite mälu ja käivitub mõne millisekundi jooksul.

Nagu te juba aru saite, leidub täiendavat teavet Springi ja MicroProfile API-liidese toetuse kohta, samuti palju muud kasulikku teavet Quarkus'i juhendites.

Allikas: habr.com