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

1. Introdução

Em 7 de março, a RedHat (em breve IBM) apresentou a nova estrutura, Quarkus . Segundo os desenvolvedores, essa estrutura é baseada no GraalVM e no OpenJDK HotSpot e foi projetada para o Kubernetes. A pilha do 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 implantar no Kubernetes e desenvolver aplicativos sem servidor, fornecendo aos desenvolvedores uma abordagem unificada para o desenvolvimento de estilos reativos e imperativos.

Se você olhar para essa classificação de estruturas, o Quarkus está em algum lugar entre "Agregadores / Geradores de Código" e "Estruturas fullstack de alto nível". Isso já é mais do que um agregador, mas também não atinge a pilha completa, porque terreno para o desenvolvimento de back-end.

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

Tempo do início à primeira resposta (s):

Consumo de memória (Mb):

Impressionante, não é?

* Não encontrei informações sobre essa pilha de tecnologia, podemos supor que esse seja algum tipo de Spring Boot com um kit de corpo adicional .

Olá Mundo!

O aplicativo mais simples escrito em Quarkus seria assim:

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

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

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

Diferente da aplicação usual - não há classe de aplicação! O Quarkus suporta recarga a quente, para que você possa alterar o aplicativo sem reiniciá-lo, desenvolvendo assim ainda mais rapidamente.

O que vem a seguir? Você pode adicionar um serviço ao controlador usando a 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. Você não precisa aprender nada de novo se trabalhou com CDI e JAX-RS antes disso, é claro.

Trabalhar com o banco de dados

Usado pelo Hibernate e anotações JPA padrão para entidades. Como nos controladores REST, você precisa escrever um mínimo de código. Basta especificar as dependências no arquivo de montagem, organizar as anotações @Entity e configurar a fonte de dados em application.properties.

Só isso. Nenhum sessionFactory, persistence.xml e 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.

O Quarkus suporta o cache de entidades, coleções para relacionamentos um para muitos, além de consultas. À primeira vista, parece ótimo, mas é o cache local , para um único host Kubernetes. I.e. caches de nós diferentes não são sincronizados entre si. Espero que seja temporário.

Execução de código assíncrona

Como mencionado acima, o Quarkus também suporta um estilo de programação reativa. O código do aplicativo anterior pode ser escrito em outro formulário.

 @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 aplicativos Quarkus podem ser escritos em JUnit4 ou JUnit5. A seguir, é apresentado um exemplo de teste para terminal, que foi gravado usando RestAssured, mas você pode usar outra estrutura:

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

Aplicativo Dependente da Plataforma

Como o Quarkus está totalmente integrado ao GraalVM, é claro, o código específico da plataforma pode ser gerado. Para fazer isso, configure GraalVM e especifique a variável de ambiente GRAALVM_HOME. Em seguida, registre um perfil para a montagem e especifique-o ao criar o aplicativo:

 mvn package -Pnative 

Curiosamente, o aplicativo gerado pode ser testado. E isso é importante, pois a execução do código "nativo" pode ser diferente da execução na JVM. Anotação @SubstrateTest executa o código do 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 o aplicativo específico da plataforma terá a seguinte aparência:

 @SubstrateTest public class GreetingResourceIT extends GreetingResourceTest { } 

A imagem gerada pode ser empacotada no Docker e executada no Kubernetes ou no OpenShift, descrito em detalhes nas instruções .

Toolkit

A estrutura do Quarkus pode ser usada com Maven e Gradle. Maven é totalmente suportado, ao contrário de Gradle. Infelizmente, no momento em que o Gradle não suporta a geração de um projeto vazio, o site possui um tutorial detalhado.

Extensões

Quarkus é uma estrutura extensível. Atualmente, existem cerca de 40 extensões que adicionam várias funcionalidades - do suporte ao contêiner Spring DI e Apache Camel ao registro e publicação de métricas para serviços em execução. E já existe uma extensão para suportar aplicativos de escrita na linguagem Kotlin, além do Java.

Conclusão

Na minha opinião, o Quarkus faz parte das tendências do tempo. O desenvolvimento do código de back-end está ficando mais fácil e mais simples, e essa estrutura simplifica e acelera ainda mais o desenvolvimento de serviços, adicionando suporte "nativo" ao Docker e Kubernetes. Uma grande vantagem é o suporte interno ao GraalVM e a geração de imagens específicas da plataforma, que permitem tornar os serviços realmente rápidos, iniciando e ocupando pouco espaço de memória. E isso é muito importante em nosso tempo de enorme entusiasmo por microsserviços e arquitetura sem servidor.

O site oficial é quarkus.io . Exemplos de projetos para um início rápido já estão no GitHub .