Quarkus: Java subatómico a velocidad supersónica. Resumen del marco de trabajo

Introducción

El siete de marzo, la empresa RedHat (pronto IBM) ha presentado nuevo marco de trabajo — Quarkus. Según los desarrolladores, este marco de trabajo se basa en GraalVM y OpenJDK HotSpot y está diseñado para Kubernetes. El stack de Quarkus incluye: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus y otros.

El objetivo de su creación es hacer de Java la plataforma líder para implementación en Kubernetes y desarrollo de aplicaciones sin servidor, proporcionando a los desarrolladores un enfoque unificado para el desarrollo tanto en estilo reactivo como imperativo.

Si observamos la esto clasificación de frameworks, Quarkus se encuentra en algún lugar entre "Aggregators/Code Generators" y "High-level fullstack frameworks". Ya es más que un agregador, pero aún no llega a ser un full-stack, ya que está enfocado en el desarrollo backend.

Se promete una velocidad de arranque de aplicación muy alta y un bajo consumo de memoria. Aquí están los datos del sitio del desarrollador:

Tiempo desde el inicio hasta la primera respuesta (s):

Configuración
REST
REST+JPA

Quarkus+GraalVM
0.014
0.055

Quarkus+OpenJDK
0.75
2.5

Traditional Cloud Native Stack*
4.3
9.5

Consumo de memoria (Mb):

Configuración
REST
REST+JPA

Quarkus+GraalVM
13
35

Quarkus+OpenJDK
74
130

Traditional Cloud Native Stack*
140
218

Impresionante, ¿no?

*No encontré información sobre este stack de tecnologías, se puede suponer que es algún Spring Boot con aditamentos adicionales..

¡Hola Mundo!

La aplicación más simple escrita en Quarkus se verá así:

@Path("/hello")
public class GreetingResource {

   @GET
   @Produces(MediaType.TEXT_PLAIN)
   public String hello() {
       return "hello";
   }
}

¡Es literalmente una sola clase y es suficiente! Se puede ejecutar la aplicación utilizando Maven en modo de desarrollo:

mvn compile quarkus:dev
…
$ curl http://localhost:8080/hello
hello

La diferencia con una aplicación habitual es que ¡no hay una clase Application! Quarkus soporta la recarga en caliente, así que se puede modificar la aplicación sin reiniciarla, lo que hace que el desarrollo sea aún más rápido.

¿Qué sigue? Se puede agregar un servicio al controlador utilizando la anotación Inject. Código del servicio:

@ApplicationScoped
public class GreetingService {

   public String greeting(String name) {
       return "Hello " + name + "!";
   }
}

Controlador:

@Path("/hello")
public class GreetingResource {

   @Inject
   GreetingService service;

   @GET
   @Produces(MediaType.TEXT_PLAIN)
   @Path("/{name}")
   public String greeting(@PathParam("name") String name) {
       return service.greeting(name);
   }
}

$ curl http://localhost:8080/hello/developer
Hello developer!

Note que en Quarkus se utilizan anotaciones estándar de frameworks conocidos: CDI y JAX-RS. No es necesario aprender nada nuevo si usted ha trabajado con CDI y JAX-RS antes, por supuesto.

Trabajo con la base de datos

Se utilizan Hibernate y las anotaciones estándar de JPA para las entidades. Al igual que con los controladores REST, es necesario escribir un mínimo de código. Basta con especificar las dependencias en el archivo de construcción y agregar las anotaciones. @Entity y configurar el datasource en application.properties.

Eso es todo. No se necesitan sessionFactory, persistence.xml ni otros archivos de servicio. Solo escribimos el código que necesitamos. Sin embargo, si es necesario, se puede crear un archivo persistence.xml y configurar el nivel ORM de manera más detallada.

Quarkus soporta la caché de entidades, colecciones para relaciones uno a muchos, así como de consultas. A primera vista, parece genial, pero esto es caché local, para un solo nodo de Kubernetes. Es decir, las cachés de diferentes nodos no están sincronizadas entre sí. Espero que esto sea temporal.

Ejecución asíncrona del código

Como se mencionó anteriormente, Quarkus también admite el estilo de programación reactiva. El código de la aplicación anterior se puede escribir de otra manera.

@Path("/hello")
public class GreetingResource {

   @GET
   @Produces(MediaType.TEXT_PLAIN)
   @Path("/{name}")
   public CompletionStage greeting(@PathParam("name") String name) {
       return CompletableFuture.supplyAsync(() -> {
           return "¡Hola " + name + "!";
       });
   }
}

El código asíncrono también se puede trasladar a un servicio; el resultado será el mismo.

Pruebas

Las pruebas para aplicaciones Quarkus se pueden escribir en JUnit4 o JUnit5. A continuación se muestra un ejemplo de prueba para el endpoint, escrito con RestAssured, aunque se puede utilizar otro framework:

@QuarkusTest
public class GreetingResourceTest {

   @Test
   public void testGreetingEndpoint() {
       String uuid = UUID.randomUUID().toString();
       given()
         .pathParam("name", uuid)
         .when().get("/hello/{name}")
         .then()
           .statusCode(200)
           .body(is("¡Hola " + uuid + "!"));
   }
}

La anotación @QuarkusTest indica que se debe iniciar la aplicación antes de ejecutar las pruebas. Por lo demás, es el mismo código conocido por todos los desarrolladores.

Aplicación dependiente de la plataforma

Dado que Quarkus está estrechamente integrado con GraalVM, por supuesto, se puede generar código dependiente de la plataforma. Para ello, es necesario instalar GraalVM y establecer la variable de entorno GRAALVM_HOME. Luego, escribir un perfil para la construcción y especificarlo al construir la aplicación:

mvn package -Pnative

Lo interesante es que se puede probar la aplicación generada. Y esto es importante, ya que la ejecución del código "nativo" puede diferir de la ejecución en la JVM. La anotación @SubstrateTest ejecuta el código dependiente de la plataforma de la aplicación. La reutilización del código existente de las pruebas se puede realizar mediante la herencia, por lo que el código para probar una aplicación dependiente de la plataforma se verá así:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

La imagen generada se puede empaquetar en Docker y ejecutarse en Kubernetes o OpenShift, como se detalla en la guía.

Herramientas

El marco Quarkus se puede utilizar con Maven y Gradle. Maven se admite completamente, a diferencia de Gradle. Desafortunadamente, en este momento Gradle no admite la generación de un proyecto vacío, en el sitio hay una detallada manual.

Extensiones

Quarkus es un marco extensible. Actualmente, existen alrededor de 40 extensiones, que añaden diversas funcionalidades, desde soporte para el contenedor Spring DI y Apache Camel hasta el registro y la publicación de métricas para servicios en ejecución. Y ya existe una extensión para soportar la escritura de aplicaciones en el lenguaje Kotlin, además de Java.

Conclusión

En mi opinión, Quarkus está muy a la moda. El desarrollo del código backend se está volviendo cada vez más fácil, y este marco simplifica y acelera aún más el desarrollo de servicios, añadiendo soporte "nativo" para Docker y Kubernetes. Un gran plus es el soporte integrado para GraalVM y la generación de imágenes dependientes de la plataforma, lo que permite que los servicios se inicien realmente rápido y ocupen poco espacio en memoria. Y esto es muy importante en nuestra época de entusiasmo masivo por los microservicios y la arquitectura sin servidor.

El sitio oficial es — quarkus.io. Ya hay ejemplos de proyectos para un rápido inicio en GitHub.

Fuente: habr.com