Primavera - Iniezione di collezioni

1. Introduzione

In questo tutorial, mostreremo come inserire raccolte Java utilizzando il framework Spring .

In poche parole, mostreremo esempi con le interfacce List, Map, Set collection.

2. Elenco con @Autowired

Creiamo un bean di esempio:

public class CollectionsBean { @Autowired private List nameList; public void printNameList() { System.out.println(nameList); } }

Qui, abbiamo dichiarato la proprietà nameList per contenere un elenco di valori String .

In questo esempio, usiamo l' inserimento di campi per nameList . Pertanto, inseriamo l' annotazione @Autowired .

Per ulteriori informazioni sull'inserimento delle dipendenze o sui diversi modi per implementarlo, consulta questa guida.

Successivamente, registriamo CollectionsBean nella classe di configurazione della configurazione:

@Configuration public class CollectionConfig { @Bean public CollectionsBean getCollectionsBean() { return new CollectionsBean(); } @Bean public List nameList() { return Arrays.asList("John", "Adam", "Harry"); } }

Oltre a registrare il CollectionsBean , inseriamo anche un nuovo elenco inizializzandolo e restituendolo esplicitamente come configurazione @Bean separata .

Ora possiamo testare i risultati:

ApplicationContext context = new AnnotationConfigApplicationContext(CollectionConfig.class); CollectionsBean collectionsBean = context.getBean( CollectionsBean.class); collectionsBean.printNameList();

L'output del metodo printNameList ():

[John, Adam, Harry]

3. Impostare con l'iniezione del costruttore

Per impostare lo stesso esempio con la raccolta Set , modifichiamo la classe CollectionsBean :

public class CollectionsBean { private Set nameSet; public CollectionsBean(Set strings) { this.nameSet = strings; } public void printNameSet() { System.out.println(nameSet); } }

Questa volta vogliamo usare un'iniezione del costruttore per inizializzare la proprietà nameSet . Ciò richiede anche modifiche nella classe di configurazione:

@Bean public CollectionsBean getCollectionsBean() { return new CollectionsBean(new HashSet(Arrays.asList("John", "Adam", "Harry"))); }

4. Mappa con iniezione di Setter

Seguendo la stessa logica, aggiungiamo il campo nameMap per dimostrare l'iniezione della mappa:

public class CollectionsBean { private Map nameMap; @Autowired public void setNameMap(Map nameMap) { this.nameMap = nameMap; } public void printNameMap() { System.out.println(nameMap); } }

Questa volta abbiamo un metodo setter per utilizzare un'iniezione di dipendenza setter . Abbiamo anche bisogno di aggiungere il codice di inizializzazione della mappa nella classe di configurazione:

@Bean public Map nameMap(){ Map nameMap = new HashMap(); nameMap.put(1, "John"); nameMap.put(2, "Adam"); nameMap.put(3, "Harry"); return nameMap; }

I risultati dopo aver richiamato il metodo printNameMap () :

{1=John, 2=Adam, 3=Harry}

5. Iniettare Bean References

Diamo un'occhiata a un esempio in cui inseriamo riferimenti a bean come elementi della raccolta.

Per prima cosa, creiamo il fagiolo:

public class BaeldungBean { private String name; // constructor }

E aggiungi un elenco di BaeldungBean come proprietà alla classe CollectionsBean :

public class CollectionsBean { @Autowired(required = false) private List beanList; public void printBeanList() { System.out.println(beanList); } }

Successivamente, aggiungiamo i metodi della factory di configurazione Java per ogni elemento BaeldungBean :

@Configuration public class CollectionConfig { @Bean public BaeldungBean getElement() { return new BaeldungBean("John"); } @Bean public BaeldungBean getAnotherElement() { return new BaeldungBean("Adam"); } @Bean public BaeldungBean getOneMoreElement() { return new BaeldungBean("Harry"); } // other factory methods }

Il contenitore Spring inietta i singoli fagioli del tipo BaeldungBean in una raccolta.

Per verificarlo, invochiamo il metodo collectionsBean.printBeanList () . L'output mostra i nomi dei bean come elementi della lista:

[John, Harry, Adam]

Ora, prendiamo in considerazione uno scenario in cui non c'è un BaeldungBean . Se non c'è un BaeldungBean registrato nel contesto dell'applicazione, Spring genererà un'eccezione perché manca la dipendenza richiesta.

Possiamo usare @Autowired (required = false) per contrassegnare la dipendenza come facoltativa. Invece di lanciare un'eccezione, beanList non verrà inizializzato e il suo valore rimarrà nullo .

Se abbiamo bisogno di una lista vuota invece di null, possiamo inizializzare beanList con una nuova ArrayList:

@Autowired(required = false) private List beanList = new ArrayList();

5.1. Utilizzo di @Order per ordinare i fagioli

Possiamo specificare l'ordine dei fagioli durante l'iniezione nella raccolta .

A tale scopo, utilizziamo l' annotazione @Order e specifichiamo l'indice:

@Configuration public class CollectionConfig { @Bean @Order(2) public BaeldungBean getElement() { return new BaeldungBean("John"); } @Bean @Order(3) public BaeldungBean getAnotherElement() { return new BaeldungBean("Adam"); } @Bean @Order(1) public BaeldungBean getOneMoreElement() { return new BaeldungBean("Harry"); } }

Il contenitore primaverile inietterà prima il fagiolo con il nome "Harry" , poiché ha il valore di ordine più basso.

It will then inject the “John”, and finally, the “Adam” bean:

[Harry, John, Adam]

Learn more about @Order in this guide.

5.2. Using @Qualifier to Select Beans

We can use the @Qualifier to select the beans to be injected into the specific collection that matches the @Qualifier name.

Here's how we use it for the injection point:

@Autowired @Qualifier("CollectionsBean") private List beanList;

Then, we mark with the same @Qualifier the beans that we want to inject into the List:

@Configuration public class CollectionConfig { @Bean @Qualifier("CollectionsBean") public BaeldungBean getElement() { return new BaeldungBean("John"); } @Bean public BaeldungBean getAnotherElement() { return new BaeldungBean("Adam"); } @Bean public BaeldungBean getOneMoreElement() { return new BaeldungBean("Harry"); } // other factory methods }

In this example, we specify that the bean with the name “John” will be injected into the List named “CollectionsBean”. The results we test here:

ApplicationContext context = new AnnotationConfigApplicationContext(CollectionConfig.class); CollectionsBean collectionsBean = context.getBean(CollectionsBean.class); collectionsBean.printBeanList();

Dall'output, vediamo che la nostra collezione ha un solo elemento:

[John]

6. Impostazione di un elenco vuoto come valore predefinito

Possiamo impostare il valore predefinito per una proprietà List inserita come un elenco vuoto utilizzando il metodo statico Collections.emptyList () :

public class CollectionsBean { @Value("${names.list:}#{T(java.util.Collections).emptyList()}") private List nameListWithDefaultValue; public void printNameListWithDefaults() { System.out.println(nameListWithDefaultValue); } }

Se eseguiamo questo con la chiave "names.list" non inizializzata tramite il file delle proprietà:

collectionsBean.printNameListWithDefaults();

Otterremo un elenco vuoto come output:

[ ]

7. Riepilogo

Con questa guida abbiamo imparato come inserire diversi tipi di raccolte Java utilizzando il framework Spring.

Abbiamo anche esaminato l'iniezione con i tipi di riferimento e come selezionarli o ordinarli all'interno della collezione.

Come al solito, il codice completo è disponibile nel progetto GitHub.