Proprietà con Spring e Spring Boot

Panoramica

Questo tutorial mostrerà come impostare e utilizzare le proprietà in Spring tramite la configurazione Java e @PropertySource.

Vedremo anche come funzionano le proprietà in Spring Boot.

Registra un file di proprietà tramite Annotazioni

Spring 3.1 introduce anche la nuova annotazione @PropertySource come un comodo meccanismo per aggiungere sorgenti di proprietà all’ambiente.,

Possiamo usare questa annotazione insieme all’annotazione @Configuration:

@Configuration@PropertySource("classpath:foo.properties")public class PropertiesWithJavaConfig { //...}

Un altro modo molto utile per registrare un nuovo file di proprietà è usare un segnaposto, che ci permette di selezionare dinamicamente il file giusto in fase di runtime:

@PropertySource({ "classpath:persistence-${envTarget:mysql}.properties"})...

2.1. Definizione di più posizioni delle proprietà

L’annotazione @PropertySource è ripetibile in base alle convenzioni Java 8., Pertanto, se stiamo usando Java 8 o superiore, possiamo usare questa annotazione per definire più posizioni delle proprietà:

Naturalmente, possiamo anche usare l’annotazione @PropertySources e specificare un array di @PropertySource. Funziona in qualsiasi versione Java supportata, non solo in Java 8 o superiore:

In entrambi i casi, vale la pena notare che in caso di collisione del nome di proprietà, l’ultima lettura di origine ha la precedenza.,

Uso/Iniezione di Proprietà

l’Iniezione di una proprietà con @Valore di annotazione è semplice:

@Value( "${jdbc.url}" )private String jdbcUrl;

Si può anche specificare un valore predefinito per la proprietà:

@Value( "${jdbc.url:aDefaultUrl}" )private String jdbcUrl;

Il nuovo PropertySourcesPlaceholderConfigurer aggiunto in Primavera 3.1 risolvere ${…} segnaposto all’interno di fagiolo definizione di valori di proprietà e @Valore annotazioni.,

Infine, possiamo ottenere il valore di una proprietà utilizzando l’API di ambiente:

@Autowiredprivate Environment env;...dataSource.setUrl(env.getProperty("jdbc.url"));

Proprietà Con Spring Boot

Prima di entrare in opzioni di configurazione più avanzate per le proprietà, passiamo un po ‘ di tempo a guardare il nuovo supporto delle proprietà in Spring Boot.

In generale, questo nuovo supporto comporta meno configurazione rispetto allo standard Spring, che è ovviamente uno degli obiettivi principali di Boot.

4.1. applicazione.,proprietà: il file di proprietà predefinito

Boot applica la sua tipica convenzione sull’approccio di configurazione ai file di proprietà. Ciò significa che possiamo semplicemente mettere un’applicazione.file di proprietà nella nostra directory src/main/resources, e verrà rilevato automaticamente. Possiamo quindi iniettare qualsiasi proprietà caricata da esso come normale.

Quindi, usando questo file predefinito, non dobbiamo registrare esplicitamente una PropertySource o persino fornire un percorso a un file di proprietà.,

Possiamo anche configurare un file diverso in fase di runtime se necessario, utilizzando una proprietà environment:

java -jar app.jar --spring.config.location=classpath:/another-location.properties

A partire da Spring Boot 2.3, possiamo anche specificare le posizioni dei caratteri jolly per i file di configurazione.

Ad esempio, possiamo impostare la molla.config.proprietà location per config/*/:

java -jar app.jar --spring.config.location=config/*/

In questo modo, Spring Boot cercherà i file di configurazione corrispondenti al modello di directory config/*/ al di fuori del nostro file jar. Questo è utile quando abbiamo più fonti di proprietà di configurazione.

Dalla versione 2.4.,0, Spring Boot supporta l’utilizzo di file di proprietà multi-documento, analogamente a YAML in base alla progettazione:

baeldung.customProperty=defaultValue#---baeldung.customProperty=overriddenValue

Si noti che per i file di proprietà, la notazione a tre trattini è preceduta da un carattere di commento (#).

4.2. File di proprietà specifiche dell’ambiente

Se abbiamo bisogno di indirizzare ambienti diversi, c’è un meccanismo incorporato per questo in avvio.

Possiamo semplicemente definire un ambiente applicativo.proprietà nella directory src / main / resources, quindi impostare un profilo Spring con lo stesso nome di ambiente.,

Ad esempio, se definiamo un ambiente di “staging”, ciò significa che dovremo definire un profilo di staging e quindi una staging dell’applicazione.proprieta.

Questo file env verrà caricato e avrà la precedenza sul file di proprietà predefinito. Si noti che il file predefinito verrà comunque caricato, è solo che quando c’è una collisione di proprietà, il file di proprietà specifico dell’ambiente ha la precedenza.

4.3. File di proprietà specifiche del test

Potremmo anche avere l’obbligo di utilizzare valori di proprietà diversi quando la nostra applicazione è in fase di test.,

Spring Boot gestisce questo per noi cercando nella nostra directory src/test/resources durante un’esecuzione di test. Ancora una volta, le proprietà predefinite saranno comunque iniettabili come normali ma verranno sovrascritte da queste se c’è una collisione.

4.4. L’annotazione @ TestPropertySource

Se abbiamo bisogno di un controllo più granulare sulle proprietà del test, possiamo usare l’annotazione @TestPropertySource.,

Questo ci permette di impostare le proprietà di test per uno specifico contesto di test, avendo la precedenza sulle proprietà predefinite sources:

Se non vogliamo usare un file, possiamo specificare nomi e valori direttamente:

Possiamo anche ottenere un effetto simile usando l’argomento properties dell’annotazione @SpringBootTest:

4.5. Proprietà gerarchiche

Se abbiamo proprietà raggruppate insieme, possiamo utilizzare l’annotazione @ConfigurationProperties, che mapperà queste gerarchie di proprietà in grafici di oggetti Java.,

Prendiamo alcune proprietà utilizzate per configurare una connessione al database:

database.url=jdbc:postgresql:/localhost:5432/instancedatabase.username=foodatabase.password=bar

E quindi usiamo l’annotazione per mapparle a un oggetto del database:

Spring Boot applica nuovamente la sua convenzione sull’approccio di configurazione, mappando automaticamente tra i nomi delle proprietà e i loro campi corrispondenti. Tutto ciò che dobbiamo fornire è il prefisso della proprietà.

Se vuoi approfondire le proprietà di configurazione, dai un’occhiata al nostro articolo approfondito.

4.6. Alternativa: File YAML

Spring supporta anche i file YAML.,

Tutte le stesse regole di denominazione si applicano per i file di proprietà specifici per test, specifici per l’ambiente e predefiniti. L’unica differenza è l’estensione del file e una dipendenza dalla libreria SnakeYAML sul nostro classpath.,

YAML è particolarmente buona per gerarchica struttura di stoccaggio; la proprietà seguente file:

database.url=jdbc:postgresql:/localhost:5432/instancedatabase.username=foodatabase.password=barsecret: foo

è sinonimo con il seguente file YAML:

database: url: jdbc:postgresql:/localhost:5432/instance username: foo password: barsecret: foo

e ‘ anche la pena ricordare che i file YAML non supportano l’ @PropertySource annotazione, quindi, se abbiamo bisogno di usare questa annotazione, sarebbe ci costringe all’utilizzo di un file di proprietà.

Un altro punto notevole è che nella versione 2.4.0 Spring Boot ha cambiato il modo in cui le proprietà vengono caricate da file YAML multi-documento., In precedenza, l’ordine in cui erano stati aggiunti era basato sull’ordine di attivazione del profilo. Con la nuova versione, tuttavia, il framework segue le stesse regole di ordinamento che abbiamo indicato in precedenza .file di proprietà; le proprietà dichiarate più in basso nel file sovrascriveranno semplicemente quelle più in alto.

Inoltre, in questa versione i profili non possono più essere attivati da documenti specifici del profilo, rendendo il risultato più chiaro e prevedibile.

4.7. Importazione di file di configurazione aggiuntivi

Prima della versione 2.4.,0, Avvio a molla consentito inclusi file di configurazione aggiuntivi utilizzando la molla.config.posizione e primavera.config.proprietà aggiuntive-posizione, ma avevano alcune limitazioni. Ad esempio, dovevano essere definiti prima di avviare l’applicazione (come proprietà di ambiente o sistema o utilizzando argomenti della riga di comando) come sono stati utilizzati all’inizio del processo.

Nella versione menzionata, possiamo usare la molla.config.importa proprietà all’interno dell’applicazione.proprietà o applicazione.file yml per includere facilmente file aggiuntivi., Questa proprietà supporta alcune caratteristiche interessanti:

• aggiunta di più file o directory
• i file possono essere caricati sia dal classpath o da una directory esterna
• che indica se il processo di avvio dovrebbe fallire se un file non viene trovato, o se è un file opzionale
• importazione di extensionless file

vediamo un valido esempio:

Nota: qui abbiamo formattato la struttura utilizzando le interruzioni di riga giusto per chiarezza.

Spring tratterà le importazioni come un nuovo documento inserito immediatamente sotto la dichiarazione di importazione.

4.8., Proprietà Argomenti della Riga di Comando

Oltre a utilizzare un file, si può passare direttamente le proprietà della riga di comando:

java -jar app.jar --property="value"

Si può fare anche tramite le proprietà di sistema, che sono fornite prima che il comando jar, piuttosto che dopo che:

java -Dproperty.name="value" -jar app.jar

4.9. Proprietà dalle variabili di ambiente

Spring Boot rileverà anche le variabili di ambiente, trattandole come proprietà:

export name=valuejava -jar app.jar

4.10., Randomizzazione dei valori delle proprietà

Se non vogliamo valori di proprietà deterministi, possiamo usare RandomValuePropertySource per randomizzare i valori delle proprietà:

random.number=${random.int}random.long=${random.long}random.uuid=${random.uuid}

4.11. Ulteriori tipi di sorgenti di proprietà

Spring Boot supporta una moltitudine di sorgenti di proprietà, implementando un ordinamento ben congegnato per consentire l’override sensibile. Vale la pena consultare la documentazione ufficiale, che va oltre lo scopo di questo articolo.,

Configurazione utilizzando fagioli grezzi-il PropertySourcesPlaceholderConfigurer

Oltre ai metodi convenienti di ottenere proprietà in primavera, possiamo anche definire e regiter il bean configurazione delle proprietà manualmente.

Lavorare con PropertySourcesPlaceholderConfigurer ci dà il pieno controllo sulla configurazione, con il rovescio della medaglia di essere più prolisso e la maggior parte del tempo, inutile.,

Vediamo come possiamo definire questo bean usando la configurazione Java:

Proprietà nei contesti padre-figlio

Questa domanda si ripresenta ancora e ancora: cosa succede quando la nostra applicazione web ha un contesto genitore e un contesto figlio? Il contesto genitore può avere alcune funzionalità e bean di base comuni, e quindi uno (o più) contesti figlio, forse contenenti bean specifici del servlet.

In tal caso, qual è il modo migliore per definire i file delle proprietà e includerli in questi contesti? E come recuperare al meglio queste proprietà dalla primavera?

Daremo una semplice ripartizione.,

Se il file è definito nel contesto Padre:

• @Il valore funziona nel contesto Figlio: SÌ

• @Il valore funziona nel contesto padre: SÌ

• ambiente.getProperty nel contesto figlio: SÌ

• ambiente.getProperty nel contesto Padre: SÌ

Se il file è definito nel contesto Figlio:

• @Il valore funziona nel contesto Figlio: SÌ

• @Il valore funziona nel contesto padre: NO

• ambiente.getProperty nel contesto figlio: SÌ

• ambiente.,getProperty nel contesto genitore: NO

Conclusione

Questo articolo ha mostrato diversi esempi di utilizzo di proprietà e file di proprietà in primavera.

Come sempre, l’intero codice che supporta l’articolo è disponibile su GitHub.