🥇Quarkus — Java subatômica hipersônica. Uma breve visão do framework

Introdução

No dia sete de março, a empresa RedHat (em breve — IBM) apresentou um novo framework — Quarkus. Segundo os desenvolvedores, este framework é baseado no GraalVM e no OpenJDK HotSpot e é destinado ao Kubernetes. O stack Quarkus inclui: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus e outros.

O objetivo da criação é tornar o Java a plataforma líder para implantação no Kubernetes e desenvolvimento de aplicações serverless, fornecendo aos desenvolvedores uma abordagem unificada para o desenvolvimento tanto em estilo reativo quanto imperativo.

Se olharmos para este a classificação dos frameworks, o Quarkus se posiciona entre 'Agregadores/Geradores de Código' e 'Frameworks Full-Stack de Alto Nível'. É mais do que um agregador, mas ainda não chega a ser full-stack, já que é voltado para o desenvolvimento backend.

Foi prometida uma velocidade de inicialização extremamente alta e baixo consumo de memória. Aqui estão os dados do site do desenvolvedor:

Tempo desde o início até a primeira resposta (s):

Configuração
REST
REST+JPA

Quarkus+GraalVM
0.014
0.055

Quarkus+OpenJDK
0.75
2.5

Pilha Nativa Tradicional*
4.3
9.5

Consumo de memória (Mb):

Configuração
REST
REST+JPA

Quarkus+GraalVM
13
35

Quarkus+OpenJDK
74
130

Pilha Nativa Tradicional*
140
218

Impressionante, não é?

*Não encontrei informações sobre esta stack de tecnologias, podemos presumir que seja algum Spring Boot com um complemento adicional.

Hello World!

O aplicativo mais simples, escrito com Quarkus, terá a seguinte aparência:

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

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

Isso é literalmente uma classe e é suficiente! Você pode iniciar o aplicativo usando Maven no modo de desenvolvimento:

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

A diferença em relação ao aplicativo tradicional é que não há a classe Application! O Quarkus suporta hot reload, permitindo que você altere o aplicativo sem reiniciá-lo, tornando o desenvolvimento ainda mais rápido.

E agora? Você pode adicionar um serviço ao controlador usando a anotação Injeção. O código do serviço:

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

Observe que o Quarkus utiliza anotações padrão de frameworks conhecidos — CDI e JAX-RS. Não há necessidade de aprender nada novo, se você já trabalhou com CDI e JAX-RS antes.

Trabalho com banco de dados

Utiliza Hibernate e anotações padrão do JPA para entidades. Assim como com os controladores REST, é necessário escrever o mínimo de código. Basta indicar as dependências no arquivo de construção e adicionar as anotações. @Entity e configurar a datasource no application.properties.

Isso é tudo. Sem sessionFactory, persistence.xml e outros arquivos de serviço. Escrevemos apenas o código que é necessário. No entanto, se necessário, pode-se criar um arquivo persistence.xml e configurar mais detalhadamente a camada ORM.

O Quarkus suporta o cache de entidades, coleções para relacionamentos um-para-muitos, assim como consultas. À primeira vista, isso parece ótimo, mas é cache local para um único nó do Kubernetes. Ou seja, os caches de diferentes nós não são sincronizados entre si. Espero que isso seja temporário.

Execução assíncrona de código

Como mencionado acima, o Quarkus também suporta o estilo de programação reativa. O código do aplicativo anterior pode ser escrito de outra forma.

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

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

O código assíncrono também pode ser transferido para um serviço; o resultado será o mesmo.

Testes

Os testes para aplicativos Quarkus podem ser escritos com JUnit4 ou JUnit5. Abaixo está um exemplo de teste para o endpoint, escrito usando o RestAssured, mas pode-se usar outro 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("Hello " + uuid + "!"));
   }
}

A anotação @QuarkusTest indica que o aplicativo deve ser iniciado antes de executar os testes. No restante, é o código familiar a todos os desenvolvedores.

Aplicativo dependente da plataforma

Uma vez que o Quarkus está intimamente integrado ao GraalVM, é claro que é possível gerar código dependente da plataforma. Para isso, é necessário instalar o GraalVM e definir a variável de ambiente GRAALVM_HOME. Em seguida, definir um perfil para a construção e especificá-lo ao construir o aplicativo:

mvn package -Pnative

O interessante é que o aplicativo gerado pode ser testado. E isso é importante, pois a execução do código 'nativo' pode diferir da execução na JVM. A anotação @SubstrateTest executa o código do aplicativo dependente da plataforma. O reaproveitamento do código de teste existente pode ser feito por meio da herança, e, no final, o código para testar um aplicativo dependente da plataforma ficará assim:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

A imagem gerada pode ser empacotada em Docker e executada no Kubernetes ou OpenShift, como descrito em documentação.

Ferramentas

O framework Quarkus pode ser usado com Maven e Gradle. O Maven é totalmente suportado, ao contrário do Gradle. Infelizmente, no momento, o Gradle não suporta a geração de um projeto vazio, mas há informações detalhadas no site tutorial.

Extensões

Quarkus é um framework extensível. Atualmente, existem cerca de 40 extensões, que adicionam diversas funcionalidades — desde o suporte ao container Spring DI e Apache Camel até logging e publicação de métricas para serviços em funcionamento. E já existe uma extensão que suporta a escrita de aplicativos na linguagem Kotlin, além do Java.

Conclusão

Na minha opinião, Quarkus está definitivamente nas tendências do momento. O desenvolvimento de código backend está se tornando cada vez mais simples, e este framework torna ainda mais fácil e rápido o desenvolvimento de serviços, adicionando suporte 'nativo' ao Docker e Kubernetes. Um grande ponto positivo é o suporte integrado ao GraalVM e à geração de imagens dependentes da plataforma, o que permite que os serviços realmente iniciem rapidamente e ocupem pouco espaço em memória. Isso é muito importante em nossa época de crescente fascínio por microserviços e arquitetura serverless.

Site oficial — quarkus.io. Exemplos de projetos para um início rápido já estão disponíveis em GitHub.

Fonte: habr.com