Een aangepaste starter maken met Spring Boot

1. Overzicht

De kernontwikkelaars van Spring Boot bieden starters voor de meeste populaire open source-projecten, maar we zijn niet beperkt tot deze.

We kunnen ook onze eigen starters op maat schrijven. Als we een interne bibliotheek hebben voor gebruik binnen onze organisatie, zou het een goede gewoonte zijn om er ook een starter voor te schrijven als deze in Spring Boot-context gaat worden gebruikt.

Deze starters stellen ontwikkelaars in staat om langdurige configuraties te vermijden en hun ontwikkeling snel op gang te brengen. Omdat er echter veel dingen op de achtergrond gebeuren, wordt het soms moeilijk om te begrijpen hoe een annotatie of gewoon een afhankelijkheid in de pom.xml maakt zoveel functies mogelijk.

In dit artikel zullen we de Spring Boot-magie demystificeren om te zien wat er achter de schermen gebeurt. Vervolgens zullen we deze concepten gebruiken om een starter te maken voor onze eigen aangepaste bibliotheek.

2. De autoconfiguratie van Spring Boot ontrafelen

2.1. Automatische configuratieklassen

Wanneer Spring Boot opstart, zoekt het naar een bestand met de naam lente.fabrieken in het klassenpad. Dit bestand bevindt zich in het META-INF directory. Laten we eens kijken naar een fragment van dit bestand uit het spring-boot-autoconfigure-project:

# Auto-configuratie org.springframework.boot.autoconfigure.EnableAutoConfiguration = \ org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration, \ org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration.mwork \ org.bootingframing. MongoAutoConfiguration, \ org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

Dit bestand wijst een naam toe aan verschillende configuratieklassen die Spring Boot zal proberen uit te voeren. Dus, volgens dit fragment, zal Spring Boot proberen om alle configuratieklassen voor RabbitMQ, Cassandra, MongoDB en Hibernate uit te voeren.

Of deze klassen daadwerkelijk worden uitgevoerd, hangt af van de aanwezigheid van afhankelijke klassen op het klassenpad. Als de klassen voor MongoDB bijvoorbeeld worden gevonden op het klassenpad, MongoAutoConfiguration wordt uitgevoerd en alle mongo-gerelateerde bonen worden geïnitialiseerd.

Deze voorwaardelijke initialisatie wordt mogelijk gemaakt door de @ConditionalOnClass annotatie. Laten we eens kijken naar het codefragment van MongoAutoConfiguration klasse om het gebruik ervan te zien:

@Configuration @ConditionalOnClass (MongoClient.class) @EnableConfigurationProperties (MongoProperties.class) @ConditionalOnMissingBean (type = "org.springframework.data.mongodb.MongoDbFactory") openbare klasse MongoAutoConfiguration {// configuratiecode}

Nu hoe - als het MongoClient is beschikbaar in het klassenpad - deze configuratieklasse wordt uitgevoerd en de Spring bean-fabriek gevuld met een MongoClient geïnitialiseerd met standaard configuratie-instellingen.

**2.2. Aangepaste eigenschappen van het application.properties het dossier**

Spring Boot initialiseert de bonen met behulp van enkele vooraf geconfigureerde standaardinstellingen. Om deze standaardwaarden te negeren, declareren we ze over het algemeen in de application.properties bestand met een specifieke naam. Deze eigendommen worden automatisch opgepikt door de Spring Boot-container.

Laten we eens kijken hoe dat werkt.

In het codefragment voor MongoAutoConfiguration, @EnableConfigurationProperties annotatie wordt gedeclareerd met de MongoProperties klasse die fungeert als de container voor aangepaste eigenschappen:

@ConfigurationProperties (prefix = "spring.data.mongodb") openbare klasse MongoProperties {privé String-host; // andere velden met standaard getters en setters}

Het voorvoegsel plus de veldnaam vormen de namen van de eigenschappen in het application.properties het dossier. Dus om de gastheer voor MongoDB hoeven we alleen het volgende in het eigenschappenbestand te schrijven:

spring.data.mongodb.host = localhost

Evenzo kunnen waarden voor andere velden in de klasse worden ingesteld met behulp van het eigenschappenbestand.

3. Een aangepaste starter maken

Op basis van de concepten in sectie 2, moeten we de volgende componenten schrijven om een aangepaste starter te maken:

Een auto-configuratieklasse voor onze bibliotheek samen met een eigenschappenklasse voor aangepaste configuratie.
Een starter pom om de afhankelijkheden van de bibliotheek en het autoconfigure-project binnen te halen.

Ter demonstratie hebben we een eenvoudige begroetingsbibliotheek gemaakt die een begroetingsbericht voor verschillende tijdstippen van de dag als configuratieparameters inneemt en het begroetingsbericht uitvoert. We zullen ook een voorbeeld van een Spring Boot-applicatie maken om het gebruik van onze autoconfiguratie- en startermodules te demonstreren.

3.1. De Autoconfigure-module

We noemen onze automatische configuratiemodule greeter-spring-boot-autoconfigure. Deze module heeft twee hoofdklassen, d.w.z. GreeterProperties waarmee u aangepaste eigenschappen kunt instellen via application.properties bestand en GreeterAutoConfiguartion waar de bonen voor zullen worden gemaakt begroeter bibliotheek.

Laten we de code voor beide klassen bekijken:

@ConfigurationProperties (prefix = "baeldung.greeter") openbare klasse GreeterProperties {private String gebruikersnaam; private String morningMessage; privé String afternoonMessage; privé String eveningMessage; privé String nightMessage; // standaard getters en setters}

@Configuration @ConditionalOnClass (Greeter.class) @EnableConfigurationProperties (GreeterProperties.class) openbare klasse GreeterAutoConfiguration {@Autowired privé GreeterProperties greeterProperties; @Bean @ConditionalOnMissingBean openbare GreetingConfig greeterConfig () {String userName = greeterProperties.getUserName () == null? System.getProperty ("gebruiker.naam"): greeterProperties.getUserName (); // .. GreetingConfig greetingConfig = nieuwe GreetingConfig (); greetingConfig.put (USER_NAME, gebruikersnaam); // ... return greetingConfig; } @Bean @ConditionalOnMissingBean openbare Greeter greeter (GreetingConfig greetingConfig) {retourneer nieuwe Greeter (greetingConfig); }}

We moeten ook een lente.fabrieken bestand in het src / main / resources / META-INF directory met de volgende inhoud:

org.springframework.boot.autoconfigure.EnableAutoConfiguration = \ com.baeldung.greeter.autoconfigure.GreeterAutoConfiguration

Bij het opstarten van de toepassing, het GreeterAutoConfiguration class wordt uitgevoerd als de class Greeter is aanwezig in het klassenpad. Als het met succes wordt uitgevoerd, wordt de Spring-toepassingscontext gevuld met GreeterConfig en Greeter bonen door de eigenschappen te lezen via GreeterProperties klasse.

De @ConditionalOnMissingBean annotatie zorgt ervoor dat deze bonen alleen worden gemaakt als ze nog niet bestaan. Hierdoor kunnen ontwikkelaars de automatisch geconfigureerde bonen volledig negeren door hun eigen bonen te definiëren in een van de @Configuratie klassen.

3.2. Creëren pom.xml

Laten we nu de starter maken pom die de afhankelijkheden voor de auto-configuratiemodule en de begroetingsbibliotheek zal binnenhalen.

Volgens de naamgevingsconventie moeten alle starters die niet worden beheerd door het kernteam van Spring Boot beginnen met de bibliotheeknaam gevolgd door het achtervoegsel -veer-boot-starter. Dus we zullen onze starter zo noemen greeter-spring-boot-starter:

 4.0.0 com.baeldung greeter-spring-boot-starter 0.0.1-SNAPSHOT UTF-8 0.0.1-SNAPSHOT 2.2.6.RELEASE org.springframework.boot spring-boot-starter $ {spring-boot.version} com .baeldung greeter-spring-boot-autoconfigure $ {project.version} com.baeldung greeter $ {greeter.version}

3.3. Met behulp van de starter

Laten we creëren greeter-spring-boot-sample-app die de starter zal gebruiken. In de pom.xml we moeten het als afhankelijkheid toevoegen:

 com.baeldung greeter-spring-boot-starter $ {greeter-starter.version}

Spring Boot configureert alles automatisch en we hebben een Greeter boon klaar om te worden geïnjecteerd en gebruikt.

Laten we ook enkele van de standaardwaarden van het GreeterProperties door ze te definiëren in het application.properties bestand met de baeldung.greeter voorvoegsel:

baeldung.greeter.userName = Baeldung baeldung.greeter.afternoonMessage = Woha \ Afternoon

Laten we tot slot de Greeter boon in onze applicatie:

@SpringBootApplication openbare klasse GreeterSampleApplication implementeert CommandLineRunner {@Autowired privé Greeter-greeter; openbare statische leegte hoofd (String [] args) {SpringApplication.run (GreeterSampleApplication.class, args); } @Override public void run (String ... args) gooit Uitzondering {String message = greeter.greet (); System.out.println (bericht); }}

4. Conclusie

In deze korte tutorial hebben we ons gericht op het uitrollen van een aangepaste Spring Boot-starter en op hoe deze starters, samen met het automatische configuratiemechanisme, op de achtergrond werken om veel handmatige configuratie te elimineren.

De volledige broncode voor alle modules die we in dit artikel hebben gemaakt, is te vinden op GitHub.

streamalism.org