Spring - Injizieren von Sammlungen

Frühjahrsspritzende Kollektionen

1. Einführung

In diesem Tutorial zeigen wir, wie maninject Java collections using the Spring framework macht.

Einfach ausgedrückt, zeigen wir Beispiele mit den Sammlungsschnittstellen vonList, Map, Set.

**2. List mit@Autowired**

Erstellen wir eine Beispielbohne:

public class CollectionsBean {

    @Autowired
    private List nameList;

    public void printNameList() {
        System.out.println(nameList);
    }
}

Hier haben wir die EigenschaftnameListo deklariert, dass sieList vonString Werten enthält.

In this example, we use field injection for nameList. Therefore, we put the @Autowired annotation.

Weitere Informationen zur Abhängigkeitsinjektion oder zu verschiedenen Implementierungsmethoden finden Sie inguide.

Danach registrieren wirCollectionsBean in der Konfigurations-Setup-Klasse:

@Configuration
public class CollectionConfig {

    @Bean
    public CollectionsBean getCollectionsBean() {
        return new CollectionsBean();
    }

    @Bean
    public List nameList() {
        return Arrays.asList("John", "Adam", "Harry");
    }
}

Neben der Registrierung derCollectionsBean fügen wir auch eine neue Liste ein, indem wir sie explizit initialisieren und als separate@Bean-Konfiguration zurückgeben.

Jetzt können wir die Ergebnisse testen:

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

Die Ausgabe der printNameList () -Methode:

[John, Adam, Harry]

**3. Set mit Konstruktorinjektion**

Um dasselbe Beispiel mit derSet-Sammlung einzurichten, ändern wir dieCollectionsBean -Skala:

public class CollectionsBean {

    private Set nameSet;

    public CollectionsBean(Set strings) {
        this.nameSet = strings;
    }

    public void printNameSet() {
        System.out.println(nameSet);
    }
}

This time we want to use a constructor injection for initializing the nameSet property. Dies erfordert auch Änderungen in der Konfigurationsklasse:

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

**4. Map mit Setter-Injektion**

Fügen Sie nach der gleichen Logik das Feld nameMaphinzu, um die Karteninjektion zu demonstrieren:

public class CollectionsBean {

    private Map nameMap;

    @Autowired
    public void setNameMap(Map nameMap) {
        this.nameMap = nameMap;
    }

    public void printNameMap() {
        System.out.println(nameMap);
    }
}

Diesmalwe have a setter method in order to use a setter dependency injection. Wir müssen auch den Initialisierungscode vonMapin der Konfigurationsklasse hinzufügen:

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

Die Ergebnisse nach dem Aufrufen der MethodeprintNameMap():

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

5. Injizieren von Bean-Referenzen

Schauen wir uns ein Beispiel an, in dem wir Bean-Referenzen als Elemente der Sammlung einfügen.

Zuerst erstellen wir die Bohne:

public class exampleBean {

    private String name;

    // constructor
}

Und fügen Sie derCollectionsBean -Skala einList vonexampleBean als Eigenschaft hinzu:

public class CollectionsBean {

    @Autowired(required = false)
    private List beanList;

    public void printBeanList() {
        System.out.println(beanList);
    }
}

Als Nächstes fügen wir die Java-Konfigurationsfactory-Methoden für jedesexampleBean-Element hinzu:

@Configuration
public class CollectionConfig {

    @Bean
    public exampleBean getElement() {
        return new exampleBean("John");
    }

    @Bean
    public exampleBean getAnotherElement() {
        return new exampleBean("Adam");
    }

    @Bean
    public exampleBean getOneMoreElement() {
        return new exampleBean("Harry");
    }

    // other factory methods
}

Der Spring-Container injiziert die einzelnen Bohnen vom TypexampleBeanin eine Sammlung.

Um dies zu testen, rufen wir die MethodecollectionsBean.printBeanList()auf. Die Ausgabe zeigt die Bean-Namen als Listenelemente:

[John, Harry, Adam]

Nunlet’s consider a scenario when there is not a exampleBean. Wenn im Anwendungskontext keinexampleBeanregistriert ist, löst Spring eine Ausnahme aus, da die erforderliche Abhängigkeit fehlt.

Wir können@Autowired(required = false) verwenden, um die Abhängigkeit als optional zu markieren. Anstatt eine Ausnahme auszulösen, werden diebeanList nicht initialisiert und ihr Wert bleibtnull.

Wenn wir anstelle vonnull, eine leere Liste benötigen, können wirbeanList mit einem neuenArrayList: initialisieren

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

5.1. Verwenden von@Order zum Sortieren von Bohnen

We can specify the order of the beans while injecting into the collection.

Zu diesem Zweck verwenden wir die Annotation@Orderund geben den Index an:

@Configuration
public class CollectionConfig {

    @Bean
    @Order(2)
    public exampleBean getElement() {
        return new exampleBean("John");
    }

    @Bean
    @Order(3)
    public exampleBean getAnotherElement() {
        return new exampleBean("Adam");
    }

    @Bean
    @Order(1)
    public exampleBean getOneMoreElement() {
        return new exampleBean("Harry");
    }
}

Spring container first will inject the bean with the name “Harry”, da es den niedrigsten Ordnungswert hat.

Es werden dann die“John”, und schließlich die“Adam”-Bohne injiziert:

[Harry, John, Adam]

Weitere Informationen zu@Order finden Sie inguide.

5.2. Verwenden von@Qualifier zum Auswählen von Bohnen

Wir können@Qualifier verwenden, um die Beans auszuwählen, die in die spezifische Sammlung injiziert werden sollen, die dem Namen von@Qualifierentspricht.

So verwenden wir es für den Injektionspunkt:

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

Dann markieren wir mit denselben@Qualifier die Bohnen, die wir in dieList injizieren möchten:

@Configuration
public class CollectionConfig {

    @Bean
    @Qualifier("CollectionsBean")
    public exampleBean getElement() {
        return new exampleBean("John");
    }

    @Bean
    public exampleBean getAnotherElement() {
        return new exampleBean("Adam");
    }

    @Bean
    public exampleBean getOneMoreElement() {
        return new exampleBean("Harry");
    }

    // other factory methods
}

In diesem Beispiel geben wir an, dass die Bean mit dem Namen“John” will in dieList mit dem Namen“CollectionsBean” injiziert werden soll. Die Ergebnisse testen wir hier:

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

Aus der Ausgabe geht hervor, dass unsere Sammlung nur ein Element enthält:

[John]

6. Festlegen einer leeren Liste als Standardwert

Mit der statischen MethodeCollections.emptyList()können wir den Standardwert für eine injizierte List-Eigenschaft als leere Liste festlegen:

public class CollectionsBean {

    @Value("${names.list:}#{T(java.util.Collections).emptyList()}")
    private List nameListWithDefaultValue;

    public void printNameListWithDefaults() {
        System.out.println(nameListWithDefaultValue);
    }
}

Wenn wir dies mit dem Schlüssel "names.list" ausführen, der nicht über die Eigenschaftendatei initialisiert wurde:

collectionsBean.printNameListWithDefaults();

Wir erhalten eine leere Liste als Ausgabe:

[ ]

7. Zusammenfassung

In diesem Handbuch haben wir gelernt, wie mit dem Spring-Framework verschiedene Arten von Java-Auflistungen eingefügt werden.

Wir untersuchten auch die Injektion mit Referenztypen und wie diese innerhalb der Sammlung ausgewählt oder bestellt werden können.

Wie üblich ist der vollständige Code inGitHub project verfügbar.

TOC