Como o Quarkus integra o MicroProfile e o Spring

Olá pessoal, e com vocês o terceiro post da série Quarkus! (A propósito, registre-se e acesse o nosso webinar “ This is Quarkus - Kubernetes framework Java nativo ”, que será realizado em 27 de maio. Mostraremos como começar do zero ou transferir soluções prontas)



Ao desenvolver microsserviços Java, geralmente se acredita que o MicroProfile e Spring do Eclipse Inicialização são APIs separadas e independentes. Por padrão, os programadores geralmente usam as APIs às quais estão acostumados, pois o aprendizado de novas estruturas e componentes de tempo de execução leva muito tempo. Hoje, tentaremos simplificar o desenvolvimento de algumas APIs MicroProfile populares para desenvolvedores do Spring.e mostre como usar a API Spring e os novos recursos úteis do Quarkus ao mesmo tempo .

Se um pouco mais detalhado, examinaremos primeiro o escopo e os detalhes de como o Quarkus suporta APIs do Spring para mostrar aos desenvolvedores do Spring como usar a API MicroProfile em seu trabalho diário. Depois, falaremos sobre a API MicroProfile, que será útil para os desenvolvedores do Spring ao criar microsserviços.

Porquê Quarkus? Primeiramente, isso é codificação ao vivo, ou seja, recarregamento automático de quaisquer alterações na API MicroProfile, API Spring e outras APIs Java, que são executadas com apenas um comando: mvn quarkus: dev. Em segundo lugar, considerado em nosso exemploo serviço Person (compilado das APIs Spring, MicroProfile e JPA em um arquivo binário usando a imagem nativa do GraalVM) inicia em apenas 0,055 segundos e ocupa cerca de 90 MB de RAM (RSS) no terminal do aplicativo RESTful. Além disso, sua própria compilação é realizada com apenas um comando: mvn package -Pnative.

Não entraremos em detalhes do MicroProfile, mas apenas tentaremos ajudar os desenvolvedores do Spring a entender como, no Quarkus, você pode usar as APIs do Spring junto com as APIs do MicroProfile.

Containers e Kubernetes


Para não sobrecarregar este artigo, examinaremos apenas os aspectos de alto nível do suporte ao Kubernetes aqui , pois é importante entender isso. O Quarkus está posicionado como uma pilha Java para o Kubernetes, foi projetado para minimizar o consumo de memória e o tempo de inicialização dos aplicativos e serviços Java e, como resultado, aumentar a densidade de sua localização no host e reduzir os custos gerais.

O Quarkus também suporta a geração automática de recursos do Kubernetes e oferece guias de implantação nas plataformas Kubernetes e Red Hat OpenShift. Além disso, o Quarkus gera automaticamente os arquivos Dockerfile.jvm (pacote da JVM) e Dockerfile.native (pacote binário nativo) necessários para criar contêineres.

Finalmente, concentrando-se no Kubernetes como o ambiente de implantação de destino, o Quarkus não usa estruturas Java nos casos em que funcionalidades semelhantes são implementadas no nível da própria plataforma Kubernetes. A Tabela 1 mostra um mapa da correspondência funcional do Kubernetes e das estruturas Java típicas usadas pelos desenvolvedores do Spring.

Tabela 1. Mapa de mapeamento funcional para estruturas Java e Kubernetes.
FuncionalBota de primavera tradicionalKubernetes
Descoberta de serviçoEurekaDNS
ConfiguraçãoConfiguração da nuvem da primaveraConfigurar mapas / segredos
Balanceamento de cargaFaixa de opções (lado do cliente)Serviço, Controlador de Replicação (lado do servidor)

Compilando e Executando o Código do Exemplo


Neste artigo, nos referimos a um projeto de exemplo em que as APIs Spring e MicroProfile e até a mesma classe Java são compartilhadas. O código deste exemplo pode ser compilado e executado na linha de comando; consulte o arquivo README.md para obter mais detalhes.

APIs do Spring Framework


Injeção de dependência


O Quarkus suporta uma variedade de APIs de CDI (Contexts and Injection Dependency Injection) e APIs de Spring Dependency Injection (Spring DI). Se você trabalha com MicroProfile, Java EE e Jakarta EE , já está familiarizado com o CDI. Por outro lado, os desenvolvedores do Spring podem usar a API do Quarkus Extension for Spring DI para garantir a compatibilidade com o Spring DI. Exemplos de uso das APIs Spring DI suportadas são fornecidos na Tabela 2.

O projeto do nosso exemplo usa CDI e Spring Dependency Injection. Para obter mais informações e exemplos sobre este tópico, consulte o Guia Quarkus, chamado Spring DI Guide .

Tabela 2. Exemplos de uso das APIs Spring DI suportadas.
Recursos DI Spring suportados
Constructor Injection
public PersonSpringController(
   PersonSpringRepository personRepository,  // injected      
   PersonSpringMPService personService) {    // injected
      this.personRepository = personRepository;
      this.personService = personService;
}
Field Injection
Autowired
Value
@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;
   }
}
Service
@Service
public class MessageProducer {
   @Value("${greeting.message}")
   String message;

   public String getPrefix() {
      return message;
   }
}

-


Os usuários do MicroProfile apreciarão o Quarkus suportando JAX-RS, MicroProfile Rest Client, JSON-P e JSON-B como seu principal modelo de programação na web. Os desenvolvedores do Spring ficarão satisfeitos com o suporte recente da API da Web do Spring no Quarkus, em particular, as interfaces REST. Semelhante ao Spring DI, o principal objetivo do suporte à Spring Web API é que os desenvolvedores do Spring usem as Spring Web APIs junto com as APIs do MicroProfile. Exemplos de uso das APIs da Web Spring suportadas são fornecidas na Tabela 3, e mais informações e exemplos sobre esse tópico podem ser encontrados no Quarkus Guide, chamado Spring Web Guide .

Tabela 3. Exemplos de uso das Spring Web APIs suportadas.
Recursos da Web do Spring suportadosExemplos
@RestController
@RequestMapping
@RestController
@RequestMapping("/person")
public class PersonSpringController {
   ...
   ...
   ...
}
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping
@RequestParam
@RequestHeader
@MatrixVariable
@PathVariable
@CookieValue
@RequestBody
@ResponseStatus
@ExceptionHandler
@RestControllerAdvice (partial)
@GetMapping(path = "/greet/{id}",
   produces = "text/plain")
   public String greetPerson(
   @PathVariable(name = "id") long id) {
   ...
   ...
   ...
}

Spring Data JPA


Os usuários do MicroProfile também gostarão do Quarkus para dar suporte ao JPA usando o Hibernate ORM. Também há boas notícias para os desenvolvedores do Spring: o Quarkus suporta as anotações comuns e os tipos de JPA do Spring Data. Exemplos de uso das APIs JPA do Spring Data suportadas são fornecidos na tabela 4.
No projeto do nosso exemplo , as APIs JPA do Spring Data são usadas e informações adicionais estão disponíveis no guia do Quarkus chamado Guia JPA do Spring Data .

Tabela 4. Exemplos de uso das APIs JPA Spring Data suportadas.
Recursos JPA de dados de primavera suportadosExemplos
Crudrepository
public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}
Repositório
JpaRepository
PagingAndSortingRepository
public class PersonRepository extends 

    Repository {

    Person save(Person entity);

    Optional findById(Person entity);
}
Fragmentos de Repositório
public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}
Métodos de consulta derivados
public interface PersonRepository extends CrudRepository {

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

    Boolean existsBookByYearOfBirthBetween(
            Integer start, Integer end);
}
Consultas definidas pelo usuário
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- MicroProfile


(Fault tolerance)


Os projetos de tolerância a falhas são críticos para evitar falhas em cascata e criar arquiteturas robustas de microsserviços. Os desenvolvedores da Spring usam disjuntores Hystrix para tolerância a falhas há anos . No entanto, o Hystrix não é atualizado há muito tempo, mas a tolerância a falhas do MicroProfile agora está se desenvolvendo ativamente e já teve vários anos de uso na produção. Portanto, para aumentar a confiabilidade dos serviços no Quarkus, é recomendável usar as APIs de tolerância a falhas do MicroProfile, exemplos dos quais são fornecidos na Tabela 5. Para obter mais informações sobre isso, consulte o Guia de tolerância a falhas do Quarkus .

Tabela 5. Exemplos de uso das APIs de tolerância a falhas MicroProfile suportadas.
Recursos de tolerância a falhas do MicroProfileDescriçãoExemplos
@Asynchronous

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

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

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

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

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

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

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

(Service Health)


As plataformas Kubernetes monitoram a integridade do contêiner usando serviços especiais. Para que a plataforma subjacente possa monitorar os serviços, os desenvolvedores do Spring geralmente usam o HealthIndicator e o Spring Boot Actuator personalizados. No Quarkus, isso pode ser feito usando o MicroProfile Health, que por padrão executa uma verificação de animação, mas pode ser configurado para verificar simultaneamente a animação e a disponibilidade. Exemplos de uso das APIs de integridade do MicroProfile Health suportadas são mostradas na Tabela 6, e mais informações são fornecidas no Quarkus Health Guide .

Tabela 6. Exemplos de uso das APIs MicroProfile Health suportadas.
Recursos de integridade do MicroProfileDescriçãoExemplos
@Liveness

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

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


Os aplicativos fornecem métricas para fins operacionais (para controlar indicadores de desempenho do SLA) ou não operacionais (indicadores do SLA comercial). Os desenvolvedores do Spring fornecem métricas usando o Spring Boot Actuator e o micrômetro. Por sua vez, o Quarkus usa o MicroProfile Metrics para fornecer métricas básicas (JVM e sistema operacional), métricas do fornecedor (Quarkus) e métricas do aplicativo. O MicroProfile Metrics requer que a implementação suporte os formatos de saída JSON e OpenMetrics (Prometheus). Exemplos de uso da API do MicroProfile Metrics são fornecidos na Tabela 7.

No projeto do nosso exemplo, o MicroProfile Metrics é usado para fornecer métricas do aplicativo. Para mais informações, consulte o Quarkus Metrics Guide .

7. API- MicroProfile Metrics.
MicroProfile Metrics
@Counted
counter-,
@Counted(name = "fallbackCounter", 
  displayName = "Fallback Counter", 
  description = "Fallback Counter")
public String salutationFallback() {
   return fallbackSalutation;
}
@ConcurrentGauge
gauge-,
@ConcurrentGuage(
  name = "fallbackConcurrentGauge", 
  displayName="Fallback Concurrent", 
  description="Fallback Concurrent")
public String salutationFallback() {
   return fallbackSalutation;
}
@Gauge
gauge-,
@Metered(name = "FallbackGauge",
   displayName="Fallback Gauge",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}
@Metered
meter-,
@Metered(name = "MeteredFallback",
   displayName="Metered Fallback",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}
Metric
, ,
@Metric
@Metered(name = "MeteredFallback",
   displayName="Metered Fallback",
   description="Fallback frequency")
public String salutationFallback() {
   return fallbackSalutation;
}
Timed
,
@Timed(name = "TimedFallback",
   displayName="Timed Fallback",
   description="Fallback delay")
public String salutationFallback() {
   return fallbackSalutation;
}

Métricas Terminais

Métricas para aplicativos de host local : 8080 / metrics / application
Métricas básicas para localhost : 8080 / metrics / base
Métricas de fornecedor para localhost : 8080 / metrics / fornecedor
Todas as métricas para localhost : 8080 / metrics

MicroProfile Rest Client


Os microsserviços geralmente fornecem pontos de extremidade RESTful que exigem APIs de cliente apropriadas. Para usar pontos de extremidade RESTful, os desenvolvedores do Spring geralmente usam um RestTemplate. A Quarkus também oferece APIs do MicroProfile Rest Client para solucionar esse problema, exemplos de seu uso são fornecidos na Tabela 8.

No projeto do nosso exemplo, o uso de terminais RESTful é realizado usando o MicroProfile Rest Client. Para obter mais informações e exemplos sobre este tópico, consulte o Guia do Quarkus Rest Client .

Tabela 8. Exemplos de uso das APIs do MicroProfile Rest Client.
Recursos do MicroProfile Rest ClientDescriçãoExemplos
@RegisterRestClient
Registra uma interface Java digitada como um cliente REST
@RegisterRestClient
@Path("/")
public interface MyRestClient {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String getSalutation();
}
@RestClient
Marca a implementação de uma instância de uma interface do cliente REST digitada
@Autowired // or @Inject
@RestClient
MyRestClient restClient;
Invocação
Invoca um terminal REST
System.out.println(
   restClient.getSalutation());
mp-rest / url
Especifica um terminal REST
application.properties:
org.example.MyRestClient/mp-rest/url=
   http://localhost:8081/myendpoint

Sumário


Neste blog, que é útil principalmente para os desenvolvedores do Spring, vimos brevemente como usar as APIs do Spring no Quarkus juntamente com as APIs do MicroProfile para desenvolver microsserviços Java e compilá-los em código binário nativo, que economiza centenas de megabytes de RAM e começa em questão de milissegundos.

Como você já entendeu, informações adicionais sobre o suporte às APIs Spring e MicroProfile, bem como uma série de outras informações úteis, podem ser encontradas nos manuais do Quarkus .

All Articles