Creazione di un antipasto personalizzato con Spring Boot

1. Panoramica

Gli sviluppatori principali di Spring Boot forniscono i principianti per la maggior parte dei popolari progetti open source, ma non ci limitiamo a questi.

Possiamo anche scrivere i nostri antipasti personalizzati . Se disponiamo di una libreria interna da utilizzare all'interno della nostra organizzazione, sarebbe una buona pratica scrivere anche un antipasto se verrà utilizzata nel contesto di Spring Boot.

Questi antipasti consentono agli sviluppatori di evitare lunghe configurazioni e avviare rapidamente il loro sviluppo. Tuttavia, con molte cose che accadono in background, a volte diventa difficile capire come un'annotazione o semplicemente includendo una dipendenza nel pom.xml abiliti così tante funzionalità.

In questo articolo, demistificheremo la magia di Spring Boot per vedere cosa sta succedendo dietro le quinte. Quindi useremo questi concetti per creare un antipasto per la nostra libreria personalizzata.

2. Demistificazione dell'autoconfigurazione di Spring Boot

2.1. Classi di configurazione automatica

Quando Spring Boot si avvia, cerca un file denominato spring.factories nel classpath. Questo file si trova nella directory META-INF . Diamo un'occhiata a uno snippet di questo file dal progetto spring-boot-autoconfigure:

# Auto Configure org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\ org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\ org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\ org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

Questo file mappa un nome a diverse classi di configurazione che Spring Boot tenterà di eseguire. Quindi, come da questo frammento, Spring Boot proverà a eseguire tutte le classi di configurazione per RabbitMQ, Cassandra, MongoDB e Hibernate.

Se queste classi verranno effettivamente eseguite o meno dipenderà dalla presenza di classi dipendenti nel classpath. Ad esempio, se le classi per MongoDB si trovano nel classpath, MongoAutoConfiguration verrà eseguito e tutti i bean relativi a mongo verranno inizializzati.

Questa inizializzazione condizionale è abilitata dall'annotazione @ConditionalOnClass . Diamo un'occhiata allo snippet di codice dalla classe MongoAutoConfiguration per vedere il suo utilizzo:

@Configuration @ConditionalOnClass(MongoClient.class) @EnableConfigurationProperties(MongoProperties.class) @ConditionalOnMissingBean(type = "org.springframework.data.mongodb.MongoDbFactory") public class MongoAutoConfiguration { // configuration code }

Ora come, se MongoClient è disponibile nel classpath, questa classe di configurazione verrà eseguita popolando il bean factory Spring con un MongoClient inizializzato con le impostazioni di configurazione predefinite.

2.2. Proprietà personalizzate dal file application.properties

Spring Boot inizializza i bean utilizzando alcune impostazioni predefinite preconfigurate. Per sovrascrivere questi valori predefiniti, generalmente li dichiariamo nel file application.properties con un nome specifico. Queste proprietà vengono raccolte automaticamente dal contenitore Spring Boot.

Vediamo come funziona.

Nello snippet di codice per MongoAutoConfiguration , l' annotazione @EnableConfigurationProperties viene dichiarata con la classe MongoProperties che funge da contenitore per le proprietà personalizzate:

@ConfigurationProperties(prefix = "spring.data.mongodb") public class MongoProperties { private String host; // other fields with standard getters and setters }

Il prefisso più il nome del campo rendono i nomi delle proprietà nel file application.properties . Quindi, per impostare l' host per MongoDB, dobbiamo solo scrivere quanto segue nel file delle proprietà:

spring.data.mongodb.host = localhost

Allo stesso modo, i valori per altri campi nella classe possono essere impostati utilizzando il file delle proprietà.

3. Creazione di uno starter personalizzato

Sulla base dei concetti nella sezione 2, per creare uno starter personalizzato dobbiamo scrivere i seguenti componenti:

  1. Una classe di configurazione automatica per la nostra libreria insieme a una classe di proprietà per la configurazione personalizzata.
  2. Un pom di partenza per portare dentro le dipendenze della libreria e del progetto di autoconfigurazione.

A scopo dimostrativo, abbiamo creato una semplice libreria di messaggi di saluto che accoglierà un messaggio di saluto per diverse ore del giorno come parametri di configurazione e genererà il messaggio di saluto. Creeremo anche un'applicazione Spring Boot di esempio per dimostrare l'utilizzo dei nostri moduli di configurazione automatica e di avvio.

3.1. Il modulo di configurazione automatica

Chiameremo il nostro modulo di configurazione automatica greeter-spring-boot-autoconfigure . Questo modulo avrà due classi principali, ovvero GreeterProperties che abiliterà l'impostazione delle proprietà personalizzate tramite il file application.properties e GreeterAutoConfiguartion che creerà i bean per la libreria di Greeter .

Diamo un'occhiata al codice per entrambe le classi:

@ConfigurationProperties(prefix = "baeldung.greeter") public class GreeterProperties { private String userName; private String morningMessage; private String afternoonMessage; private String eveningMessage; private String nightMessage; // standard getters and setters }
@Configuration @ConditionalOnClass(Greeter.class) @EnableConfigurationProperties(GreeterProperties.class) public class GreeterAutoConfiguration { @Autowired private GreeterProperties greeterProperties; @Bean @ConditionalOnMissingBean public GreetingConfig greeterConfig() { String userName = greeterProperties.getUserName() == null ? System.getProperty("user.name") : greeterProperties.getUserName(); // .. GreetingConfig greetingConfig = new GreetingConfig(); greetingConfig.put(USER_NAME, userName); // ... return greetingConfig; } @Bean @ConditionalOnMissingBean public Greeter greeter(GreetingConfig greetingConfig) { return new Greeter(greetingConfig); } }

Abbiamo anche bisogno di aggiungere un file spring.factories nella directory src / main / resources / META-INF con il seguente contenuto:

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

All'avvio dell'applicazione, la classe GreeterAutoConfiguration verrà eseguita se la classe Greeter è presente nel classpath. Se eseguito correttamente, popolerà il contesto dell'applicazione Spring con i bean GreeterConfig e Greeter leggendo le proprietà tramite la classe GreeterProperties .

L' annotazione @ConditionalOnMissingBean garantirà che questi bean verranno creati solo se non esistono già. Ciò consente agli sviluppatori di sovrascrivere completamente i bean configurati automaticamente definendone uno in una delle classi @Configuration .

3.2. Creazione di pom.xml

Ora creiamo lo starter pom che porterà le dipendenze per il modulo di configurazione automatica e la libreria di benvenuto.

Secondo la convenzione di denominazione, tutti gli avviatori che non sono gestiti dal team principale di Spring Boot dovrebbero iniziare con il nome della libreria seguito dal suffisso -spring-boot-starter . Quindi chiameremo il nostro antipasto come saluto-primavera-avvio-avvio:

 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. Utilizzando lo Starter

Creiamo una app di esempio di avvio primaverile che utilizzerà lo starter. Nel pom.xml dobbiamo aggiungerlo come dipendenza:

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

Spring Boot configurerà automaticamente tutto e avremo un bean Greeter pronto per essere iniettato e utilizzato.

Cambiamo anche alcuni dei valori predefiniti di GreeterProperties definendoli nel file application.properties con il prefisso baeldung.greeter :

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

Infine, usiamo il bean Greeter nella nostra applicazione:

@SpringBootApplication public class GreeterSampleApplication implements CommandLineRunner { @Autowired private Greeter greeter; public static void main(String[] args) { SpringApplication.run(GreeterSampleApplication.class, args); } @Override public void run(String... args) throws Exception { String message = greeter.greet(); System.out.println(message); } }

4. Conclusione

In questo breve tutorial, ci siamo concentrati sul lancio di uno starter Spring Boot personalizzato e su come questi starter, insieme al meccanismo di autoconfigurazione, funzionano in background per eliminare molte configurazioni manuali.

Il codice sorgente completo per tutti i moduli che abbiamo creato in questo articolo può essere trovato su GitHub.