使用非空外键将父实体和子实体同时保存到父实体（Spring JPA / Hibernate）

提问者：小点点

使用非空外键将父实体和子实体同时保存到父实体（Spring JPA / Hibernate）

我在 MySQL 数据库中有两个实体，我想实现双向映射，在保存新父级时自动保存新子项。

机器（父）字段：ID、品牌

角色（子）字段：id、nome、macchina_id（外键不为空）

当我保存一个新的MACCHINA时，我还想通过这个JSON保存一个新的角色：

{
  "marca": "string",
  "personas": [
    {
      "nome": "string"
    }
  ]
}

机器实体：

@Entity
@Table(name = "macchina")
public class Macchina implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotNull
    @Column(name = "marca", nullable = false)
    private String marca;

    @OneToMany(mappedBy = "macchina", cascade = CascadeType.ALL)
    private Set<Persona> personas = new HashSet<>();

    // getters and setters ...
}

角色实体：

@Entity
@Table(name = "persona")
public class Persona implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NotNull
    @Column(name = "nome", nullable = false)
    private String nome;

    @ManyToOne(optional = false)
    @JoinColumn(name="macchina_id", referencedColumnName = "id", nullable = false)
    private Macchina macchina;

        // getters and setters ...
    }

在这种情况下，当我在 Macchina 实体上调用 JPA 存储库方法 .save（）时，我有一个例外：

> Caused by:
> com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException:
> Column 'macchina_id' cannot be null

在同样的情况下，我尝试在数据库中删除 Persona 表中字段“macchina_id”的 NotNull 约束;在这种情况下，事务将执行，但用户配置表中的“macchina_id”字段为 NULL。

我找到了解决方法，方法是删除数据库中“macchina_id”（以及实体中的注释）的 NotNull 约束，并以这种方式修改从父级到子级的映射：

@OneToMany(cascade = CascadeType.ALL)
@JoinColumn(name = "macchina_id")
private Set<Persona> personas = new HashSet<>();

我删除了“mappedBy”并添加了@JoinColumn。以这种方式工作：Hibernate执行插入到Macchina，插入到Persona，最后更新到Persona（我想编写/更新macchina_id字段）。

我的目标是维护数据库中字段“macchina_id”的 NotNull 属性;在映射字段私有Macchina Macchina上的子实体中维护一些属性值;如@NotNull / nullable = false / @ManyToOne（可选 = false），并使用由Spring/Hibernate自动验证的“macchina_id”字段同时保存这两个实体，而无需手动编写代码。

那么，有一种自动方法（Spring/Hibernate）可以先保存父项，然后再保存对父项具有 NotNull 外键的子项？

有什么建议吗？

问候，安德里亚

共3个答案

匿名用户

我遇到了完全相同的问题，经过多次搜索后找到了这个线程。我终于解决了它。基本上，JPA（或Hibernate-不确定）似乎无法单独设置子项中的父引用（即使您设置了注释）。因此，在父实体中，您应该执行以下操作：

@Entity
public class ParentEntity {

    @OneToMany(mappedBy = "parentReference", cascade = CascadeType.ALL) // parentReference, the property in ChildEntity class
    private final List<ChildEntity> childEntities = new ArrayList<>();

    public ParentEntity(ParentDTO parentDTO) {
        ...
        this.childEntities.add(new ChildEntity(parentDTO.getChildDTO(), this)); // NOTE second param "this"
    }
}

在子实体中，设置父引用

@Entity
public class ChildEntity {

    @ManyToOne
    @JoinColumn(name = "child_foreign_key_column_name", nullable = false)
    private final ParentEntity parentReference;

    public ChildEntity(ChildDTO child, ParentEntity parentReference) {
        ...
        this.parentReference = parentReference;
    }
}

匿名用户

用于保存的代码非常简单：我从 REST 接收 JSON 到 DTO 中，然后将 DTO 映射到域对象中，最后我调用 jpaRepository 的 .save（）方法。

@Override
@Transactional
public MacchinaDTO save(MacchinaDTO macchinaDTO) {
    log.debug("Request to save Macchina : {}", macchinaDTO);
    Macchina macchina = macchinaMapper.toEntity(macchinaDTO);
    macchina = macchinaRepository.save(macchina);
    return macchinaMapper.toDto(macchina);
}

匿名用户

我想尽量避免手动将Macchina添加到每个角色中。我正在尝试通过 Spring/Hibernate 来管理它（因为如果我从外键中删除非空约束，它可以工作）。

为了完成这个例子，我使用了一个用项目生成器JHipster生成的项目（如果你知道的话），它使用MapStruct来映射DTO和域：

/**
 * Contract for a generic dto to entity mapper.
 @param <D> - DTO type parameter.
 @param <E> - Entity type parameter.
 */

public interface EntityMapper <D, E> {
    public E toEntity(D dto);
    public D toDto(E entity);
    public List <E> toEntity(List<D> dtoList);
    public List <D> toDto(List<E> entityList);
}

/**
 * Mapper for the entity Macchina and its DTO MacchinaDTO.
 */
@Mapper(componentModel = "spring", uses = {PersonaMapper.class})
public interface MacchinaMapper extends EntityMapper <MacchinaDTO, Macchina> {

    default Macchina fromId(Long id) {
        if (id == null) {
            return null;
        }
        Macchina macchina = new Macchina();
        macchina.setId(id);
        return macchina;
    }
}

@Generated(
    value = "org.mapstruct.ap.MappingProcessor",
    date = "2017-07-21T11:57:12+0200",
    comments = "version: 1.1.0.Final, compiler: Eclipse JDT (IDE) 3.12.3.v20170228-1205, environment: Java 1.8.0_141 (Oracle Corporation)"
)
@Component
public class MacchinaMapperImpl implements MacchinaMapper {

    @Autowired
    private PersonaMapper personaMapper;

    @Override
    public MacchinaDTO toDto(Macchina arg0) {
        if ( arg0 == null ) {
            return null;
        }

        MacchinaDTO macchinaDTO = new MacchinaDTO();

        macchinaDTO.setId( arg0.getId() );
        macchinaDTO.setMarca( arg0.getMarca() );
        Set<PersonaDTO> set = personaSetToPersonaDTOSet( arg0.getPersonas() );
        if ( set != null ) {
            macchinaDTO.setPersonas( set );
        }

        return macchinaDTO;
    }

    @Override
    public List<MacchinaDTO> toDto(List<Macchina> arg0) {
        if ( arg0 == null ) {
            return null;
        }

        List<MacchinaDTO> list = new ArrayList<MacchinaDTO>();
        for ( Macchina macchina : arg0 ) {
            list.add( toDto( macchina ) );
        }

        return list;
    }

    @Override
    public Macchina toEntity(MacchinaDTO arg0) {
        if ( arg0 == null ) {
            return null;
        }

        Macchina macchina = new Macchina();

        macchina.setId( arg0.getId() );
        macchina.setMarca( arg0.getMarca() );
        Set<Persona> set = personaDTOSetToPersonaSet( arg0.getPersonas() );
        if ( set != null ) {
            macchina.setPersonas( set );
        }

        return macchina;
    }

    @Override
    public List<Macchina> toEntity(List<MacchinaDTO> arg0) {
        if ( arg0 == null ) {
            return null;
        }

        List<Macchina> list = new ArrayList<Macchina>();
        for ( MacchinaDTO macchinaDTO : arg0 ) {
            list.add( toEntity( macchinaDTO ) );
        }

        return list;
    }

    protected Set<PersonaDTO> personaSetToPersonaDTOSet(Set<Persona> set) {
        if ( set == null ) {
            return null;
        }

        Set<PersonaDTO> set_ = new HashSet<PersonaDTO>();
        for ( Persona persona : set ) {
            set_.add( personaMapper.toDto( persona ) );
        }

        return set_;
    }

    protected Set<Persona> personaDTOSetToPersonaSet(Set<PersonaDTO> set) {
        if ( set == null ) {
            return null;
        }

        Set<Persona> set_ = new HashSet<Persona>();
        for ( PersonaDTO personaDTO : set ) {
            set_.add( personaMapper.toEntity( personaDTO ) );
        }

        return set_;
    }
}