Einführung in Bootique

1. Übersicht

Bootique ist ein sehr leichtes Open-Source - JVM-Framework ohne Container, mit dem skalierbare Mikrodienste der nächsten Generation erstellt werden sollen. Es basiert auf einem eingebetteten Jetty-Server und unterstützt REST- Handler mit Jax-Rs vollständig .

In diesem Artikel wird gezeigt, wie Sie mit Bootique eine einfache Webanwendung erstellen .

2. Maven-Abhängigkeiten

Beginnen wir mit der Verwendung von Bootique, indem wir der pom.xml die folgende Abhängigkeit hinzufügen :

 io.bootique.jersey bootique-jersey compile   io.bootique bootique-test test  

Für Bootique müssen jedoch auch einige Stücklistenimporte („Bill of Material“) deklariert werden . Deshalb folgenAbschnitt muss in der pom.xml hinzugefügt werden :

   io.bootique.bom bootique-bom 0.23 pom import   

Die neueste Version von Bootique ist im Central Maven Repository verfügbar.

Um ein lauffähiges Glas zu bauen, verlässt sich Bootique auf das Maven-Shade-Plugin. Aus diesem Grund müssen wir auch die folgende Konfiguration hinzufügen:

   org.apache.maven.plugins maven-shade-plugin   

3. Starten einer Anwendung

Der einfachste Weg, eine Bootique- Anwendung zu starten, besteht darin, die exec () -Methode von Bootique über die Hauptmethode aufzurufen :

public class App { public static void main(String[] args) { Bootique.app(args) .autoLoadModules() .exec(); } }

Dadurch wird der eingebettete Server jedoch nicht gestartet. Sobald der obige Code ausgeführt wurde, sollte das folgende Protokoll angezeigt werden:

NAME com.baeldung.bootique.App OPTIONS -c yaml_location, --config=yaml_location Specifies YAML config location, which can be a file path or a URL. -h, --help Prints this message. -H, --help-config Prints information about application modules and their configuration options. -s, --server Starts Jetty server.

Dies sind nichts anderes als die verfügbaren Programmargumente, die im Lieferumfang von Bootique enthalten sind .

Die Namen sind selbsterklärend; Um den Server zu starten, müssen wir entweder das Argument –s oder –server übergeben , und der Server ist auf dem Standardport 8080 betriebsbereit .

4. Module

Bootique- Anwendungen werden mit Sammlungen von „Modulen“ erstellt. In Bootiques Begriff "Ein Modul ist eine Java-Bibliothek, die Code enthält" bedeutet, dass jeder Dienst als Modul behandelt wird. Es verwendet Google Guice für die Abhängigkeitsinjektion.

Um zu sehen, wie es funktioniert, erstellen wir eine Schnittstelle:

public interface HelloService { boolean save(); }

Jetzt müssen wir eine Implementierung erstellen:

public class HelloServiceImpl implements HelloService { @Override public boolean save() { return true; } }

Es gibt zwei Möglichkeiten, wie wir das Modul laden können. Die erste ist die Verwendung Guice ‚s - Modul - Schnittstelle und das andere ist durch die Verwendung Bootique ‘ s BQModuleProvider die auch bekannt ist als Selbstlade .

4.1. Guice-Modul

Hier können wir verwenden Guice ‚s - Modul - Schnittstelle zu binden Instanzen:

public class ModuleBinder implements Module { @Override public void configure(Binder binder) { binder .bind(HelloService.class) .to(HelloServiceImpl.class); } }

Sobald das Modul definiert ist, müssen wir dieses benutzerdefinierte Modul der Bootique- Instanz zuordnen :

Bootique .app(args) .module(module) .module(ModuleBinder.class) .autoLoadModules() .exec();

4.2. BQModuleProvider (automatisches Laden)

Hier müssen wir lediglich den zuvor erstellten Modulbinder mit BQModuleProvider definieren :

public class ModuleProvider implements BQModuleProvider { @Override public Module module() { return new ModuleBinder(); } }

Der Vorteil dieser Technik besteht darin, dass wir der Bootique- Instanz keine Modulinformationen zuordnen müssen .

Wir müssen nur eine Datei in /resources/META-INF/services/io.bootique.BQModuleProvider erstellen und den vollständigen Namen des ModuleProviders einschließlich des Paketnamens schreiben. Bootique kümmert sich um den Rest:

com.baeldung.bootique.module.ModuleProvider

Jetzt können wir die Annotation @Inject verwenden , um die Dienstinstanzen zur Laufzeit zu verwenden:

@Inject HelloService helloService;

Eine wichtige Sache, die hier zu beachten ist, ist, dass wir, da wir den eigenen DI-Mechanismus von Bootique verwenden, keine Guice @ ImplementedBy- Annotation zum Binden der Dienstinstanzen verwenden müssen .

5. REST-Endpunkt

Es ist einfach, REST-Endpunkte mithilfe der JAX-RS-API zu erstellen:

@Path("/") public class IndexController { @GET public String index() { return "Hello, baeldung!"; } @POST public String save() { return "Data Saved!"; } }

Um die Endpunkte der eigenen Jersey- Instanz von Bootique zuzuordnen , müssen wir ein JerseyModule definieren :

Module module = binder -> JerseyModule .extend(binder) .addResource(IndexController.class);

6. Konfiguration

Wir können integrierte oder benutzerdefinierte Konfigurationsinformationen in einer YAML-basierten Eigenschaftendatei bereitstellen.

Wenn wir beispielsweise die Anwendung an einem benutzerdefinierten Port starten und einen Standard-URI-Kontext 'Hallo' hinzufügen möchten, können wir die folgende YAML-Konfiguration verwenden:

jetty: context: /hello connector: port: 10001

Jetzt müssen wir beim Starten der Anwendung den Speicherort dieser Datei im Konfigurationsparameter angeben:

--config=/home/baeldung/bootique/config.yml

7. Protokollierung

Out-of-the-Box Bootique wird mit einem Bootique-Logback- Modul geliefert . Um dieses Modul zu verwenden, müssen wir der pom.xml die folgende Abhängigkeit hinzufügen :

 io.bootique.logback bootique-logback 

This module comes with a BootLogger interface with we can override to implement custom logging:

Bootique.app(args) .module(module) .module(ModuleBinder.class) .bootLogger( new BootLogger() { @Override public void trace( Supplier args ) { // ... } @Override public void stdout( String args ) { // ... } @Override public void stderr( String args, Throwable thw ) { // ... } @Override public void stderr( String args ) { // ... } }).autoLoadModules().exec();

Also, we can define logging configuration information in the config.yaml file:

log: level: warn appenders: - type: file logFormat: '%c{20}: %m%n' file: /path/to/logging/dir/logger.log

8. Testing

For testing, Bootique comes with the bootique-test module. There are two ways by which we can test a Bootique application.

The first approach is ‘foreground' approach which makes all test-cases run on the main test thread.

The other one is ‘background' approach which makes the test-cases run on an isolated thread pool.

The ‘foreground' environment can be initialized using BQTestFactory:

@Rule public BQTestFactory bqTestFactory = new BQTestFactory();

Die Hintergrundumgebung kann mit BQDaemonTestFactory initialisiert werden :

@Rule public BQDaemonTestFactory bqDaemonTestFactory = new BQDaemonTestFactory();

Sobald die Umgebungsfabrik bereit ist, können wir einfache Testfälle schreiben, um die Dienste zu testen:

@Test public void givenService_expectBoolen() { BQRuntime runtime = bqTestFactory .app("--server").autoLoadModules() .createRuntime(); HelloService service = runtime.getInstance( HelloService.class ); assertEquals( true, service.save() ); }

9. Fazit

In diesem Artikel haben wir gezeigt, wie eine Anwendung mit den Kernmodulen von Bootique erstellt wird . Es gibt mehrere andere Bootique- Module wie bootique-jooq , bootique-kotlin , bootique-job usw. Die vollständige Liste der verfügbaren Module finden Sie hier.

Wie immer ist der vollständige Quellcode auf GitHub verfügbar.