Quarkus é un Java subatómico supersónico. Breve descrición do marco

Introdución

O XNUMX de marzo, RedHat (en breve IBM) presentado novo marco - quarkus. Segundo os desenvolvedores, este marco está baseado en GraalVM e OpenJDK HotSpot e está deseñado para Kubernetes. A pila Quarkus inclúe: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus e outros.

O obxectivo é facer de Java a plataforma líder para a implantación de Kubernetes e o desenvolvemento de aplicacións sen servidor, proporcionando aos desenvolvedores un enfoque unificado para o desenvolvemento tanto en estilos reactivos como imperativos.

Se miras isto clasificación de marcos, entón Quarkus está nalgún lugar entre "Agregadores/Xeradores de código" e "Marcos completos de alto nivel". Isto xa é algo máis que un agregador, pero nin sequera chega á pila completa, porque... adaptado para o desenvolvemento de backend.

Prométese unha velocidade moi alta de lanzamento da aplicación e un baixo consumo de memoria. Aquí tes os datos do sitio web do programador:

Tempo desde o inicio ata a primeira resposta(s):

Configuración
DESCANSO
REST+JPA

Quarkus+GraalVM
0.014
0.055

Quarkus+OpenJDK
0.75
2.5

Pila nativa na nube tradicional*
4.3
9.5

Consumo de memoria (Mb):

Configuración
DESCANSO
REST+JPA

Quarkus+GraalVM
13
35

Quarkus+OpenJDK
74
130

Pila nativa na nube tradicional*
140
218

Impresionante, non?

*Non atopei ningunha información sobre esta pila de tecnoloxía, podemos supoñer que se trata dunha especie de Spring Boot cun kit de carrocería adicional.

Ola mundo!

A aplicación máis sinxela escrita en Quarkus sería así:

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

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

É literalmente unha clase e é suficiente! Podes executar a aplicación usando Maven no modo de desenvolvemento:

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

A diferenza dunha aplicación normal é que non hai unha clase de aplicación. Quarkus admite a recarga en quente, polo que pode cambiar a súa aplicación sen reiniciala, facendo que o desenvolvemento sexa aínda máis rápido.

Que segue? Podes engadir un servizo a un controlador mediante unha anotación Inxectar. Código de servizo:

@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!

Teña en conta que Quarkus usa anotacións estándar de marcos coñecidos: CDI e JAX-RS. Non hai que aprender nada novo se xa traballaches con CDI e JAX-RS antes, por suposto.

Traballando coa base de datos

Utilízanse anotacións de Hibernate e JPA estándar para as entidades. Do mesmo xeito que cos controladores REST, cómpre escribir un mínimo de código. Basta con indicar as dependencias no ficheiro de montaxe, engadir anotacións @Entity e configurar a fonte de datos na aplicación.propiedades.

Todos. Non hai ficheiros sessionFactory, persistence.xml nin outros servizos. Escribimos só o código que sexa necesario. Non obstante, se é necesario, pode crear un ficheiro persistence.xml e configurar a capa ORM con máis precisión.

Quarkus admite o almacenamento en caché de entidades, coleccións para relacións de un a varios e consultas. A primeira vista parece xenial, pero é así local caché, para un nodo de Kubernetes. Eses. As cachés dos distintos nodos non están sincronizadas entre si. Espero que isto sexa temporal.

Execución de código asíncrono

Como se mencionou anteriormente, Quarkus tamén admite o estilo de programación reactiva. O código da solicitude anterior pódese escribir nunha forma diferente.

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

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

Tamén se pode transferir código asíncrono ao servizo, o resultado será o mesmo.

Probas

As probas para aplicacións Quarkus pódense escribir en JUnit4 ou JUnit5. A continuación móstrase un exemplo de proba para un punto final, está escrito usando RestAssured, pero pódese usar outro marco:

@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("Hello " + uuid + "!"));
   }
}

A anotación @QuarkusTest indícase que execute a aplicación antes de realizar probas. O resto é código familiar para todos os desenvolvedores.

Aplicación específica da plataforma

Dado que Quarkus está estreitamente integrado con GraalVM, por suposto que é posible xerar código específico da plataforma. Para iso, cómpre instalar GraalVM e especificar a variable de ambiente GRAALVM_HOME. Ademais rexistrar un perfil para a montaxe e especifíqueo ao crear a aplicación:

mvn package -Pnative

Curiosamente, a aplicación xerada pódese probar. E isto é importante porque a execución do código nativo pode diferir da execución na JVM. A anotación @SubstrateTest executa código de aplicación específico da plataforma. A reutilización do código de proba existente pódese facer mediante a herdanza; como resultado, o código para probar unha aplicación dependente da plataforma terá o seguinte aspecto:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

A imaxe xerada pódese empaquetar en Docker e executarse en Kubernetes ou OpenShift, descrito en detalle en instrucións.

Kit de ferramentas

O framework Quarkus pódese usar con Maven e Gradle. Maven é totalmente compatible, a diferenza de Gradle. Desafortunadamente, polo momento Gradle non admite a xeración dun proxecto baleiro; hai información detallada no sitio web o libro de texto.

Extensións

Quarkus é un framework extensible. Actualmente hai unha orde 40 extensións, que engaden varias funcionalidades, desde o soporte Contenedor de resorte DI и Apache Camel antes de rexistrar e publicar métricas para a execución dos servizos. E xa hai unha extensión para admitir aplicacións de escritura en Kotlin, ademais de Java.

Conclusión

Na miña opinión, Quarkus está bastante en liña coas tendencias da época. O desenvolvemento de código de backend é cada vez máis sinxelo e este cadro simplifica e acelera aínda máis o desenvolvemento do servizo engadindo soporte nativo para Docker e Kubernetes. Unha gran vantaxe é o soporte integrado para GraalVM e a xeración de imaxes dependentes da plataforma, o que permite que os servizos se inicien moi rápido e ocupen pouco espazo de memoria. E isto é moi importante na nosa época de paixón masiva polos microservizos e a arquitectura sen servidor.

Sitio oficial - quarkus.io. Xa están dispoñibles exemplos de proxectos para un inicio rápido GitHub.

Fonte: www.habr.com