Introduzione a Bootique

1. Panoramica

Bootique è un framework JVM open source senza container molto leggero volto a creare micro-servizi scalabili di nuova generazione. È costruito sul server Jetty incorporato e supporta completamente i gestori REST con jax-rs .

In questo articolo, mostreremo come creare una semplice applicazione web usando Bootique .

2. Dipendenze di Maven

Cominciamo a usare Bootique aggiungendo la seguente dipendenza nel pom.xml:

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

Tuttavia, Bootique richiede anche la dichiarazione di alcune importazioni BOM ("Bill of Material") . Ecco perché seguirela sezione deve essere aggiunta nel pom.xml:

   io.bootique.bom bootique-bom 0.23 pom import   

L'ultima versione di Bootique è disponibile in Central Maven Repository.

Per costruire un jar eseguibile, Bootique si affida a maven -shade-plugin. Ecco perché dobbiamo aggiungere anche la configurazione di seguito:

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

3. Avvio di un'applicazione

Il modo più semplice per iniziare una Bootique applicazione è quello di richiamare Bootique s' exec () metodo dal metodo principale:

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

Tuttavia, questo non avvierà il server incorporato. Una volta eseguito il codice precedente, dovrebbe essere visualizzato il seguente registro:

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.

Questi non sono altro che gli argomenti del programma disponibili che vengono pre-raggruppati con Bootique .

I nomi sono autoesplicativi; quindi, per avviare il server dobbiamo passare l' argomento –s o –server e il server sarà attivo e funzionante sulla porta predefinita 8080 .

4. Moduli

Le applicazioni Bootique sono realizzate con raccolte di "moduli". Nel termine Bootique "Un modulo è una libreria Java che contiene del codice", il che significa che tratta ogni servizio come un modulo. Utilizza Google Guice per Dependency Injection.

Per vedere come funziona, creiamo un'interfaccia:

public interface HelloService { boolean save(); }

Ora, dobbiamo creare un'implementazione:

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

Ci sono due modi in cui possiamo caricare il modulo. Il primo è quello di utilizzare Guice 's modulo di interfaccia, e l'altro è utilizzando Bootique ' s BQModuleProvider che è noto anche come auto-caricamento .

4.1. Modulo Guice

Qui, siamo in grado di utilizzare Guice s' Modulo interfaccia per le istanze di bind:

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

Una volta definito il modulo, dobbiamo mappare questo modulo personalizzato all'istanza Bootique :

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

4.2. BQModuleProvider (caricamento automatico)

Qui, tutto ciò che dobbiamo fare è definire il raccoglitore di moduli creato in precedenza con BQModuleProvider :

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

Il vantaggio di questa tecnica è che non è necessario mappare alcuna informazione sul modulo con l' istanza Bootique .

Dobbiamo solo creare un file in /resources/META-INF/services/io.bootique.BQModuleProvider e scrivere il nome completo di ModuleProvider incluso il nome del pacchetto e Bootique si occuperà del resto:

com.baeldung.bootique.module.ModuleProvider

Ora possiamo usare l' annotazione @Inject per utilizzare le istanze del servizio in fase di runtime:

@Inject HelloService helloService;

Una cosa importante da notare qui è che poiché stiamo usando il meccanismo DI di Bootique , non abbiamo bisogno di usare l' annotazione Guice @ImplementedBy per associare le istanze del servizio.

5. Endpoint REST

È semplice creare endpoint REST utilizzando l'API JAX-RS:

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

Per mappare i punti finali nella Bootique proprio 's Jersey esempio, abbiamo bisogno di definire un JerseyModule :

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

6. Configurazione

Possiamo fornire informazioni di configurazione integrate o personalizzate in un file di proprietà basato su YAML.

Ad esempio, se vogliamo avviare l'applicazione su una porta personalizzata e aggiungere un contesto URI predefinito "ciao", possiamo utilizzare la seguente configurazione YAML:

jetty: context: /hello connector: port: 10001

Ora, durante l'avvio dell'applicazione, dobbiamo fornire la posizione di questo file nel parametro di configurazione:

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

7. Registrazione

Out-of-the-box Bootique viene fornito con un Bootique-logback modulo. Per utilizzare questo modulo, dobbiamo aggiungere la seguente dipendenza nel 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'ambiente di "background" può essere inizializzato utilizzando BQDaemonTestFactory :

@Rule public BQDaemonTestFactory bqDaemonTestFactory = new BQDaemonTestFactory();

Una volta che la factory dell'ambiente è pronta, possiamo scrivere semplici casi di test per testare i servizi:

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

9. Conclusione

In questo articolo, abbiamo mostrato come creare un'applicazione utilizzando i moduli principali di Bootique . Ci sono molti altri moduli Bootique disponibili come bootique-jooq , bootique-kotlin , bootique-job , ecc. L'elenco completo dei moduli disponibili è disponibile qui.

Come sempre, il codice sorgente completo è disponibile su GitHub.