Cómo Quarkus integra MicroProfile y Spring

¡Hola a todos, y con ustedes la tercera publicación de la serie Quarkus! (Por cierto, regístrese y vaya a nuestro seminario webEste es el marco Java nativo de Quarkus - Kubernetes ”, que se llevará a cabo el 27 de mayo. Le mostraremos cómo comenzar desde cero o transferir soluciones preparadas)



Al desarrollar microservicios Java, a menudo se cree que Eclipse MicroProfile y Spring El arranque son API separadas e independientes. De forma predeterminada, los programadores suelen usar las API a las que están acostumbrados, ya que aprender nuevos marcos y componentes de tiempo de ejecución lleva mucho tiempo. Hoy intentaremos simplificar el desarrollo de algunas API de MicroProfile populares para desarrolladores de Spring.y muestra cómo usar Spring API y las nuevas funciones útiles de Quarkus al mismo tiempo .

Si es un poco más detallado, primero veremos el alcance y los detalles de cómo Quarkus admite las API de Spring para mostrar a los desarrolladores de Spring cómo usar la API de MicroProfile en su trabajo diario. Luego hablaremos sobre la API MicroProfile, que será útil para los desarrolladores de Spring al crear microservicios.

¿Por qué Quarkus? En primer lugar, esta es la codificación en vivo, es decir, la recarga automática de cualquier cambio en la API MicroProfile, Spring API y otras API Java, que se realiza con un solo comando: mvn quarkus: dev. En segundo lugar, considerado en nuestro ejemploEl servicio Person (se compila desde las API Spring, MicroProfile y JPA en un archivo binario usando la imagen nativa de GraalVM) comienza en solo 0.055 segundos y toma aproximadamente 90 MB de RAM (RSS) en el punto final de la aplicación RESTful. Además, su compilación se realiza con un solo comando: mvn package -Pnative.

No entraremos en detalles de MicroProfile, sino que solo trataremos de ayudar a los desarrolladores de Spring a comprender cómo en Quarkus puede usar las API de Spring junto con las API de MicroProfile.

Contenedores y Kubernetes


Para no sobrecargar este artículo, solo veremos los aspectos de alto nivel del soporte de Kubernetes aquí , ya que es importante entenderlo. Quarkus se posiciona como una pila Java para Kubernetes, está diseñada para minimizar el consumo de memoria y el tiempo de inicio de las aplicaciones y servicios Java y, como resultado, aumentar la densidad de su ubicación en el host y reducir los costos generales.

Quarkus también admite la generación automática de recursos de Kubernetes y ofrece guías de implementación en las plataformas Kubernetes y Red Hat OpenShift. Además, Quarkus genera automáticamente los archivos Dockerfile.jvm (empaquetado JVM) y Dockerfile.native (empaquetado binario nativo) necesarios para crear contenedores.

Finalmente, al centrarse en Kubernetes como el entorno de implementación de destino, Quarkus no usa marcos de Java en casos en los que se implementa una funcionalidad similar a nivel de la plataforma Kubernetes. La Tabla 1 muestra un mapa de la correspondencia funcional de Kubernetes y los marcos Java típicos utilizados por los desarrolladores de Spring.

Tabla 1. Mapa de mapeo funcional para frameworks Java y Kubernetes.
FuncionalBota de primavera tradicionalKubernetes
Descubrimiento de servicioEurekaDNS
ConfiguraciónSpring Cloud configMapas de configuración / secretos
Balanceo de cargaCinta (lado del cliente)Servicio, controlador de replicación (lado del servidor)

Compilar y ejecutar el código del ejemplo


En este artículo, nos referimos a un proyecto de ejemplo donde se comparten las API Spring y MicroProfile e incluso la misma clase Java. El código de este ejemplo puede compilarse y ejecutarse desde la línea de comandos; consulte el archivo README.md para obtener más detalles.

Spring Framework APIs


Inyección de dependencia


Quarkus admite una variedad de API de Contextos e Inyección de Dependencia (CDI) y API de Inyección de Dependencia de Primavera (Spring DI). Si trabaja con MicroProfile, Java EE y Jakarta EE , entonces ya está familiarizado con CDI. Por otro lado, los desarrolladores de Spring pueden usar la Extensión Quarkus para Spring DI API para garantizar la compatibilidad con Spring DI. En la Tabla 2 se dan ejemplos del uso de las API Spring DI admitidas.

El proyecto de nuestro ejemplo utiliza la inyección de dependencia de CDI y Spring. Para obtener más información y ejemplos sobre este tema, consulte la Guía de Quarkus, llamada Spring DI Guide .

Tabla 2. Ejemplos de uso de las API Spring DI compatibles.
Funciones de Spring DI compatibles
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;
   }
}

-


Los usuarios de MicroProfile disfrutarán de Quarkus que admite JAX-RS, MicroProfile Rest Client, JSON-P y JSON-B como su principal modelo de programación web. Los desarrolladores de Spring estarán encantados con el reciente soporte de Spring Web API en Quarkus, en particular, las interfaces REST. Al igual que Spring DI, el objetivo principal de admitir la API web de Spring es que los desarrolladores de Spring utilicen las API web de Spring junto con las API de MicroProfile. En la Tabla 3 se dan ejemplos de uso de las API web de Spring compatibles, y se puede encontrar más información y ejemplos sobre este tema en la Guía Quarkus, llamada la Guía Web de Spring .

Tabla 3. Ejemplos de uso de las API web de Spring compatibles.
Funciones web de Spring compatiblesEjemplos
@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


Los usuarios de MicroProfile también desearán que Quarkus admita JPA utilizando Hibernate ORM. También hay buenas noticias para los desarrolladores de Spring: Quarkus admite las anotaciones comunes y los tipos JPA de Spring Data.
En la tabla 4 se dan ejemplos del uso de las API de Spring Data JPA. En el proyecto de nuestro ejemplo , se utilizan las API de Spring Data JPA , y hay información adicional disponible en la guía Quarkus llamada Spring Data JPA Guide .

Tabla 4. Ejemplos de uso de las API de Spring Data JPA compatibles.
Funciones de Spring Data JPA compatiblesEjemplos
Crudrepository
public interface PersonRepository
         extends JpaRepository,
                 PersonFragment {
   ...
}
Repositorio
JpaRepository
PagingAndSortingRepository
public class PersonRepository extends 

    Repository {

    Person save(Person entity);

    Optional findById(Person entity);
}
Fragmentos de repositorio
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 por el usuario
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)


Los diseños de tolerancia a fallas son críticos para prevenir fallas en cascada y construir arquitecturas robustas de microservicios. Los desarrolladores de Spring han estado utilizando disyuntores Hystrix para tolerancia a fallas durante años . Sin embargo, Hystrix no se ha actualizado durante mucho tiempo, pero la tolerancia a fallas de MicroProfile ahora se está desarrollando activamente y ya ha tenido varios años de uso en producción. Por lo tanto, para aumentar la confiabilidad de los servicios en Quarkus, se recomienda utilizar las API de MicroProfile Fault Tolerance, cuyos ejemplos se dan en la Tabla 5. Para obtener más información al respecto, consulte la Guía de Quarkus Fault Tolerance .

Tabla 5. Ejemplos de uso de las API compatibles de MicroProfile Fault Tolerance.
Características de tolerancia a fallas de microperfilDescripciónEjemplos
@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)


Las plataformas de Kubernetes supervisan el estado de los contenedores mediante servicios especiales. Para que la plataforma subyacente pueda monitorear los servicios, los desarrolladores de Spring generalmente usan el HealthIndicator personalizado y Spring Boot Actuator. En Quarkus, esto se puede hacer utilizando MicroProfile Health, que de forma predeterminada realiza una verificación de vida, pero se puede configurar para verificar simultáneamente la vida y la preparación. En la Tabla 6 se muestran ejemplos de uso de las API de salud de MicroProfile compatibles, y se proporciona más información en la Guía de salud de Quarkus .

Tabla 6. Ejemplos de uso de las API de mantenimiento de MicroProfile compatibles.
Características de salud de microperfilDescripciónEjemplos
@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();  
}


Las aplicaciones proporcionan métricas ya sea para fines operativos (para controlar los indicadores de rendimiento de SLA) o no operativos (indicadores de SLA de negocios). Los desarrolladores de Spring proporcionan métricas utilizando el actuador y el micrómetro Spring Boot. A su vez, Quarkus utiliza las métricas de MicroProfile para proporcionar métricas básicas (JVM y sistema operativo), métricas de proveedores (Quarkus) y métricas de aplicaciones. MicroProfile Metrics requiere que la implementación admita formatos de salida JSON y OpenMetrics (Prometheus).

En la Tabla 7 se dan ejemplos de uso de la API de métricas de MicroProfile. En el proyecto de nuestro ejemplo, las Métricas de MicroProfile se utilizan para proporcionar métricas de aplicaciones. Para obtener más información, consulte la Guía de métricas de Quarkus .

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 Puntos

finales Métricas para aplicaciones localhost : 8080 / metrics / application Métricas
básicas para localhost : 8080 / metrics / base Métricas del
proveedor para localhost : 8080 / metrics / vendor
Todas las métricas para localhost : 8080 / metrics

MicroProfile Rest Client


Los microservicios a menudo proporcionan puntos finales RESTful que requieren API de cliente apropiadas. Para usar puntos finales RESTful, los desarrolladores de Spring suelen usar un RestTemplate. Quarkus también ofrece las API de MicroProfile Rest Client para resolver este problema, en la Tabla 8 se dan ejemplos de su uso.

En el proyecto de nuestro ejemplo, el uso de puntos finales RESTful se realiza utilizando MicroProfile Rest Client. Para obtener más información y ejemplos sobre este tema, consulte la Guía del cliente de Quarkus Rest .

Tabla 8. Ejemplos de uso de las API de MicroProfile Rest Client.
Características del cliente MicroProfile RestDescripciónEjemplos
@RegisterRestClient
Registra una interfaz Java escrita como cliente REST
@RegisterRestClient
@Path("/")
public interface MyRestClient {
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String getSalutation();
}
@RestClient
Marca la implementación de una instancia de una interfaz de cliente REST escrita
@Autowired // or @Inject
@RestClient
MyRestClient restClient;
Invocación
Invoca un punto final REST
System.out.println(
   restClient.getSalutation());
mp-rest / url
Especifica un punto final REST
application.properties:
org.example.MyRestClient/mp-rest/url=
   http://localhost:8081/myendpoint

Resumen


En este blog, que es principalmente útil para los desarrolladores de Spring, analizamos brevemente cómo usar las API de Spring en Quarkus junto con las API de MicroProfile para desarrollar microservicios Java y luego compilarlos en código binario nativo, lo que ahorra cientos de megabytes de RAM y comienza en cuestión de milisegundos.

Como ya entendió, puede encontrar información adicional sobre el soporte para las API Spring y MicroProfile, así como una gran cantidad de otra información útil, en los manuales de Quarkus .

All Articles