Hibernate OneToMany insert导致分离实体传递到PERSISTER错误

我正在尝试使用hibernate panache将数据持久化到一个

OneToMany

表功能和特性角色。创建了一个服务方法，该方法的输入将是

列表

功能ID和

字符串

角色名称。我想插入FeatureRole表，其中包含每个功能（来自ids）和角色名称

return Panache.withTransaction(() -> {
            return featuresRepository.findByIds(ids).collect().asList().onItem().transform(t -> {
                FeatureRole fr = new FeatureRole();
                fr.setRole_name("role name");
                for (Features fe: t) {
                    fr.setFeatures(fe);
                    fe.getFeatureRoles().add(fr);
                }
                return featureRoleRepository.persistAndFlush(fr).map(to -> fr);
            }).flatMap(t -> t);
        });

当我运行此命令时，发生了一个错误。表示功能插入到功能角色表未持久化。我们如何解决这个错误

Caused by: java.util.concurrent.CompletionException: org.hibernate.PersistentObjectException: detached entity passed to persist: io.github.jithset.models.Features
                at java.base/java.util.concurrent.CompletableFuture.encodeThrowable(CompletableFuture.java:331)
                at java.base/java.util.concurrent.CompletableFuture.uniApplyNow(CompletableFuture.java:670)
                at java.base/java.util.concurrent.CompletableFuture.uniApplyStage(CompletableFuture.java:658)
                at java.base/java.util.concurrent.CompletableFuture.thenApply(CompletableFuture.java:2094)
                at java.base/java.util.concurrent.CompletableFuture.thenApply(CompletableFuture.java:143)
                at org.hibernate.reactive.util.impl.CompletionStages.lambda$loop$5(CompletionStages.java:170)
                at com.ibm.asyncutil.iteration.AsyncTrampoline.lambda$asyncWhile$1(AsyncTrampoline.java:209)
                at com.ibm.asyncutil.iteration.AsyncTrampoline$TrampolineInternal.unroll(AsyncTrampoline.java:119)
                at com.ibm.asyncutil.iteration.AsyncTrampoline$TrampolineInternal.trampoline(AsyncTrampoline.java:101)
                at com.ibm.asyncutil.iteration.AsyncTrampoline$TrampolineInternal.access$200(AsyncTrampoline.java:84)
                at com.ibm.asyncutil.iteration.AsyncTrampoline.asyncWhile(AsyncTrampoline.java:192)
                at com.ibm.asyncutil.iteration.AsyncTrampoline.asyncWhile(AsyncTrampoline.java:209)
                at org.hibernate.reactive.util.impl.CompletionStages.loop(CompletionStages.java:169)
                at org.hibernate.reactive.util.impl.CompletionStages.loop(CompletionStages.java:186)
                at org.hibernate.reactive.session.impl.ReactiveSessionImpl.fire(ReactiveSessionImpl.java:1076)
                at org.hibernate.reactive.session.impl.ReactiveSessionImpl.firePersist(ReactiveSessionImpl.java:696)
                ... 67 more

角色

特征

@实体
@表（name=“features”）
@诺尔格构装师
@托斯特林
公共类功能{
@身份证
@SequenceGenerator（name=“featureSequence”，sequenceName=“featureSequence”，allocationSize=1）
@GeneratedValue（generator=“featureSequence”）
@列（name=“feature\u id”）
@Getter@Setter
公共长id；
@Getter@Setter
@不空白
@列（唯一=真）
公共字符串名称；
@独身癖(
mappedBy=“features”，
cascade=CascadeType.ALL，
删除=真，
fetch=FetchType.EAGER
)
@Getter@Setter
私有列表功能角色=新建ArrayList（）；
公共功能（长id、字符串名称）{
this.id=id；
this.name=名称；
}
来自（行）的公共静态要素{
返回新功能（row.getLong（“功能_id”）、row.getString（“名称”）；
}`在这里输入代码`

根据您的映射，一个

功能角色可以与一个
功能关联（多对一）。在您的代码中，您循环使用多个
功能，并在每次调用时重写关联
fr.setFeatures（fe）；

这意味着只有循环中最后的
特征
将具有正确的关联，因为
fr
仅与单个元素关联

假设一个
特性
可以有许多
特性角色
，您需要决定哪个用例适用：

1.一个
功能角色可以有许多
功能

然后是a，您必须将映射重写为类似于：

...
class FeatureRole {
    ...
    @ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    private List<Features> features;
    ...
    public void addFeature(Features features) {
     this.features.add( features );
     features.getFeatureRoles().add( this );
 }

2.单个
功能角色
只能与一个
功能关联

然后循环的逻辑需要改变。
但是我需要更多的细节来帮助你

@Entity
@Table(name = "features")
@NoArgsConstructor
@ToString
public class Features {

    @Id
    @SequenceGenerator(name = "featureSequence", sequenceName = "featureSequence", allocationSize = 1)
    @GeneratedValue(generator = "featureSequence")
    @Column(name = "feature_id")
    @Getter @Setter
    public Long id;

    @Getter @Setter
    @NotBlank
    @Column(unique = true)
    public String name;

    @OneToMany(
            mappedBy = "features",
            cascade = CascadeType.ALL,
            orphanRemoval = true,
            fetch = FetchType.EAGER
    )
    @Getter @Setter
    private List<FeatureRole> featureRoles =new ArrayList<>();

    public Features(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    public static Features from(Row row) {
        return new Features(row.getLong("feature_id"), row.getString("name"));
    }`enter code here`

...
class FeatureRole {
    ...
    @ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    private List<Features> features;
    ...
    public void addFeature(Features features) {
     this.features.add( features );
     features.getFeatureRoles().add( this );
 }

...
class Features {
    ...
    @ManyToMany(mappedby="features")
    private List<FeatureRole> featureRoles =new ArrayList<>()
    ...
}

for (Features fe: t) {
    fr.addFeatures(fe);
}