Wie definiere ich eine List Bean im Frühjahr?

Ich verwende Spring, um Phasen in meiner Anwendung zu definieren. Es ist konfiguriert, dass der erforderlichen Klasse (hier genannt Configurator) die Stufen injiziert werden.
Jetzt brauche ich die Liste der Stufen in einer anderen Klasse mit dem Namen LoginBean. Der Configuratorbietet keinen Zugang zu seiner Liste der Stufen.

Ich kann die Klasse nicht ändern Configurator.

Meine Idee:
Definieren Sie eine neue Bohne namens Stages und injizieren Sie sie in Configuratorund LoginBean. Mein Problem mit dieser Idee ist, dass ich nicht weiß, wie ich diese Eigenschaft transformieren soll:

<property ...>
  <list>
    <bean ... >...</bean>
    <bean ... >...</bean>
    <bean ... >...</bean>
  </list>
</property>

in eine Bohne.

So etwas funktioniert nicht:

<bean id="stages" class="java.util.ArrayList">

Kann mir jemand dabei helfen?

Importieren Sie den Spring Util-Namespace. Anschließend können Sie eine List Bean wie folgt definieren:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans
                    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                    http://www.springframework.org/schema/util
                    http://www.springframework.org/schema/util/spring-util-2.5.xsd">


<util:list id="myList" value-type="java.lang.String">
    <value>foo</value>
    <value>bar</value>
</util:list>

Der Werttyp ist der zu verwendende generische Typ und optional. Sie können die Listenimplementierungsklasse auch mithilfe des Attributs angeben list-class.

Hier ist eine Methode:

<bean id="stage1" class="Stageclass"/>
<bean id="stage2" class="Stageclass"/>

<bean id="stages" class="java.util.ArrayList">
    <constructor-arg>
        <list>
            <ref bean="stage1" />
            <ref bean="stage2" />                
        </list>
    </constructor-arg>
</bean>

Eine weitere Option ist die Verwendung von JavaConfig. Angenommen, alle Stufen sind bereits als Frühlingsbohnen registriert, müssen Sie nur:

@Autowired
private List<Stage> stages;

und spring fügt sie automatisch in diese Liste ein. Wenn Sie die Ordnung bewahren müssen (die obere Lösung tut das nicht), können Sie dies folgendermaßen tun:

@Configuration
public class MyConfiguration {
  @Autowired
  private Stage1 stage1;

  @Autowired
  private Stage2 stage2;

  @Bean
  public List<Stage> stages() {
    return Lists.newArrayList(stage1, stage2);
  }
}

Die andere Lösung zur Aufrechterhaltung der Ordnung ist die Verwendung einer @OrderAnmerkung zu Bohnen. Die Liste enthält dann Beans, die nach aufsteigendem Anmerkungswert sortiert sind.

@Bean
@Order(1)
public Stage stage1() {
    return new Stage1();
}

@Bean
@Order(2)
public Stage stage2() {
    return new Stage2();
}

<bean id="someBean"
      class="com.somePackage.SomeClass">
    <property name="myList">
        <list value-type="com.somePackage.TypeForList">
            <ref bean="someBeanInTheList"/>
            <ref bean="someOtherBeanInTheList"/>
            <ref bean="someThirdBeanInTheList"/>
        </list>
    </property>
</bean>

Und in SomeClass:

class SomeClass {

    List<TypeForList> myList;

    @Required
    public void setMyList(List<TypeForList> myList) {
        this.myList = myList;
    }

}

Stacker gab eine großartige Antwort, ich würde einen Schritt weiter gehen, um es dynamischer zu machen und Spring 3 EL Expression zu verwenden.

<bean id="listBean" class="java.util.ArrayList">
        <constructor-arg>
            <value>#{springDAOBean.getGenericListFoo()}</value>
        </constructor-arg>
</bean>

Ich habe versucht herauszufinden, wie ich dies mit der util: list tun kann, konnte es aber aufgrund von Konvertierungsfehlern nicht zum Laufen bringen.

Ich denke, Sie suchen vielleicht org.springframework.beans.factory.config.ListFactoryBean.

Sie deklarieren eine ListFactoryBean-Instanz, geben die zu instanziierende Liste als Eigenschaft mit einem <list>Element als Wert an und geben der Bean ein idAttribut. Jedes Mal, wenn Sie die deklarierte idals refoder ähnlich in einer anderen Bean-Deklaration verwenden, wird eine neue Kopie der Liste instanziiert. Sie können auch die Listzu verwendende Klasse angeben .

 <bean id="student1" class="com.spring.assin2.Student">  
<property name="name" value="ram"></property>  
<property name="id" value="1"></property> 
<property name="listTest">
        <list value-type="java.util.List">
            <ref bean="test1"/>
            <ref bean="test2"/>
        </list>
    </property>
</bean>  

Definiere diese Beans (test1, test2) danach :)

Verwenden Sie den util-Namespace, um die Liste als Bean in Ihrem Anwendungskontext zu registrieren. Sie können die Liste dann wiederverwenden, um sie in andere Bean-Definitionen einzufügen.

Als Ergänzung zu Jakubs Antwort können Sie, wenn Sie JavaConfig verwenden möchten, auch auf diese Weise automatisch verdrahten:

import com.google.common.collect.Lists;

import java.util.List;

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Bean;

<...>

@Configuration
public class MyConfiguration {

    @Bean
    public List<Stage> stages(final Stage1 stage1, final Stage2 stage2) {
        return Lists.newArrayList(stage1, stage2);
    }
}

Sie entfernen idnur aus Bohnen innerhalb des <list>Tags. So was:

<property name="listStaff">
  <list>
    <bean class="com.test.entity.Staff">
        <constructor-arg name="name" value = "Jonh"/>
        <constructor-arg name="age" value = "30"/>
    </bean>
    <bean class="com.test.entity.Staff">
        <constructor-arg name="name" value = "Jam"/>
        <constructor-arg name="age" value = "21"/>
    </bean>
  </list>
</property>

Und so injizieren Sie Set in eine Eigenschaft im Frühjahr:

<bean id="process"
      class="biz.bsoft.processing">
    <property name="stages">
        <set value-type="biz.bsoft.AbstractStage">
            <ref bean="stageReady"/>
            <ref bean="stageSteady"/>
            <ref bean="stageGo"/>
        </set>
    </property>
</bean>

Injizieren Sie eine Liste von Zeichenfolgen.

Angenommen, Sie haben eine Modellklasse für Länder, die eine Liste von Zeichenfolgen wie unten enthält.

public class Countries {
    private List<String> countries;

    public List<String> getCountries() {
        return countries;
    }   

    public void setCountries(List<String> countries) {
        this.countries = countries;
    }

}

Nach der XML-Definition definieren Sie eine Bean- und Inject-Liste der Länder.

<bean id="demoCountryCapitals" name="demoCountryCapitals" class="com.sample.pojo.Countries">
   <property name="countries">
      <list>
         <value>Iceland</value>
         <value>India</value>
         <value>Sri Lanka</value>
         <value>Russia</value>
      </list>
   </property>
</bean>

Referenz - Link

Injizieren Sie die Liste der Pojos

Angenommen, Sie haben eine Modellklasse wie unten.

public class Country {
    private String name;
    private String capital;
    .....
    .....
 }

public class Countries {
    private List<Country> favoriteCountries;

    public List<Country> getFavoriteCountries() {
        return favoriteCountries;
    }

    public void setFavoriteCountries(List<Country> favoriteCountries) {
        this.favoriteCountries = favoriteCountries;
    }

}

Bohnendefinitionen.

 <bean id="india" class="com.sample.pojo.Country">
  <property name="name" value="India" />
  <property name="capital" value="New Delhi" />
 </bean>

 <bean id="russia" class="com.sample.pojo.Country">
  <property name="name" value="Russia" />
  <property name="capital" value="Moscow" />
 </bean>


 <bean id="demoCountryCapitals" name="demoCountryCapitals" class="com.sample.pojo.Countries">
  <property name="favoriteCountries">
   <list>
    <ref bean="india" />
    <ref bean="russia" />
   </list>
  </property>
 </bean>

Referenz Verbindung .