用JPA持久化一个图

我试图用JPA持久化一个图，但它不起作用。我的叶是节点，可以有多个父节点，父节点可以有多个子节点

@实体
@表（name=“NODES”）
@继承（策略=InheritanceType.JOINED）
@鉴别器列（name=“KIND”，鉴别器类型=鉴别器类型.STRING，长度=1）
公共抽象类节点实现可序列化{
@列（unique=true，name=“name”，nullable=false，length=50）
私有字符串名称；
@ManyToMany（mappedBy=“children”，fetch=FetchType.LAZY）
@JoinTable（name=“NODE_PARENTS”，joinColumns={@JoinColumn（name=“NODEID”，referencedColumnName=“ID”）}，inverseJoinColumns={@JoinColumn（name=“PARENTID”，referencedColumnName=“ID”）}）
私人家长；
公共节点（）{
this.parents=new HashSet（）；
}
公共字符串getName（）{
返回此.name；
}
公共void集合名（字符串名）{
this.name=名称；
}
public void setParents（集合父列表）{
for（父级：this.parents）{
移除父对象（父对象）；
}
用于（父项：父项列表）{
addParent（父母）；
}
}
公共void addParent（父级）{
this.parents.add（parent）；
如果（！parent.getMembers（）.包含（此））{
parent.getMembers（）.add（此）；
}
}
public void removeParent（ACLGroup parent）{
此.parents.remove（parent）；
if（parent.getMembers（）.contains（this））{
parent.getMembers（）.remove（此）；
}
}
公共集getParents（）{
返回集合.unmodifiableSet（this.parents）；
}
}
@实体
@表（name=“LEAFS”）
@鉴别器值（“L”）
公共类叶扩展节点{
//有些领域需要坚持
}
@实体
@表（name=“内部节点”）
@鉴别器值（“P”）
公共类InnerNodes扩展节点实现父节点{
//有些领域需要坚持
@ManyToMany（fetch=FetchType.LAZY）
私人儿童；
公共内部节点（）{
this.children=newhashset（）；
}
公共集getChildren（）{
返回集合.unmodifiableSet（this.children）；
}
公共void setChildren（Set childList）{
for（节点子节点：this.children）{
removeChild（儿童）；
}
用于（节点子节点：子列表）{
addChild（child）；
}
}
公共void addChild（节点子节点）{
this.children.add（child）；
如果（！child.getParents（）.包含（此））{
child.addParent（this）；
}
}
public void removeChild（节点子节点）{
这个。儿童。移除（儿童）；
if（child.getParents（）.contains（this））{
子。移除父（本）；
}
}
}
公共接口父级{
设置getChildren（）；
void setChildren（Set childList）；
void addChild（节点子节点）；
void removeChild（节点子节点）；
}

问题是，我不能持久化接口父级，但我需要它来防止循环。每个叶或内部节点可以有多个父节点，每个父节点可以有多个子节点

有没有实施的想法？ 非常感谢

---

安德烈

如果一片叶子可以有多个双亲，那么它就不是一棵树，所以它也不是一片叶子。为什么不坚持使用Node呢？顺便说一下，考虑一下用于保存图形的OO模型。让JPA管理它的ERM端。我模型的一个叶没有子节点，所以我决定有一个抽象基类节点和两个实现（叶和内部节点）。后者可以生孩子。

@Entity
@Table(name = "NODES")
@Inheritance(strategy = InheritanceType.JOINED)
@DiscriminatorColumn(name = "KIND", discriminatorType = DiscriminatorType.STRING, length = 1)
public abstract class Node implements Serializable {

    @Column(unique = true, name = "NAME", nullable = false, length = 50)
    private String name;

    @ManyToMany(mappedBy = "children", fetch = FetchType.LAZY)
    @JoinTable(name = "NODE_PARENTS", joinColumns = { @JoinColumn(name = "NODEID", referencedColumnName = "ID") }, inverseJoinColumns = { @JoinColumn(name = "PARENTID", referencedColumnName = "ID") })
    private Set<Parent> parents;

    public Node() {
        this.parents = new HashSet<Parent>();
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setParents(Collection<Parent> parentList) {
        for(Parent parent : this.parents) {
            removeParent(parent);
        }
        for (Parent parent : parentList) {
            addParent(parent);
        }
    }

    public void addParent(Parent parent) {
        this.parents.add(parent);
        if (!parent.getMembers().contains(this)) {
            parent.getMembers().add(this);
        }
    }

    public void removeParent(ACLGroup parent) {
        this.parents.remove(parent);
        if (parent.getMembers().contains(this)) {
            parent.getMembers().remove(this);
        }
    }

    public Set<ACLGroup> getParents() {
        return Collections.unmodifiableSet(this.parents);
    }
}

@Entity
@Table(name = "LEAFS")
@DiscriminatorValue("L")
public class Leaf extends Node {

    // some fields to persist
}

@Entity
@Table(name = "INNER_NODES")
@DiscriminatorValue("P")
public class InnerNodes extends Node implements Parent {

    // some fields to persist

    @ManyToMany(fetch = FetchType.LAZY)
    private Set<Node> children;

    public InnerNodes() {
        this.children = new HashSet<Node>();
    }

    public Set<Node> getChildren() {
        return Collections.unmodifiableSet(this.children);
    }

    public void setChildren(Set<Node> childList) {
        for (Node child : this.children) {
            removeChild(child);
        }
        for (Node child : childList) {
            addChild(child);
        }
    }

    public void addChild(Node child) {
        this.children.add(child);
        if (!child.getParents().contains(this)) {
            child.addParent(this);
        }
    }

    public void removeChild(Node child) {
        this.children.remove(child);
        if (child.getParents().contains(this)) {
            child.removeParent(this);
        }
    }
}

public interface Parent {
    Set<Node> getChildren();
    void setChildren(Set<Node> childList);
    void addChild(Node child);
    void removeChild(Node child);
}