Quarkus é um Java subatômico supersônico. Breve visão geral da estrutura

Introdução

Em XNUMX de março, RedHat (em breve IBM) apresentado novo quadro - quarks. Segundo os desenvolvedores, este framework é baseado em GraalVM e OpenJDK HotSpot e foi projetado para Kubernetes. A pilha Quarkus inclui: JPA/Hibernate, JAX-RS/RESTEasy, Eclipse Vert.x, Netty, Apache Camel, Kafka, Prometheus e outros.

O objetivo é tornar o Java a plataforma líder para implantação do Kubernetes e desenvolvimento de aplicativos sem servidor, fornecendo aos desenvolvedores uma abordagem unificada para o desenvolvimento em estilos reativos e imperativos.

Se você olhar para este classificação de frameworks, então Quarkus está em algum lugar entre “Agregadores/Geradores de Código” e “Frameworks fullstack de alto nível”. Isso já é mais que um agregador, mas não chega nem ao full stack, porque... adaptado para desenvolvimento de back-end.

São prometidas velocidades muito altas de inicialização de aplicativos e baixo consumo de memória. Aqui estão os dados do site do desenvolvedor:

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

Configuração
DESCANSO
REST+JPA

Quarkus+GraalVM
0.014
0.055

Quarkus+OpenJDK
0.75
2.5

Pilha tradicional nativa da nuvem*
4.3
9.5

Consumo de memória (Mb):

Configuração
DESCANSO
REST+JPA

Quarkus+GraalVM
13
35

Quarkus+OpenJDK
74
130

Pilha tradicional nativa da nuvem*
140
218

Impressionante, não é?

*Não encontrei nenhuma informação sobre esta pilha de tecnologia, podemos assumir que se trata de algum tipo de Spring Boot com um body kit adicional.

Olá Mundo!

A aplicação mais simples escrita em Quarkus ficaria assim:

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

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

É literalmente uma aula e basta! Você pode executar o aplicativo usando Maven em modo de desenvolvimento:

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

A diferença de uma aplicação normal é que não existe nenhuma classe Application! O Quarkus suporta hot reload, para que você possa alterar seu aplicativo sem reiniciá-lo, tornando o desenvolvimento ainda mais rápido.

Qual é o próximo? Você pode adicionar um serviço a um controlador usando uma anotação Injetar. Código de 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 usa anotações padrão de estruturas familiares - CDI e JAX-RS. Não há necessidade de aprender nada novo se você já trabalhou com CDI e JAX-RS antes, é claro.

Trabalhando com o banco de dados

São usadas anotações Hibernate e JPA padrão para entidades. Tal como acontece com os controladores REST, você precisa escrever um mínimo de código. Basta indicar as dependências no arquivo assembly, adicionar anotações @Entity e configure a fonte de dados em application.properties.

Todos. Nenhum sessionFactory, persistence.xml ou outros arquivos de serviço. Escrevemos apenas o código necessário. No entanto, se necessário, você pode criar um arquivo persistence.xml e configurar a camada ORM com mais detalhes.

Quarkus suporta cache de entidades, coleções para relacionamentos um-para-muitos e consultas. À primeira vista parece ótimo, mas é local cache, para um nó Kubernetes. Aqueles. Os caches de diferentes nós não são sincronizados entre si. Espero que isso seja temporário.

Execução de código assíncrono

Conforme mencionado acima, o Quarkus também oferece suporte ao estilo de programação reativo. O código do aplicativo anterior pode ser escrito de uma 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 + "!";
       });
   }
}

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

Teste

Os testes para aplicações Quarkus podem ser escritos em JUnit4 ou JUnit5. Abaixo está um exemplo de teste para um endpoint, ele foi escrito usando RestAssured, mas outra estrutura pode ser usada:

@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 instrui você a executar o aplicativo antes de executar os testes. O resto é código familiar a todos os desenvolvedores.

Aplicativo específico da plataforma

Como o Quarkus está totalmente integrado ao GraalVM, é claro que é possível gerar código específico da plataforma. Para fazer isso, você precisa instalar o GraalVM e especificar a variável de ambiente GRAALVM_HOME. Avançar registrar um perfil para montagem e especifique-o ao criar o aplicativo:

mvn package -Pnative

Curiosamente, o aplicativo gerado pode ser testado. E isso é importante porque a execução do código nativo pode ser diferente da execução na JVM. A anotação @SubstrateTest executa código de aplicativo específico da plataforma. A reutilização do código de teste existente pode ser feita usando herança; como resultado, o código para testar um aplicativo dependente de plataforma será semelhante a este:

@SubstrateTest
public class GreetingResourceIT extends GreetingResourceTest {

}

A imagem gerada pode ser empacotada em Docker e executada em Kubernetes ou OpenShift, descrita detalhadamente em instruções.

Toolkit

A estrutura Quarkus pode ser usada com Maven e Gradle. Maven é totalmente compatível, ao contrário do Gradle. Infelizmente, no momento o Gradle não suporta a geração de um projeto vazio; há informações detalhadas no site livro didático.

expansão

Quarkus é uma estrutura extensível. Atualmente existe um pedido 40 extensões, que adicionam diversas funcionalidades - desde suporte Recipiente Spring DI и Apache Camelo antes de registrar e publicar métricas para serviços em execução. E já existe uma extensão para suportar a escrita de aplicações em Kotlin, além de Java.

Conclusão

Na minha opinião, Quarkus está bastante alinhado com as tendências da época. O desenvolvimento de código de back-end está se tornando cada vez mais fácil, e esta estrutura simplifica e acelera ainda mais o desenvolvimento de serviços, adicionando suporte nativo para Docker e Kubernetes. Uma grande vantagem é o suporte integrado para GraalVM e a geração de imagens dependentes da plataforma, o que permite que os serviços sejam iniciados muito rapidamente e ocupem pouco espaço de memória. E isso é muito importante em nossa época de paixão em massa por microsserviços e arquitetura sem servidor.

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

Fonte: habr.com