Usuário(a):Gabriel Arruda20/Testes

Introdução

O Micronaut é uma estrutura Java moderna, baseada em e de pilha completa, projetada para criar aplicativos JVM modulares e facilmente testáveis ​​com suporte para Java, Kotlin e Groovy.

O Micronaut é desenvolvido pelos criadores da estrutura Grails e se inspira nas lições aprendidas ao longo dos anos construindo aplicativos do mundo real de monólitos a microsserviços usando Spring, Spring Boot e Grails.

A Micronaut visa fornecer todas as ferramentas necessárias para construir aplicações JVM, incluindo:

• Injeção de Dependência e Inversão de Controle (IoC)
• Programação Orientada a Aspectos (AOP)
• Padrões sensatos e configuração automática

Com o Micronaut, você pode criar aplicativos orientados a mensagens, aplicativos de linha de comando, servidores HTTP e muito mais, enquanto para microsserviços em particular, o Micronaut também fornece:

• Configuração Distribuída
• Descoberta de serviço
• Roteamento HTTP
• Balanceamento de carga do lado do cliente

Ao mesmo tempo, o Micronaut visa evitar as desvantagens de frameworks como Spring, Spring Boot e Grails, fornecendo:

• Tempo de inicialização rápido
• Pegada de memória reduzida

Uso mínimo de reflexão

• Uso mínimo de proxies
• Sem geração de bytecode em tempo de execução
• Teste de unidade fácil

Historicamente, estruturas como Spring e Grails não foram projetadas para serem executadas em cenários como funções sem servidor, aplicativos Android ou microsserviços com baixo consumo de memória. Em contraste, o Micronaut foi projetado para ser adequado para todos esses cenários.

Este objetivo é alcançado através do uso de processadores de anotação Java, que podem ser usados ​​em qualquer linguagem JVM que os suporte, bem como um servidor e cliente HTTP construídos em Netty . Para fornecer um modelo de programação semelhante ao Spring e Grails, esses processadores de anotação pré-compilam os metadados necessários para realizar DI, definem proxies AOP e configuram seu aplicativo para execução em um ambiente de pouca memória.

Muitas APIs no Micronaut são fortemente inspiradas em Spring e Grails. Isso ocorre por design e ajuda a atualizar os desenvolvedores rapidamente.

Início rápido

As seções a seguir orientam você através de um início rápido sobre como usar o Micronaut para configurar um aplicativo "Hello World" básico.

Antes de começar, certifique-se de ter um JDK Java 8 ou superior instalado e é recomendável usar um IDE adequado , como o IntelliJ IDEA.

Aumentando o consumo de memória

Atualmente, muitas organizações escolhem o Spring Boot como sua estrutura preferida ao desenvolver novos microsserviços. Principalmente porque o Spring Boot é realmente fácil de configurar, há uma comunidade vibrante e muitos guias para colocá-lo em funcionamento. Um problema com o Spring em geral é que o consumo de memória cresce de forma constante quando você começa a adicionar funcionalidade ao seu microsserviço. Quando você tem um cenário completo que consiste em vários microsserviços baseados em Spring, os custos operacionais podem aumentar e a facilidade de desenvolvimento torna-se menor.

Tempo de execução x tempo de compilação

É aí que entra o Micronaut. Ele foi criado para eliminar os problemas acima mencionados, oferecendo ainda a facilidade de desenvolvimento e configuração de tudo. Você provavelmente se pergunta como eles conseguem isso? Principalmente se trata de como eles funcionam internamente. O Spring faz a injeção de dependência com base na reflexão. Ele também salva e armazena em cache muitas informações durante o tempo de execução, o que entope a memória quando você começa a adicionar funcionalidades.

Micronaut faz isso diferente. Ele faz injeção de dependência com base em processadores de anotação que pré-compilam os metadados necessários. Como tudo o que é necessário para injeção de dependência é feito em tempo de compilação, não é necessário fazer isso em tempo de execução e isso pode economizar muita memória a longo prazo.

Recursos nativos da nuvem

A maioria das estruturas JVM em uso hoje foi projetada antes do surgimento das implantações em nuvem e das arquiteturas de microsserviços. Os aplicativos criados com essas estruturas destinavam-se a serem implantados em contêineres Java tradicionais. Como resultado, o suporte à nuvem nessas estruturas geralmente vem como um complemento, e não como recursos de design principais.

O Micronaut foi projetado desde o início para criar microsserviços para a nuvem. Como resultado, muitos recursos importantes que normalmente requerem bibliotecas ou serviços externos estão disponíveis no próprio aplicativo. Para substituir um dos chavões favoritos do setor, os aplicativos Micronaut são "nativos da nuvem".

A seguir estão alguns recursos específicos da nuvem que são integrados diretamente ao tempo de execução do Micronaut:

• Configuração Distribuída
• Descoberta de serviço
• Balanceamento de carga do lado do cliente
• Rastreamento Distribuído
• Funções sem servidor

Muitos recursos do Micronaut são fortemente inspirados pelos recursos do Spring e do Grails. Isso ocorre por design e ajuda os desenvolvedores que já estão familiarizados com sistemas como o Spring Cloud.

As seções a seguir abordam esses recursos e como usá-los.

• Configuração da Nuvem

Os aplicativos criados para a nuvem geralmente precisam se adaptar à execução em um ambiente de nuvem, ler e compartilhar a configuração de maneira distribuída e externalizar a configuração para o ambiente quando necessário.

O conceito de ambiente do Micronaut é, por padrão, compatível com a plataforma Cloud e faz o melhor esforço para detectar o ambiente ativo subjacente.

Você pode usar a anotação Requires para carregar condicionalmente as definições de bean.

Configurações

O Micronaut apresenta várias configurações integradas que permitem a integração com bancos de dados comuns e outros servidores.

O Projeto Reactor é usado internamente pelo Micronaut. No entanto, para usar Reactor ou outros tipos de bibliotecas reativas (por exemplo, RxJava) em seu controlador e/ou métodos de cliente HTTP, você precisa incluir dependências.

Suporte a idiomas

O Micronaut suporta qualquer linguagem JVM que implemente a API Java Annotation Processor .

Embora o Groovy não ofereça suporte a essa API, foi criado um suporte especial usando transformações AST. A lista atual de linguagens suportadas é: Java, Groovy e Kotlin (por meio da kaptferramenta).

Teoricamente, qualquer linguagem que suporte uma maneira de analisar o AST em tempo de compilação pode ser suportada. O pacote io.micronaut.inject.writer inclui classes de linguagem neutra que constroem classes BeanDefinition em tempo de compilação usando a ferramenta ASM.

Compilador

O Micronaut Compiler é um conjunto de extensões para compiladores de linguagem existentes:

• Java- a API Java Annotation Processing (APT) é usada para código Java e Kotlin (uma versão futura do Micronaut suportará KSP para Kotlin)
• Groovy - As transformações Groovy AST são usadas para participar da compilação do código Groovy.

Para manter esta documentação simples, as seções restantes irão descrever a interação com o compilador Java.

O Micronaut Compiler visita o código do usuário final e gera bytecode adicional que fica ao lado do código do usuário na mesma estrutura de pacote.

O AST da origem do usuário é visitado usando implementações de TypeElementVisitor que são carregadas por meio do mecanismo de carregador de serviço Java padrão .

Cada implementação de TypeElementVisitor pode substituir um ou mais dos visit*métodos que recebem uma instância de Element .

A API de elemento fornece uma abstração de linguagem neutra sobre o AST e cálculo do AnnotationMetadata para um determinado elemento (classe, método, campo etc.).

Metadados de anotação

Micronaut é uma implementação de um modelo de programação baseado em anotação. Isso quer dizer que as anotações formam uma parte fundamental do design da API da estrutura.

Dada essa decisão de design, um modelo de tempo de compilação foi formulado para enfrentar os desafios de avaliar anotações em tempo de execução.

A API AnnotationMetadata é uma construção usada em tempo de compilação e em tempo de execução por componentes de estrutura. AnnotationMetadatarepresenta a fusão computada de informações de anotação para um determinado tipo, campo, construtor, método ou propriedade de bean e pode incluir ambas as anotações declaradas no código-fonte, mas também meta-anotações sintéticas que podem ser usadas em tempo de execução para implementar a lógica do framework.

Ao visitar o código-fonte no Micronaut Compiler usando a API de elemento para cada ClassElement , FieldElement , MethodElement , ConstructorElement e PropertyElement , uma instância de AnnotationMetadata é computada.

A AnnotationMetadataAPI tenta abordar os seguintes desafios:

• As anotações podem ser herdadas de tipos e interfaces em implementações. Para evitar a necessidade de percorrer a hierarquia de classe/interface em tempo de execução, o Micronaut irá, em tempo de construção, calcular anotações herdadas e lidar com regras de substituição de membro
• As anotações podem ser anotadas com outras anotações. Essas anotações são frequentemente chamadas de meta-anotações ou estereótipos. A AnnotationMetadataAPI fornece métodos para entender se uma anotação específica é declarada como meta-anotação e para descobrir quais anotações são meta-anotadas com outras anotações
• Freqüentemente, é necessário fundir metadados de anotação de diferentes fontes. Por exemplo, para propriedades JavaBean, você deseja combinar os metadados do campo privado, do getter público e dos setters públicos em uma única exibição, caso contrário, você terá que executar a lógica no tempo de execução para combinar de alguma forma esses metadados de 3 fontes distintas.
• Anotações repetíveis são combinadas e normalizadas. Se herdadas, as anotações são combinadas de interfaces ou classes pai, fornecendo uma única API para avaliar anotações repetíveis em vez de exigir lógica de tempo de execução para executar a normalização.

Quando a origem de um tipo é visitada, uma instância de ClassElement é construída por meio da API ElementFactory .

O ElementFactory usa uma instância de AbstractAnnotationMetadataBuilder que contém implementações específicas de linguagem para construir AnnotationMedatapara o tipo nativo subjacente no AST. No caso de Java, seria um arquivo javax.model.element.TypeElement.

Referências

https://docs.micronaut.io/latest/guide/#breaks https://blogs.infosupport.com/micronaut-a-new-spring-like-framework-focussed-on-minimal-memory-consumption/

Links externos

Site oficial