Jak Quarkus kombinuje MicroProfile a Spring

Ahoj všichni, tady je třetí příspěvek ze série Quarkus!

Jak Quarkus kombinuje MicroProfile a Spring

Při vývoji mikroslužeb Java se často věří, že Microprofile Eclipse и Jarní bota jsou samostatná a nezávislá API. Ve výchozím nastavení mají programátoři tendenci používat rozhraní API, na která jsou již zvyklí, protože učení nových frameworků a runtime komponent zabere spoustu času. Dnes se pokusíme zjednodušit vývoj některých populárních MicroProfile API pro vývojáře Spring a ukáže vám, jak současně používat Spring API a nové užitečné funkce kvarkus.

Trochu podrobněji se nejprve podíváme na rozsah a podrobnosti o tom, jak Quarkus podporuje Spring API, abychom vývojářům Spring ukázali, jak používat MicroProfile API při jejich každodenní práci. Poté se budeme zabývat rozhraními MicroProfile API, která jsou užitečná pro vývojáře Spring při vytváření mikroslužeb.

Proč Quarkus? Za prvé se jedná o živé kódování, tedy automatické opětovné načítání jakýchkoli změn v MicroProfile API, Spring API a dalších Java API, které se provádí pouze jedním příkazem: mvn quarkus:dev. Za druhé, projednáno v v našem příkladu služba Person (která se zkompiluje z API Spring, MicroProfile a JPA do binárního formátu pomocí nativního obrazu GraalVM) se spustí za pouhých 0.055 sekundy a zabere asi 90 MB RAM (RSS) na koncovém bodu aplikace RESTful. Jeho kompilace se navíc provádí pouze jedním příkazem: mvn package -Pnative.

Nebudeme zabíhat do podrobností o MicroProfile, kromě toho, abychom pomohli vývojářům Spring pochopit, jak mohou používat Spring API s MicroProfile API v Quarkusu.

Kontejnery a Kubernetes

Aby byl tento článek jednoduchý, budeme se zde zabývat pouze aspekty podpory na vysoké úrovni. Kubernetes, protože je důležité pochopit. Quarkus je umístěn jako Java stack pro Kubernetes, je navržen tak, aby minimalizoval spotřebu paměti a dobu spouštění Java aplikací a služeb, a v důsledku toho zvýšil jejich hustotu na hostiteli a snížil celkové náklady.

Quarkus také podporuje automatické generování Zdroje a nabídky Kubernetes průvodci pro nasazení na platformách Kubernetes a Red Hat OpenShift. Kromě toho Quarkus automaticky generuje soubory Dockerfile.jvm (balení JVM) a Dockerfile.native (nativní binární balení) potřebné k vytváření kontejnerů.

A konečně, Quarkus se zaměřením na Kubernetes jako cílové prostředí nasazení nepoužívá frameworky Java v případech, kdy je podobná funkčnost implementována na úrovni samotné platformy Kubernetes. Tabulka 1 poskytuje mapu funkční korespondence mezi Kubernetes a typickými frameworky Java, které používají vývojáři Spring.

Tabulka 1. Mapa funkční korespondence mezi frameworky Java a Kubernetes.

Funkčnost
Tradiční jarní bota
Kubernetes

Zjištění služby
Eureka
DNS

Konfigurace
Jarní konfigurace cloudu
Konfigurace map/tajemství

Vyrovnávání zatížení
Stuha (strana klienta)
Služba, řadič replikace (strana serveru)

Kompilace a spuštění kódu z příkladu

V tomto článku odkazujeme ukázkový projekt, kde se společně používají API Spring a MicroProfile a dokonce i stejná třída Java. Kód v tomto příkladu lze zkompilovat a spustit z příkazového řádku, podrobnosti naleznete v souboru README.md.

Spring Framework API

Vstřikování závislosti

Quarkus podporuje řadu Kontexty a rozhraní API pro vkládání závislostí (CDI). a rozhraní API Spring Dependency Injection (Spring DI). Pokud pracujete s MicroProfile, Java EE a Jakarta EE, pak už CDI dobře znáte. Na druhou stranu mohou vývojáři Spring použít Quarkus Extension for Spring DI API k dosažení kompatibility s Spring DI. Příklady použití podporovaných rozhraní Spring DI API jsou uvedeny v tabulce 2.

В projekt z našeho příkladu Používá CDI i Spring Dependency Injection. Další informace a příklady na toto téma naleznete v příručce Quarkus s názvem Pružinový DI průvodce.

Tabulka 2. Příklady použití podporovaných rozhraní Spring DI API.

Podporované funkce Spring DI
Příklady

Konstrukční vstřikování

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

Polní injekce
Automaticky zapojeno
Hodnota

@Autowired
@RestClient
SalutationRestClient salutationRestClient;

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

Fazole
@Konfigurace

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

Složka

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

Servis

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

   public String getPrefix() {
      return message;
   }
}

Webový rámec

Uživatelé MicroProfile budou milovat, že Quarkus podporuje JAX-RS, MicroProfile Rest Client, JSON-P a JSON-B jako primární webový programovací model. Vývojáři Spring budou potěšeni nedávnou podporou Quarkusu pro Spring Web API, zejména rozhraní REST. Podobně jako u Spring DI je hlavním cílem podpory Spring Web API umožnit vývojářům Spring používat Spring Web API ve spojení s MicroProfile API. Příklady použití podporovaných rozhraní Spring Web API jsou uvedeny v tabulce 3 a další informace a příklady na toto téma lze nalézt v kurzu Quarkus s názvem Jarní webový průvodce.

Tabulka 3. Příklady použití podporovaných rozhraní Spring Web API.

Podporované jarní webové funkce
Příklady

@RestController
@RequestMapping

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

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@RequestBody
@ResponseStatus
@ExceptionHandler
@RestControllerAdvice (částečné)

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

Jarní DataJPA

Uživatelé MicroProfile také ocení, že Quarkus podporuje JPA pomocí Hibernate ORM. Dobrá zpráva je také pro vývojáře Spring: Quarkus podporuje běžné anotace a typy Spring Data JPA. Příklady použití podporovaných rozhraní Spring Data JPA API jsou uvedeny v tabulce 4.
В projekt z našeho příkladu Používají se rozhraní API JPA Spring Data a další informace jsou k dispozici ve výukovém programu Quarkus s názvem Spring Data JPA Guide.

Tabulka 4. Příklady použití podporovaných rozhraní API Spring Data JPA.

Podporované funkce Spring Data JPA
Příklady

CrudRepository

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

sklad
JpaRepository
PagingAndSortingRepository

public class PersonRepository extends 

    Repository {

    Person save(Person entity);

    Optional findById(Person entity);
}

Fragmenty úložiště

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

Odvozené metody dotazů

public interface PersonRepository extends CrudRepository {

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

    Boolean existsBookByYearOfBirthBetween(
            Integer start, Integer end);
}

Uživatelsky definované dotazy

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

Odolnost proti chybám

Konstrukce odolnosti proti chybám jsou velmi důležité pro prevenci kaskádových selhání a vytváření spolehlivých architektur mikroslužeb. Vývojáři Spring používají jističe pro odolnost proti poruchám již mnoho let. hystrix. Hystrix však nebyl dlouho aktualizován, ale Fault Tolerance MicroProfile se nyní aktivně vyvíjí a má za sebou několik let produkčního používání. Pro zlepšení spolehlivosti služeb v Quarkusu se proto doporučuje používat rozhraní MicroProfile Fault Tolerance API, jejichž příklady jsou použity v tabulce 5. Další informace o tomto naleznete v příručce Quarkus Průvodce odolností proti chybám.

Tabulka 5. Příklady použití podporovaných rozhraní API MicroProfile Fault Tolerance.

Funkce MicroProfile Fault Tolerance
popis
Příklady

@Asynchronní

Provádění logiky v samostatném vláknu

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

@Přepážka

Omezte počet souběžných požadavků

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

@Jistič

Inteligentní řešení poruch a zotavení z poruch

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

@Ustoupit

Volání alternativní logiky v případě selhání

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

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

Opakovat

Zkuste to znovu při selhání požadavku

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

Timeout

Časový limit kontroly selhání

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

Kontrola služeb (stav služby)

Platformy Kubernetes monitorují stav kontejnerů pomocí speciálních služeb. Aby mohla základní platforma monitorovat služby, vývojáři Spring obvykle používají vlastní HealthIndicator a Spring Boot Actuator. V Quarkusu to lze provést pomocí MicroProfile Health, který ve výchozím nastavení provádí kontrolu živosti, ale lze jej nakonfigurovat tak, aby současně kontroloval živost a připravenost. Příklady použití podporovaných rozhraní MicroProfile Health API jsou uvedeny v tabulce 6 a další informace jsou uvedeny v příručce Quarkus. Průvodce zdravím.

Tabulka 6: Příklady použití podporovaných rozhraní API MicroProfile Health.

Funkce MicroProfile Health
popis
Příklady

@Životnost

Platforma restartuje neúspěšné kontejnerové aplikace
Koncový bod:
hostitel: 8080/zdraví/živě

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

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

@Připravenost

Platforma nebude odesílat provoz do kontejnerizovaných aplikací, pokud nebude připravena
Koncový bod:
hostitel: 8080/health/ready

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

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

Metriky

Aplikace poskytují metriky buď pro provozní účely (pro monitorování výkonových SLA) nebo pro neprovozní účely (obchodní SLA). Vývojáři Spring poskytují metriky pomocí Spring Boot Actuator a Micrometer. Quarkus zase používá MicroProfile Metrics k poskytování základních metrik (JVM a operační systém), dodavatelů (Quarkus) a aplikačních metrik. MicroProfile Metrics vyžaduje, aby implementace podporovala výstupní formáty JSON a OpenMetrics (Prometheus). Příklady použití MicroProfile Metrics API jsou uvedeny v tabulce 7.

В projekt z našeho příkladu MicroProfile Metrics se používají k poskytování metrik aplikací. Další informace naleznete v příručce Quarkus Průvodce metrikami.

Tabulka 7. Příklady použití MicroProfile Metrics API.

Funkce MicroProfile Metrics
popis
Příklady

@Počítáno

Označuje čítač čítače, který počítá, kolikrát byl zavolán anotovaný objekt

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

@ConcurrentGauge

Označuje měřidlo, které počítá počet souběžných volání anotovaného objektu

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

@Gauge

Označuje snímač měřidla, který měří hodnotu anotovaného objektu

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

@Měřeno

Označuje senzor měřiče, který monitoruje frekvenci volání anotovaného objektu

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

metrický

Anotace obsahující informace o metadatech, když je přijat požadavek na zadání nebo vytvoření metriky

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

Časované

Označuje časovač, který sleduje dobu trvání anotovaného objektu

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

Koncové body metrik

Metriky aplikace localhost:8080/metrika/aplikace
Základní metriky localhost:8080/metrika/základ
Metriky dodavatele localhost:8080/metrika/prodejce
Všechny metriky localhost:8080/metrika

Zbývající klient MicroProfile

Mikroslužby často poskytují koncové body RESTful, které pro práci vyžadují odpovídající klientská rozhraní API. K použití koncových bodů RESTful vývojáři Spring obvykle používají RestTemplate. Quarkus nabízí k vyřešení tohoto problému rozhraní MicroProfile Rest Client API, jejichž příklady použití jsou uvedeny v tabulce 8.

В projekt z našeho příkladu použití koncových bodů RESTful se provádí pomocí klienta MicroProfile Rest. Další informace a příklady na toto téma naleznete v příručce Quarkus Průvodce klienta Rest.

Tabulka 8. Příklady použití rozhraní MicroProfile Rest Client API.

Funkce klienta pro zbytek MicroProfile
popis
Příklady

@RegisterRestClient

Registruje zadané rozhraní Java jako klienta REST

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

@RestClient

Označuje implementaci instance zadaného klientského rozhraní REST

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

Vyvolání

Volá koncový bod REST

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

mp-rest/url

Určuje koncový bod REST

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

Výsledky

V tomto blogu, zaměřeném především na vývojáře Spring, jsme se rychle podívali na to, jak používat Spring API s MicroProfile API v Quarkusu k vývoji Java mikroslužeb a poté je zkompilovat do nativního binárního kódu, který ušetří stovky megabajtů RAM a spustí se v otázkou milisekund.

Jak jste již pochopili, více informací o podpoře rozhraní Spring a MicroProfile API, stejně jako mnoho dalších užitečných informací, naleznete v Quarkus manuály.

Zdroj: www.habr.com

Přidat komentář