Hibernate 休眠多对多自联接重复项

我尝试将图形保存到数据库中。 它由一个带有“tag”属性的简单类组成。 这个班可能有父母和孩子

保存根类后，也会保存所有图形，但当一个节点有两个父节点时，这两个父节点会在数据库中重复

以下是映射的节点类：

@Entity
@Table(name="acttest")
public class ActivityTest {

    @Id
    @Column(name="id_activity")
    @GeneratedValue
    private Long idActivity;


    @Column(name="tag")
    private String tag;


    @ManyToMany(cascade=CascadeType.ALL,  fetch = FetchType.EAGER )
    @JoinTable(name="dependencies",
        joinColumns={@JoinColumn(name="id_master")},
        inverseJoinColumns={@JoinColumn(name="id_slave")})
    private Set<ActivityTest> nextActivities = new HashSet<ActivityTest>();


    @ManyToMany(mappedBy="nextActivities",  fetch = FetchType.EAGER)
    private Set<ActivityTest> previousActivities = new HashSet<ActivityTest>();

    (getters and setters)
}

以下是包装器列表：

public class ActivityList {
    private List<ActivityTest> activities;
    private ActivityTest root = null;

    public void addRoot( String tag ) {
        if ( root == null ) {
            ActivityTest activity = new ActivityTest( tag );
            activities.add(activity);
            root = activity;
        }
    }

    public ActivityList() {
        activities = new ArrayList<ActivityTest>();
    }

    public void addNextActivity( String master, String next ) {
        ActivityTest newAct = new ActivityTest( next );
        activities.add(newAct);
        for ( ActivityTest act : activities  ) {
            if ( act.getTag().equalsIgnoreCase( master )  ) {
                act.getNextActivities().add( newAct );
            }
        }
    }

    public ActivityTest getRoot() {
        return root;
    }

    public List<ActivityTest> getActivities() {
        return activities;
    }

    public void setActivities( List<ActivityTest> activities ) {
        root = null;
        this.activities = activities;
        for ( ActivityTest act : activities  ) {
            if ( act.getPreviousActivities().size() == 0 ) {
                root = act;
                break;
            }
        }
    }


}

公共类活动列表{
私人名单活动；
private ActivityTest root=null；
公共void addRoot（字符串标记）{
if（root==null）{
ActivityTest活动=新的ActivityTest（标签）；
活动。添加（活动）；
根=活动；
}
}
公共活动列表（）{
活动=新的ArrayList（）；
}
public void addnextractivity（字符串主控、字符串下一个）{
ActivityTest newAct=新ActivityTest（下一步）；
活动。添加（新法案）；
for（活动测试法案：活动）{
if（act.getTag（）.equalsIgnoreCase（master））{
act.getnextractivities（）.add（newAct）；
}
}
}
公共活动测试getRoot（）{
返回根；
}
公共列表活动（）{
返回活动；
}
公共活动（列出活动）{
root=null；
这是活动=活动；
for（活动测试法案：活动）{
if（act.getPreviousActivities（）.size（）==0）{
根=行动；
打破
}
}
}
}

我设计要测试的图形：

图表：

和依赖关系表：

注意“BA12”节点的双重性：onde表示“A1”子节点，其他表示“A2”子节点

如何创建“BA12”节点的一个实例？

非常抱歉

通过更改包装器类解决：

添加了一个私有方法，用于搜索已创建的对象：

private ActivityTest getActivity( String tag ) {
    for ( ActivityTest act : activities  ) {
        if ( act.getTag().equalsIgnoreCase( tag )  ) {
            return act;
        }
    }
    return new ActivityTest(tag);
}

并将addNextActivity更改为：

public void addNextActivity( String master, String next ) {
    ActivityTest newAct = getActivity( next );
    activities.add(newAct);

    for ( ActivityTest act : activities  ) {
        if ( act.getTag().equalsIgnoreCase( master )  ) {
            act.getNextActivities().add( newAct );
        }
    }
}

再次抱歉。我的错误

public void addNextActivity( String master, String next ) {
    ActivityTest newAct = getActivity( next );
    activities.add(newAct);

    for ( ActivityTest act : activities  ) {
        if ( act.getTag().equalsIgnoreCase( master )  ) {
            act.getNextActivities().add( newAct );
        }
    }
}