Java 使用Spring，如何将项目添加到最终的预填充列表中？

鉴于这一类别：

public class Node {
  private final List<Node> children;
  public Node(){
    children = new ArrayList<>();
    // possibly pre-populate the list here
  }
  public List<Node> getChildren(){
    return children;
  }
}

公共类节点{
私人最终名单儿童；
公共节点（）{
children=newarraylist（）；
//可能在此处预先填充列表
}
公共列表getChildren（）{
返回儿童；
}
}

在Spring中，当一些子节点是由类定义的，而一些子节点应该是可配置的时，创建具有子节点的节点的最佳方法是什么

<bean id="node1" class="Node">
  <property name="children">
    <add-item><bean class="Node"/></add-item> <!--pseudocode-->
    <add-item><bean class="Node"/></add-item> <!--pseudocode-->
  </property>
</bean>

---

我在SpringIOC文档和论坛中找到的答案并不能让我满意，因为提议的解决方案涉及不同程度的开销：额外的映射bean、工厂方法、要继承的抽象bean。。。还有更优雅的吗？

我会直接将列表注入构造函数。这使得使用最终字段并不困难：

public class Node {
  private final List<Node> children;
  public Node(List<Node> children){
    this.children = children;
  }
  public List<Node> getChildren(){
    return children;
  }
}

<bean id="node1" class="Node">
  <constructor-arg>
        <list>
            <item><bean class="Node"/></item> <!--pseudocode-->
            ...
        </list>
    </constructor-arg>    
</beans>

公共类节点{
私人最终名单儿童；
公共节点（列出子节点）{
这个。孩子=孩子；
}
公共列表getChildren（）{
返回儿童；
}
}
...

编辑您的评论：

如果您想在之前或之后进行任何初始化，您可以这样做：

...
public Node(List<Node> children){
    this.children = new ArrayList<>();
    // do some initialization before...
    this.children.addAll(children);
    // do some initialization after...
}
...

。。。
公共节点（列出子节点）{
this.children=new ArrayList（）；
//在…之前做一些初始化。。。
this.children.addAll（children）；
//在…之后做一些初始化。。。
}
...

我稍微更改了节点类

public class Node implements InitializingBean{

private final List<Node> children;

private String name;

public Node() {
    children = new ArrayList<>();
}

@Override
public void afterPropertiesSet() throws Exception {
    //predefined nodes
    Node node = new Node();
    node.setName(":)");
    children.add(node);
}

public String toString(){ return name; }

public List<Node> getChildren() {
    return children;
}

public void setNodes(Node nodes[]){
    if(nodes != null){
        for(Node node: nodes){
            this.children.add(node);
        }
    }
}

public void setChildren(Object something){
    System.out.println(something.getClass());
}
public void setName(String name) { this.name = name; }

---

您没有指定子项的来源。作为第二个选项，如果您不想将列表注入contstructor，可以使用

@postcontract

方法：

public class Node {
  private final List<Node> children;
  public Node(){
    children = new ArrayList<>();
  }
  public List<Node> getChildren(){
    return children;
  }

  @PostConstruct
  public void init() {
    // this method will Spring call after dependency injection is done.
    children.add(...)
  }

公共类节点{
私人最终名单儿童；
公共节点（）{
children=newarraylist（）；
}
公共列表getChildren（）{
返回儿童；
}
@施工后
公共void init（）{
//此方法将在依赖项注入完成后触发调用。
添加（…）
}

yes的可能重复，答案很好，但是，如果我在课堂上有预定义的项目呢？（编辑我的示例以澄清）好的，我可以让构造函数在预填充的项之后添加提供的项，这就可以了，我还想到了一个列表属性，可读，代表所有的子项，以及第二个列表属性，可写，来添加子项。它确实有效，并没有那么糟糕，但仍然感觉像是“使域模型适应Spring功能”，而不是“使用Spring来适应域模型”如果您根本不想修改模型类，那么应该使用Spring java config。另一个解决方法是使用

MethodInvokingFactoryBean

来调用

add

方法，但它非常麻烦，而且一点也不优雅，除非Spring XML支持循环。

public class Node {
  private final List<Node> children;
  public Node(){
    children = new ArrayList<>();
  }
  public List<Node> getChildren(){
    return children;
  }

  @PostConstruct
  public void init() {
    // this method will Spring call after dependency injection is done.
    children.add(...)
  }