1. O que é o Micronaut
O Micronaut é uma estrutura da JVM para a construção de aplicativos modulares leves. Foi desenvolvido pela OCI, a mesma empresa que a Grails nos deu. O Micronaut é uma estrutura moderna projetada para tornar a criação de aplicativos de microsserviço rápida e fácil.
O Micronaut contém recursos semelhantes às estruturas existentes, como o Spring, mas, ao mesmo tempo, implementa algumas novas idéias que são suas características. Juntamente com o suporte a Java, Groovy e Kotlin, oferece muitas maneiras de criar aplicativos.
2. Principais recursos
Um dos recursos mais interessantes do Micronaut é a injeção de dependência (DI) em tempo de compilação. A maioria das estruturas usa objetos de reflexão e proxy para injetar dependências no tempo de execução. O Micronaut também coleta dados para injeção de dependência no estágio de compilação. O resultado são tempos de inicialização do aplicativo mais rápidos e menor consumo de memória.
Sua próxima oportunidade é o suporte de primeira classe à programação reativa, tanto para clientes quanto para servidores. A escolha de uma implementação específica da abordagem reativa é deixada para os desenvolvedores da solução, e o RxJava e o Project Reactor são suportados imediatamente.
Além disso, o Micronaut possui vários recursos que o tornam uma excelente estrutura de desenvolvimento nativa da nuvem. Ele suporta muitos mecanismos de descoberta de serviços, como Eureka e Consul, e também trabalha com vários sistemas de rastreamento distribuídos, como Zipkin e Jaeger.
Além disso, fornece suporte para a criação de funções lambda da AWS, facilitando a criação de aplicativos sem servidor.
3. Introdução
A maneira mais fácil de começar é usar o SDKMAN:
> sdk install micronaut 1.0.0.M2
O SDKMAN instalará todos os binários necessários para criar, testar e implantar aplicativos Micronaut. Além disso, você receberá um aplicativo de console Micronaut CLI, permitindo iniciar facilmente um novo projeto.
Artefatos binários também estão disponíveis no Sonatype e no Github.
Nas seções a seguir, veremos alguns dos recursos do Micronaut.
4. Injeção de Dependência (DI)
Como mencionado anteriormente, o Micronaut lida com a injeção de dependência em tempo de compilação, o que o diferencia da maioria dos contêineres IoC.
No entanto, ele suporta totalmente anotações JSR-330, portanto, o manuseio de bean é semelhante a outras estruturas de IoC.
Para injetar uma lixeira em nosso código, usamos
@Inject :
@Inject private EmployeeService service;
A
@Inject funciona como
@Autowired e pode ser usada com campos, métodos, construtores e parâmetros.
Por padrão, todos os beans têm um escopo - protótipo. Podemos criar rapidamente singletones usando a anotação
@Singleton . Se vários beans implementarem a mesma interface, podemos usar a anotação
@Primary para resolver o conflito:
@Primary @Singleton public class BlueCar implements Car {}
A
@Requires pode ser usada quando os beans são opcionais ou para executar uma injeção quando determinadas condições forem atendidas.
Nesse sentido, ele se comporta da mesma maneira que a anotação Spring Boot -
@Conditional .
@Singleton @Requires(beans = DataSource.class) @Requires(property = "enabled") @Requires(missingBeans = EmployeeService) @Requires(sdk = Sdk.JAVA, value = "1.8") public class JdbcEmployeeService implements EmployeeService {}
5. Crie um servidor HTTP
Agora, vamos tentar criar um aplicativo de servidor HTTP simples. Para começar, usaremos o SDKMAN:
> mn create-app hello-world-server -build maven
Portanto, criaremos um novo projeto Java com o Maven em um diretório chamado hello-world-server. Dentro deste diretório, encontraremos o código principal do aplicativo, o arquivo Maven POM e outros arquivos de projeto.
A aplicação mais simples é assim:
public class ServerApplication { public static void main(String[] args) { Micronaut.run(ServerApplication.class); } }
5.1 Bloqueando HttpRequest
O aplicativo em si não faz quase nada. Vamos adicionar um controlador com dois manipuladores. Ambos retornarão uma saudação, mas um responderá às solicitações GET e o outro responderá ao POST.
@Controller("/greet") public class GreetController { @Inject private GreetingService greetingService; @Get("/{name}") public String greet(String name) { return greetingService.getGreeting() + name; } @Post(value = "/{name}", consumes = MediaType.TEXT_PLAIN) public String setGreeting(@Body String name) { return greetingService.getGreeting() + name; } }
Do tradutor: seu humilde servo foi e fez tudo o que é dito neste artigo. Se, nesse ponto, você estiver prestes a iniciar o aplicativo e verificar se ele funciona, não se esqueça de ativar o Annotation Processing no Eclipse / IntelliJ IDEA.5.2 E / S reativa
Por padrão, o Micronaut implementa esses manipuladores como uma E / S de bloqueio tradicional. No entanto, podemos implementar rapidamente manipuladores sem bloqueio simplesmente alterando o tipo de retorno para qualquer um dos tipos reativos sem bloqueio.
Por exemplo, com RxJava, podemos usar
Observable . Da mesma forma, com o Reactor, podemos retornar os tipos
Mono ou
Flux :
@Get("/{name}") public Mono<String> greet(String name) { return Mono.just(greetingService.getGreeting() + name); }
Do tradutor: neste exemplo, você precisará do Project Reactor nas dependências do Maven: <dependency> <groupId>io.projectreactor</groupId> <artifactId>reactor-core</artifactId> <version>3.1.8.RELEASE</version> </dependency>
Manipuladores de bloqueio e não-bloqueio usam o servidor HTTP Netty.
Normalmente, as solicitações são processadas no conjunto de encadeamentos de E / S principal, criado na inicialização, o que os torna bloqueados.
No entanto, se o manipulador retornar tipos de dados sem bloqueio, o Micronaut usará o loop de eventos Netty, tornando a solicitação inteira sem bloqueio.
6. Crie um cliente HTTP
Agora, vamos criar um aplicativo cliente para os manipuladores que acabamos de criar. O Micronaut fornece duas maneiras de criar clientes HTTP:
- declarativo
- software
6.1 Criação declarativa de um cliente HTTP
A primeira e mais simples maneira de criar é usar uma abordagem declarativa:
@Client("/greet") public interface GreetingClient { @Get("/{name}") String greet(String name); }
Observe que não implementamos uma única linha de código para chamar o serviço. Em vez disso, o Micronaut entende como chamar um serviço a partir de uma assinatura de método e anotações.
Para testar esse cliente, podemos criar um teste JUnit que usa a API do servidor para executar o servidor incorporado:
public class GreetingClientTest { private EmbeddedServer server; private GreetingClient client; @Before public void setup() { server = ApplicationContext.run(EmbeddedServer.class); client = server.getApplicationContext().getBean(GreetingClient.class); } @After public void cleanup() { server.stop(); } @Test public void testGreeting() { assertEquals(client.greet("Mike"), "Hello Mike"); } }
De um tradutor: para leitores preguiçosos e curiosos, existe um projeto pronto no Github: github.com/jreznot/micronaut-introduction6.2 Criando programaticamente um cliente HTTP
Existe uma opção para criar um cliente HTTP tradicional se você precisar de mais controle sobre seu comportamento e implementação:
@Singleton public class ConcreteGreetingClient { private RxHttpClient httpClient; public ConcreteGreetingClient(@Client("/") RxHttpClient httpClient) { this.httpClient = httpClient; } public String greet(String name) { HttpRequest<String> req = HttpRequest.GET("/greet/" + name); return httpClient.retrieve(req).blockingFirst(); } public Single<String> greetAsync(String name) { HttpRequest<String> req = HttpRequest.GET("/async/greet/" + name); return httpClient.retrieve(req).first("An error as occurred"); } }
O cliente usa o RxJava por padrão, para que você possa usar facilmente as chamadas de bloqueio e não bloqueio.
7. CLI do Micronaut
Já vimos como o utilitário CLI do Micronaut funcionava quando criamos o aplicativo.
No nosso caso, era um aplicativo separado, mas esse utilitário suporta vários outros recursos.
7.1 Projetos de múltiplas aplicações (Federação)
No Micronaut, a federação é simplesmente um grupo de aplicativos individuais que são desenvolvidos em um único projeto. Usando a federação, podemos gerenciar facilmente todos eles juntos e garantir que eles usem as mesmas configurações.
Quando usamos a CLI para gerar federação, o utilitário usa os mesmos argumentos que o comando create-app. Ela criará o diretório principal do projeto e colocará cada aplicativo em um subdiretório.
7.2 Recursos
Ao criar um aplicativo ou federação, podemos escolher quais recursos nosso aplicativo precisa. Isso permite que você use o conjunto mínimo de dependências no projeto.
-features as possibilidades no argumento saw
-features , separando-as por vírgulas.
Você pode listar os recursos disponíveis com o seguinte comando:
> mn profile-info service Provided Features: -------------------- * annotation-api - Adds Java annotation API * config-consul - Adds support for Distributed Configuration with Consul * discovery-consul - Adds support for Service Discovery with Consul * discovery-eureka - Adds support for Service Discovery with Eureka * groovy - Creates a Groovy application [...] More features available
Do tradutor: bem, aqui não se surpreenda, a equipe deve ser executada fora do diretório do projeto. O diretório do projeto não funciona, talvez na versão .M3 eles o tenham corrigido. Ela já foi embora.7.3 Projetos existentes
Podemos usar a CLI para modificar projetos existentes. Isso nos permite criar caixas, clientes, controladores etc. Quando executamos o comando "mn" no diretório do projeto, os seguintes comandos estarão disponíveis:
> mn help | Command Name Command Description
8. Conclusão
Nesta breve introdução ao Micronaut, vimos como é fácil criar servidores e clientes HTTP com e sem bloqueio. Também analisamos alguns recursos da CLI.
Este é apenas um pedacinho do bolo que o Micronaut oferece. Sob o capô, ele suporta funções sem servidor, descoberta de serviço, rastreamento distribuído, monitoramento e métricas, configurações distribuídas e muito mais.
No entanto, como muitos dos recursos do Micronaut foram emprestados de estruturas existentes, como Grails e Spring, ele oferece recursos exclusivos que o diferenciam de outros.