Inleiding tot Bootique

1. Overzicht

Bootique is een zeer lichtgewicht open-source zonder container JVM-framework gericht op het bouwen van schaalbare microservices van de volgende generatie. Het is gebouwd op de ingebouwde Jetty-server en ondersteunt volledig RUST UIT handlers met jax-rs.

In dit artikel laten we zien hoe u een eenvoudige webapp kunt bouwen met Bootique.

2. Maven afhankelijkheden

Laten we beginnen met gebruiken Bootique door de volgende afhankelijkheid toe te voegen aan het pom.xml:

 io.bootique.jersey bootique-jersey compileren io.bootique bootique-test 

Echter, Bootique vereist ook het aangeven van een paar BOM ("Bill of Material") invoer. Daarom volgen sectie moet worden toegevoegd in het pom.xml:

   io.bootique.bom bootique-bom 0.23 pom import 

De nieuwste versie van Bootique is beschikbaar in Central Maven Repository.

Om een ​​loopbare pot te bouwen, Bootique vertrouwt op maven-shad-plugin. Daarom moeten we ook onderstaande configuratie toevoegen:

   org.apache.maven.plugins maven-shad-plugin 

3. Een applicatie starten

De eenvoudigste manier om een Bootique applicatie is aanroepen Bootique‘S exec () methode van de belangrijkste methode:

openbare klasse App {openbare statische leegte hoofd (String [] args) {Bootique.app (args) .autoLoadModules () .exec (); }}

Hierdoor wordt de embedded server echter niet gestart. Zodra de bovenstaande code is uitgevoerd, zou het volgende logboek moeten worden weergegeven:

NAAM com.baeldung.bootique.App OPTIES -c yaml_location, --config = yaml_location Specificeert de YAML-configuratie-locatie, die een bestandspad of een URL kan zijn. -h, --help Drukt dit bericht af. -H, --help-config Drukt informatie af over toepassingsmodules en hun configuratie-opties. -s, --server Start Jetty-server.

Dit zijn niets anders dan de beschikbare programma-argumenten die vooraf worden meegeleverd Bootique.

De namen spreken voor zich; vandaar dat we een van beide moeten doorgeven om de server te starten –S of -server argument en de server zal actief zijn op het standaardpoort 8080.

4. Modules

Bootique applicaties worden gemaakt met verzamelingen van “modules”. In Bootique‘S term "Een module is een Java-bibliotheek die een code bevat" wat betekent dat het elke service als een module behandelt. Het gebruikt Google Guice voor afhankelijkheidsinjectie.

Laten we een interface maken om te zien hoe het werkt:

openbare interface HelloService {boolean save (); }

Nu moeten we een implementatie maken:

openbare klasse HelloServiceImpl implementeert HelloService {@Override openbare boolean save () {return true; }}

Er zijn twee manieren waarop we de module kunnen laden. De eerste is om te gebruiken Guice‘S Module interface, en de andere is door Bootique‘S BQModuleProvider die ook bekend staat als automatisch laden.

4.1. Guice-module

Hier kunnen we gebruik van maken Guice‘S Module interface om instanties te binden:

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

Zodra de module is gedefinieerd, moeten we deze aangepaste module toewijzen aan het Bootique voorbeeld:

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

4.2. BQModuleProvider (automatisch laden)

Hier hoeven we alleen maar de eerder gemaakte modulebinder te definiëren met BQModuleProvider:

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

Het voordeel van deze techniek is dat we geen module-informatie hoeven in kaart te brengen met de Bootique voorbeeld.

We hoeven alleen maar een bestand te maken in /resources/META-INF/services/io.bootique.BQModuleProvider en schrijf de volledige naam van het ModuleProvider inclusief pakketnaam en Bootique zorgt voor de rest:

com.baeldung.bootique.module.ModuleProvider

Nu kunnen we gebruiken @Injecteren annotatie om de service-exemplaren tijdens de runtime te gebruiken:

@Inject HelloService helloService;

Een belangrijk ding om op te merken is dat sinds we Bootique‘S eigen DI-mechanisme, we hoeven het niet te gebruiken Guice @ImplementedBy annotatie voor het binden van de service-exemplaren.

5. REST-eindpunt

Het is eenvoudig om REST-eindpunten te maken met behulp van de JAX-RS API:

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

Om de eindpunten in het Bootique‘Van henzelf Jersey we moeten bijvoorbeeld een JerseyModule:

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

6. Configuratie

We kunnen ingebouwde of aangepaste configuratie-informatie leveren in een op YAML gebaseerd eigenschappenbestand.

Als we bijvoorbeeld de toepassing op een aangepaste poort willen starten en een standaard URI-context ‘hallo 'willen toevoegen, kunnen we de volgende YAML-configuratie gebruiken:

steiger: context: / hallo connector: poort: 10001

Nu, tijdens het starten van de applicatie, moeten we de locatie van dit bestand opgeven in de configuratieparameter:

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

7. Logboekregistratie

Out-of-the-box Bootique wordt geleverd met een bootique-logback module. Om deze module te gebruiken, moeten we de volgende afhankelijkheid toevoegen in het pom.xml:

 io.bootique.logback bootique-logback 

Deze module wordt geleverd met een BootLogger interface waarmee we kunnen overschrijven om aangepaste logboekregistratie te implementeren:

Bootique.app (args) .module (module) .module (ModuleBinder.class) .bootLogger (nieuwe 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 ();

We kunnen ook configuratie-informatie voor logboekregistratie definiëren in het config.yaml het dossier:

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

8. Testen

Om uit te proberen, Bootique wordt geleverd met de bootique-test module. Er zijn twee manieren waarop we een Bootique toepassing.

De eerste benadering is 'voorgrond' benadering die ervoor zorgt dat alle testgevallen op de hoofdtestthread worden uitgevoerd.

De andere is 'achtergrond' benadering die ervoor zorgt dat de testcases worden uitgevoerd op een geïsoleerde threadpool.

De ‘voorgrond'-omgeving kan worden geïnitialiseerd met BQTestFactory:

@Rule openbare BQTestFactory bqTestFactory = nieuwe BQTestFactory ();

De ‘achtergrond'-omgeving kan worden geïnitialiseerd met BQDaemonTestFactory:

@Rule openbare BQDaemonTestFactory bqDaemonTestFactory = nieuwe BQDaemonTestFactory ();

Als de omgevingsfabriek klaar is, kunnen we eenvoudige testcases schrijven om de services te testen:

@Test openbare ongeldige gegevenService_expectBoolen () {BQRuntime runtime = bqTestFactory .app ("- server"). AutoLoadModules () .createRuntime (); HelloService service = runtime.getInstance (HelloService.class); assertEquals (true, service.save ()); }

9. Conclusie

In dit artikel hebben we laten zien hoe je een applicatie kunt bouwen met Bootique‘S kernmodules. Er zijn verschillende andere Bootique modules beschikbaar zoals bootique-jooq, bootique-kotlin, bootique-baan, etc. De volledige lijst met beschikbare modules is hier beschikbaar.

Zoals altijd is de volledige broncode beschikbaar op GitHub.