Einführung in das Micronaut Framework

1. Was ist Micronaut?

Micronaut ist ein JVM-Framework zum Erstellen leichter modularer Anwendungen. Es wurde von OCI entwickelt, der gleichen Firma, die Grails uns gegeben hat. Micronaut ist ein modernes Framework, mit dem sich schnell und einfach Microservice-Anwendungen erstellen lassen.

Micronaut enthält Funktionen, die bestehenden Frameworks wie Spring ähneln, implementiert jedoch gleichzeitig einige neue Ideen, die seine Markenzeichen sind. Zusammen mit der Unterstützung von Java, Groovy und Kotlin bietet es viele Möglichkeiten, Anwendungen zu erstellen.

2. Hauptmerkmale

Eine der aufregendsten Funktionen von Micronaut ist die Abhängigkeitsinjektion (DI) zur Kompilierungszeit. Die meisten Frameworks verwenden Reflection- und Proxy-Objekte, um Abhängigkeiten zur Laufzeit einzufügen. Micronaut sammelt auch Daten für die Abhängigkeitsinjektion in der Kompilierungsphase. Das Ergebnis sind schnellere Startzeiten der Anwendung und weniger Speicherverbrauch.

Seine nächste Chance ist erstklassiger Support für reaktive Programmierung, sowohl für Clients als auch für Server. Die Wahl einer bestimmten Implementierung des reaktiven Ansatzes bleibt den Lösungsentwicklern überlassen, und RxJava und Project Reactor werden sofort unterstützt.

Darüber hinaus verfügt Micronaut über mehrere Funktionen, die es zu einem großartigen Cloud-nativen Entwicklungsframework machen. Es unterstützt viele Service Discovery-Mechanismen wie Eureka und Consul und funktioniert auch mit verschiedenen verteilten Tracing-Systemen wie Zipkin und Jaeger.

Darüber hinaus bietet es Unterstützung für die Erstellung von Lambda-AWS-Funktionen, sodass auf einfache Weise Anwendungen ohne Server erstellt werden können.

3. Erste Schritte

Der einfachste Weg, um loszulegen, ist die Verwendung von SDKMAN:

> sdk install micronaut 1.0.0.M2

SDKMAN installiert alle Binärdateien, die Sie zum Erstellen, Testen und Bereitstellen von Micronaut-Anwendungen benötigen. Darüber hinaus erhalten Sie eine Konsolenanwendung Micronaut CLI, mit der Sie problemlos ein neues Projekt starten können.

Binäre Artefakte sind auch auf Sonatype und Github verfügbar.

In den folgenden Abschnitten werden einige Funktionen von Micronaut vorgestellt.

4. Abhängigkeitsinjektion (DI)

Wie bereits erwähnt, übernimmt Micronaut die Abhängigkeitsinjektion zur Kompilierungszeit, wodurch es sich von den meisten IoC-Containern unterscheidet.

JSR-330-Annotationen werden jedoch vollständig unterstützt, sodass die Bean-Behandlung anderen IoC-Frameworks ähnelt.

Um einen Bin in unseren Code @Inject , verwenden wir @Inject :

 @Inject private EmployeeService service; 

Die @Inject funktioniert genau wie @Autowired und kann mit Feldern, Methoden, Konstruktoren und Parametern verwendet werden.

Standardmäßig haben alle Beans einen Scope-Prototyp. Mit der Annotation @Singleton können wir schnell Singletones @Singleton . Wenn mehrere Beans dieselbe Schnittstelle implementieren, können wir die Annotation @Primary , um den Konflikt zu lösen:

 @Primary @Singleton public class BlueCar implements Car {} 

Die @Requires kann verwendet werden, wenn Beans optional sind, oder um eine Injektion durchzuführen, wenn bestimmte Bedingungen erfüllt sind.

In dieser Hinsicht verhält es sich genauso wie die Spring Boot-Annotation - @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. Erstellen Sie einen HTTP-Server

Versuchen wir nun, eine einfache HTTP-Serveranwendung zu erstellen. Zu Beginn verwenden wir SDKMAN:

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

Also werden wir mit Maven ein neues Java-Projekt in einem Verzeichnis namens hello-world-server erstellen. In diesem Verzeichnis finden wir den Hauptanwendungscode, die Maven POM-Datei und andere Projektdateien.

Die einfachste Anwendung sieht folgendermaßen aus:

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

5.1 HttpRequest blockieren

Die Anwendung selbst macht fast nichts. Fügen wir einen Controller mit zwei Handlern hinzu. Beide geben eine Begrüßung zurück, aber einer antwortet auf GET-Anfragen und der andere auf 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; } } 

Vom Übersetzer: Ihr bescheidener Diener hat alles getan, was in diesem Artikel gesagt wird. Wenn Sie zu diesem Zeitpunkt die Anwendung starten und prüfen möchten, ob sie funktioniert, vergessen Sie nicht, die Anmerkungsverarbeitung in Eclipse / IntelliJ IDEA zu aktivieren.

5.2 Reaktives IO

Standardmäßig implementiert Micronaut diese Handler als herkömmliche blockierende E / A. Wir können jedoch nicht blockierende Handler schnell implementieren, indem wir einfach den Rückgabetyp in einen der reaktiven nicht blockierenden Typen ändern.

Mit RxJava können wir beispielsweise Observable . In ähnlicher Weise können wir mit Reactor Mono oder Flux Typen zurückgeben:

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

Vom Übersetzer: Für dieses Beispiel benötigen Sie Project Reactor in den Maven-Abhängigkeiten:

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

Sowohl blockierende als auch nicht blockierende Handler verwenden den Netty HTTP-Server.

In der Regel werden Anforderungen im Haupt-E / A-Thread-Pool verarbeitet, der beim Start erstellt wird, wodurch sie blockiert werden.

Wenn der Handler jedoch nicht blockierende Datentypen zurückgibt, verwendet Micronaut die Netty-Ereignisschleife, wodurch die gesamte Anforderung nicht blockiert wird.

6. Erstellen Sie einen HTTP-Client

Jetzt erstellen wir eine Clientanwendung für die soeben erstellten Handler. Micronaut bietet zwei Möglichkeiten zum Erstellen von HTTP-Clients:

- deklarativ
- Software

6.1 Deklarative Erstellung eines HTTP-Clients

Der erste und einfachste Weg zum Erstellen ist die Verwendung eines deklarativen Ansatzes:

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

Beachten Sie, dass wir keine einzige Codezeile zum Aufrufen des Dienstes implementiert haben. Stattdessen versteht Micronaut das Aufrufen eines Dienstes über eine Methodensignatur und Anmerkungen.

Um diesen Client zu testen, können wir einen JUnit-Test erstellen, der die Server-API zum Ausführen des eingebetteten Servers verwendet:

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

Von einem Übersetzer: Für faule, neugierige Leser gibt es auf Github ein fertiges Projekt: github.com/jreznot/micronaut-introduction

6.2 Programmgesteuertes Erstellen eines HTTP-Clients

Es gibt eine Option zum Erstellen eines herkömmlichen HTTP-Clients, wenn Sie mehr Kontrolle über dessen Verhalten und Implementierung benötigen:

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

Der Client verwendet standardmäßig RxJava, sodass Sie blockierende und nicht blockierende Anrufe problemlos verwenden können.

7. Micronaut CLI

Wir haben bereits gesehen, wie das Micronaut CLI-Dienstprogramm funktioniert, als wir die Anwendung erstellt haben.

In unserem Fall war es eine separate Anwendung, aber dieses Dienstprogramm unterstützt mehrere andere Funktionen.

7.1 Projekte aus mehreren Anwendungen (Federation)

In Micronaut ist der Verband einfach eine Gruppe einzelner Anwendungen, die in einem einzigen Projekt entwickelt werden. Mit dem Verbund können wir alle problemlos zusammen verwalten und sicherstellen, dass sie dieselben Einstellungen verwenden.

Wenn wir die CLI zum Generieren eines Verbunds verwenden, verwendet das Dienstprogramm dieselben Argumente wie der Befehl create-app. Sie erstellt das Hauptverzeichnis des Projekts und platziert jede Anwendung in einem Unterverzeichnis.

7.2 Funktionen

Beim Erstellen einer Anwendung oder eines Verbunds können wir auswählen, welche Funktionen unsere Anwendung benötigt. Auf diese Weise können Sie den Mindestsatz an Abhängigkeiten im Projekt verwenden.

Wir geben die Möglichkeiten im Argument saw -features und trennen sie durch Kommas.

Sie können verfügbare Funktionen mit dem folgenden Befehl auflisten:

 > 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 

Vom Übersetzer: Nun, hier wundern Sie sich nicht, das Team muss außerhalb des Projektverzeichnisses geführt werden. Das Projektverzeichnis funktioniert nicht, möglicherweise wurde es in der .M3-Version behoben. Sie ist schon gegangen.

7.3 Bestehende Projekte

Wir können die CLI verwenden, um vorhandene Projekte zu ändern. Auf diese Weise können wir Bins, Clients, Controller usw. erstellen. Wenn wir den Befehl "mn" im Projektverzeichnis ausführen, sind die folgenden Befehle verfügbar:

 > 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. Fazit

In dieser kurzen Einführung in Micronaut haben wir untersucht, wie einfach es ist, blockierende und nicht blockierende HTTP-Server und -Clients zu erstellen. Wir haben uns auch einige CLI-Funktionen angesehen.

Dies ist nur ein kleiner Teil des Kuchens, den Micronaut anbietet. Unter der Haube bietet es Unterstützung für Funktionen ohne Server, Serviceerkennung, verteilte Ablaufverfolgung, Überwachung und Metriken, verteilte Konfigurationen und vieles mehr.

Während viele der Funktionen von Micronaut aus vorhandenen Frameworks wie Grails und Spring übernommen wurden, bietet es einzigartige Funktionen, die es von anderen unterscheiden.