Introduction au cadre Micronaut

1. Qu'est-ce que le micronaut

Micronaut est un framework JVM pour la construction d'applications modulaires légères. Il a été développé par OCI, la même entreprise que Grails nous a donnée. Micronaut est un cadre moderne conçu pour rendre la création d'applications de microservices rapide et facile.

Micronaut contient des fonctionnalités similaires aux frameworks existants tels que Spring, mais en même temps, il met en œuvre de nouvelles idées qui sont ses caractéristiques. Associé à la prise en charge de Java, Groovy et Kotlin, il offre de nombreuses façons de créer des applications.

2. Caractéristiques clés

L'une des fonctionnalités les plus intéressantes de Micronaut est l'injection de dépendances (DI) au moment de la compilation. La plupart des frameworks utilisent des objets de réflexion et proxy pour injecter des dépendances lors de l'exécution. Micronaut collecte également des données pour l'injection de dépendances au stade de la compilation. Le résultat est des temps de démarrage des applications plus rapides et moins de consommation de mémoire.

Sa prochaine opportunité est un support de première classe pour la programmation réactive, à la fois pour les clients et pour les serveurs. Le choix d'une implémentation spécifique de l'approche réactive est laissé aux développeurs de solutions, et RxJava et Project Reactor sont pris en charge dès le départ.

De plus, Micronaut possède plusieurs fonctionnalités qui en font un excellent cadre de développement natif dans le cloud. Il prend en charge de nombreux mécanismes de découverte de services, tels qu'Eureka et Consul, et fonctionne également avec divers systèmes de suivi distribués tels que Zipkin et Jaeger.

En outre, il prend en charge la création de fonctions lambda AWS, ce qui facilite la création d'applications sans serveur.

3. Pour commencer

La façon la plus simple de commencer est d'utiliser SDKMAN:

> sdk install micronaut 1.0.0.M2

SDKMAN installe tous les fichiers binaires dont vous avez besoin pour créer, tester et déployer des applications Micronaut. De plus, vous recevrez une application console Micronaut CLI, vous permettant de démarrer facilement un nouveau projet.

Des artefacts binaires sont également disponibles sur Sonatype et sur Github.

Dans les sections suivantes, nous examinerons certaines des fonctionnalités de Micronaut.

4. Injection de dépendance (DI)

Comme mentionné précédemment, Micronaut gère l'injection de dépendances au moment de la compilation, ce qui le distingue de la plupart des conteneurs IoC.

Cependant, il prend entièrement en charge les annotations JSR-330, de sorte que la gestion des beans est similaire à d'autres frameworks IoC.

Pour injecter un bac dans notre code, nous utilisons @Inject :

 @Inject private EmployeeService service; 

L' @Inject fonctionne comme @Autowired et peut être utilisée avec des champs, des méthodes, des constructeurs et des paramètres.

Par défaut, tous les beans ont une portée - prototype. Nous pouvons rapidement créer des singletones en utilisant l'annotation @Singleton . Si plusieurs beans implémentent la même interface, nous pouvons utiliser l'annotation @Primary pour résoudre le conflit:

 @Primary @Singleton public class BlueCar implements Car {} 

L' @Requires peut être utilisée lorsque les beans sont facultatifs, ou pour effectuer une injection lorsque certaines conditions sont remplies.

À cet égard, il se comporte de la même manière que l'annotation 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. Créez un serveur HTTP

Maintenant, essayons de créer une application serveur HTTP simple. Pour commencer, nous utiliserons SDKMAN:

> mn create-app hello-world-server -build maven

Nous allons donc créer un nouveau projet Java avec Maven dans un répertoire appelé hello-world-server. À l'intérieur de ce répertoire, nous trouverons le code d'application principal, le fichier Maven POM et d'autres fichiers de projet.

L'application la plus simple ressemble à ceci:

 public class ServerApplication { public static void main(String[] args) { Micronaut.run(ServerApplication.class); } } 

5.1 Blocage de HttpRequest

L'application elle-même ne fait presque rien. Ajoutons un contrôleur avec deux gestionnaires. Les deux renverront un message d'accueil, mais l'un répondra aux demandes GET et l'autre répondra au 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; } } 

Du traducteur: votre humble serviteur est allé faire tout ce qui est dit dans cet article. Si, à ce stade, vous êtes sur le point de lancer l'application et de voir si cela fonctionne, n'oubliez pas d'activer le traitement des annotations dans Eclipse / IntelliJ IDEA.

5.2 E / S réactives

Par défaut, Micronaut implémente ces gestionnaires en tant qu'E / S de blocage traditionnelles. Cependant, nous pouvons rapidement implémenter des gestionnaires non bloquants en changeant simplement le type de retour en l'un des types non bloquants réactifs.

Par exemple, avec RxJava, nous pouvons utiliser Observable . De même, avec Reactor, nous pouvons retourner des types Mono ou Flux :

 @Get("/{name}") public Mono<String> greet(String name) { return Mono.just(greetingService.getGreeting() + name); } 

Du traducteur: pour cet exemple, vous aurez besoin de Project Reactor dans les dépendances Maven:

 <dependency> <groupId>io.projectreactor</groupId> <artifactId>reactor-core</artifactId> <version>3.1.8.RELEASE</version> </dependency> 

Les gestionnaires bloquants et non bloquants utilisent le serveur HTTP Netty.

En règle générale, les demandes sont traitées dans le pool de threads d'E / S principal, qui est créé au démarrage, ce qui les rend bloquées.

Cependant, si le gestionnaire renvoie des types de données non bloquants, Micronaut utilise la boucle d'événements Netty, rendant la demande entière non bloquante.

6. Créez un client HTTP

Maintenant, créons une application client pour les gestionnaires que nous venons de créer. Micronaut propose deux façons de créer des clients HTTP:

- déclaratif
- logiciel

6.1 Création déclarative d'un client HTTP

La première et la plus simple façon de créer est d'utiliser une approche déclarative:

 @Client("/greet") public interface GreetingClient { @Get("/{name}") String greet(String name); } 

Notez que nous n'avons pas implémenté une seule ligne de code pour appeler le service. Au lieu de cela, Micronaut comprend comment appeler un service à partir d'une signature de méthode et d'annotations.

Pour tester ce client, nous pouvons créer un test JUnit qui utilise l'API du serveur pour exécuter le serveur intégré:

 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"); } } 

Un traducteur: pour les lecteurs paresseux et curieux, il existe un projet prêt à l'emploi sur Github: github.com/jreznot/micronaut-introduction

6.2 Création par programme d'un client HTTP

Il existe une option pour créer un client HTTP traditionnel si vous avez besoin de plus de contrôle sur son comportement et son implémentation:

 @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"); } } 

Le client utilise RxJava par défaut, vous pouvez donc facilement utiliser les appels bloquants et non bloquants.

7. CLI Micronaut

Nous avons déjà vu comment l'utilitaire Micronaut CLI fonctionnait lorsque nous avons créé l'application.

Dans notre cas, il s'agissait d'une application distincte, mais cet utilitaire prend en charge plusieurs autres fonctionnalités.

7.1 Projets issus de plusieurs applications (Fédération)

Au Micronaut, la fédération est simplement un groupe d'applications individuelles développées en un seul projet. En utilisant la fédération, nous pouvons facilement les gérer tous ensemble et nous assurer qu'ils utilisent les mêmes paramètres.

Lorsque nous utilisons la CLI pour générer la fédération, l'utilitaire prend les mêmes arguments que la commande create-app. Elle créera le répertoire principal du projet et placera chaque application dans un sous-répertoire.

7.2 Caractéristiques

Lors de la création d'une application ou d'une fédération, nous pouvons choisir les fonctionnalités dont notre application a besoin. Cela vous permet d'utiliser l'ensemble minimal de dépendances dans le projet.

Nous -features les possibilités dans l'argument saw -features , en les séparant par des virgules.

Vous pouvez répertorier les fonctionnalités disponibles avec la commande suivante:

 > 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 

Du traducteur: eh bien, ici ne soyez pas surpris, l'équipe doit être gérée en dehors du répertoire du projet. Le répertoire du projet ne fonctionne pas, peut-être que dans la version .M3 ils l'ont corrigé. Elle est déjà partie.

7.3 Projets existants

Nous pouvons utiliser la CLI pour modifier des projets existants. Cela nous permet de créer des bacs, des clients, des contrôleurs, etc. Lorsque nous exécutons la commande «mn» dans le répertoire du projet, les commandes suivantes seront disponibles:

 > mn help | Command Name Command Description ----------------------------------------------- create-bean Creates a singleton bean create-client Creates a client interface create-controller Creates a controller and associated test create-job Creates a job with scheduled method 

8. Conclusion

Dans cette brève introduction à Micronaut, nous avons examiné à quel point il est facile de créer des serveurs et des clients HTTP bloquants et non bloquants. Nous avons également examiné quelques fonctionnalités CLI.

Ce n'est qu'un petit morceau du gâteau que Micronaut propose. Sous le capot, il prend en charge les fonctions sans serveur, la découverte de services, le suivi distribué, la surveillance et les métriques, les configurations distribuées et bien plus encore.

Cependant, comme de nombreuses fonctionnalités de Micronaut ont été empruntées à des frameworks existants tels que Grails et Spring, il offre des fonctionnalités uniques qui le distinguent des autres.