Introduction à Bootique

1. Vue d'ensemble

Bootique est un framework JVM open-source très léger sans conteneur destiné à créer des micro-services évolutifs de nouvelle génération. Il est construit sur le serveur Jetty intégré et prend entièrement en charge les gestionnaires REST avec jax-rs .

Dans cet article, nous montrerons comment créer une application Web simple à l'aide de Bootique .

2. Dépendances de Maven

Commençons par utiliser Bootique en ajoutant la dépendance suivante dans le pom.xml:

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

Cependant, Bootique exige également de déclarer quelques importations de nomenclatures («Bill of Material») . C'est pourquoi suivreLa section doit être ajoutée dans le pom.xml:

   io.bootique.bom bootique-bom 0.23 pom import   

La dernière version de Bootique est disponible dans le référentiel central de Maven.

Pour créer un fichier jar exécutable, Bootique s'appuie sur maven-shadow-plugin. C'est pourquoi nous devons également ajouter la configuration ci-dessous:

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

3. Démarrer une application

Le plus simple pour démarrer une Bootique application est d'invoquer Bootique de exec () méthode de la méthode principale:

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

Cependant, cela ne démarrera pas le serveur intégré. Une fois que le code ci-dessus est exécuté, le journal suivant doit être affiché:

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.

Ce ne sont rien d'autre que les arguments de programme disponibles pré-fournis avec Bootique .

Les noms sont explicites; par conséquent, pour démarrer le serveur, nous devons passer l' argument –s ou –server et le serveur sera opérationnel sur le port par défaut 8080 .

4. Modules

Les applications Bootique sont constituées de collections de «modules». Dans le terme de Bootique «Un module est une bibliothèque Java qui contient du code», ce qui signifie qu'il traite chaque service comme un module. Il utilise Google Guice pour l'injection de dépendances.

Pour voir comment cela fonctionne, créons une interface:

public interface HelloService { boolean save(); }

Maintenant, nous devons créer une implémentation:

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

Il existe deux manières de charger le module. La première consiste à utiliser Guice « s Module interface, et l'autre est à l'aide de Bootique » s BQModuleProvider qui est également connu sous le nom d' auto-chargement .

4.1. Module Guice

Ici, nous pouvons utiliser Guice de module interface pour les instances bind:

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

Une fois le module défini, nous devons mapper ce module personnalisé à l' instance Bootique :

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

4.2. BQModuleProvider (chargement automatique)

Ici, tout ce que nous devons faire est de définir le module-binder créé précédemment avec BQModuleProvider :

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

L'avantage de cette technique est que nous n'avons pas besoin de mapper les informations de module avec l' instance Bootique .

Nous avons juste besoin de créer un fichier dans /resources/META-INF/services/io.bootique.BQModuleProvider et d'écrire le nom complet du ModuleProvider avec le nom du package et Bootique se chargera du reste:

com.baeldung.bootique.module.ModuleProvider

Maintenant, nous pouvons utiliser l' annotation @Inject pour utiliser les instances de service au moment de l'exécution:

@Inject HelloService helloService;

Une chose importante à noter ici est que puisque nous utilisons le propre mécanisme DI de Bootique , nous n'avons pas besoin d'utiliser l' annotation Guice @ImplementedBy pour lier les instances de service.

5. Point de terminaison REST

Il est simple de créer des points de terminaison REST à l'aide de l'API JAX-RS:

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

Pour mapper les points de terminaison dans la propre instance Jersey de Bootique , nous devons définir un JerseyModule :

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

6. Configuration

Nous pouvons fournir des informations de configuration intégrées ou personnalisées dans un fichier de propriétés basé sur YAML.

Par exemple, si nous voulons démarrer l'application sur un port personnalisé et ajouter un contexte URI par défaut `` bonjour '', nous pouvons utiliser la configuration YAML suivante:

jetty: context: /hello connector: port: 10001

Maintenant, lors du démarrage de l'application, nous devons fournir l'emplacement de ce fichier dans le paramètre de configuration:

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

7. Journalisation

Out-of-the-box Bootique est livré avec un Bootique-logback module. Pour utiliser ce module, nous devons ajouter la dépendance suivante dans le pom.xml :

 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();

L'environnement 'background' peut être initialisé à l'aide de BQDaemonTestFactory :

@Rule public BQDaemonTestFactory bqDaemonTestFactory = new BQDaemonTestFactory();

Une fois la fabrique d'environnement prête, nous pouvons écrire des cas de test simples pour tester les services:

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

9. Conclusion

Dans cet article, nous avons montré comment créer une application à l'aide des modules de base de Bootique . Il existe plusieurs autres modules Bootique disponibles comme bootique-jooq , bootique-kotlin , bootique-job , etc. La liste complète des modules disponibles est disponible ici.

Comme toujours, le code source complet est disponible à l'adresse over sur GitHub.