JPA/Hibernate处理复合主键Null ID错误技巧

本文旨在解决JPA/Hibernate中使用`@EmbeddedId`作为复合主键时，因外键关联未正确嵌入导致`Null ID`生成错误的问题。通过将`@ManyToOne`关联直接整合到`@Embeddable`类中，并优化实体映射与保存逻辑，确保复合主键在持久化前完整初始化，从而避免运行时错误，提升数据模型的一致性和健壮性。

理解JPA/Hibernate中嵌入式复合主键的挑战

在使用JPA和Hibernate构建数据模型时，复合主键是一种常见需求，尤其当一个实体的主键由多个字段组成时。@EmbeddedId注解允许我们将一个独立的@Embeddable类用作实体的主键。然而，当这个复合主键的一部分是一个外键（即关联到另一个实体的主键）时，如果没有正确配置，很容易遇到“Null ID generated”错误。

问题的核心在于，当一个实体（例如BlockAttribute）使用@EmbeddedId，并且该@EmbeddedId包含一个外键（例如blockID，指向Block实体的主键），在保存BlockAttribute之前，BlockAttributeID中的所有组件都必须被正确初始化。如果BlockAttributeID仅仅包含一个Long blockID字段，而BlockAttribute实体本身又有一个@ManyToOne Block block字段，那么在保存BlockAttribute时，JPA/Hibernate可能无法自动将Block实体的主键值填充到BlockAttributeID中的blockID字段。

考虑以下初始的数据模型：

1. BlockAttributeID (嵌入式主键类)

@Embeddable
@Data // Lombok注解，用于生成getter/setter, equals, hashCode等
public class BlockAttributeID implements Serializable {

    @Column(name = "block_id")
    Long blockID; // 仅包含Block的ID

    String attribute;

    // equals 和 hashCode 方法的实现需要注意，尤其是当blockID可能为null时
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof BlockAttributeID)) return false;
        BlockAttributeID that = (BlockAttributeID) o;
        return Objects.equals(blockID, that.blockID) && Objects.equals(attribute, that.attribute);
    }

    @Override
    public int hashCode() {
        return Objects.hash(blockID, attribute);
    }
}

2. BlockAttribute (使用嵌入式主键的实体)

@Data
@Table(name = "block_attribute")
@Entity
public class BlockAttribute {

    @EmbeddedId
    BlockAttributeID blockAttributeID;

    // 冗余的ManyToOne关联，与EmbeddedId中的blockID形成冲突或混淆
    @ManyToOne(fetch = FetchType.LAZY)
    @JsonIgnore
    @JoinColumn(name = "block_id") // 这个@JoinColumn通常会导致问题
    Block block; // 这里又有一个Block实体引用

    String label;
    // ... 其他字段

    // equals 和 hashCode 同样需要基于复合主键进行正确实现
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof BlockAttribute)) return false;
        BlockAttribute that = (BlockAttribute) o;
        return Objects.equals(blockAttributeID, that.blockAttributeID);
    }

    @Override
    public int hashCode() {
        return Objects.hash(blockAttributeID);
    }
}

3. Block (父实体)

@Table(name = "block")
@Entity
@Data
public class Block {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "block_id")
    Long blockID; // Block的主键

    // ... 其他字段和关联

    @OneToMany(mappedBy = "block", fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval = true)
    Set blockAttributes = new HashSet<>();

    // ... 其他方法
}

当尝试以下保存逻辑时，就会出现Null ID generated for: class BlockAttribute错误：

// 1. 保存父Block实体，生成其blockID
block = blockRepository.save(block);

// 2. 设置BlockAttribute的block字段
blockAttribute.setBlock(block); // 此时blockAttributeID中的blockID并未被设置

// 3. 尝试保存BlockAttribute
blockAttributeRepository.save(blockAttribute); // 抛出Null ID错误

问题在于，blockAttribute.setBlock(block)只是设置了BlockAttribute实体中的block引用，但@EmbeddedId中的blockID字段仍然是null。JPA在保存BlockAttribute时，需要BlockAttributeID中的所有主键组件都非空。

解决方案：将外键关联嵌入到@Embeddable类中

解决此问题的关键在于，如果一个外键是复合主键的一部分，那么该外键的@ManyToOne关联应该直接放在@Embeddable类中，而不是在主实体中重复定义。这样，@EmbeddedId就能直接持有对关联实体的引用，从而确保在创建复合主键时，能够获取到关联实体的主键信息。

1. 修正后的 BlockAttributeID 类

我们将@ManyToOne关联直接移入BlockAttributeID。

import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data; // 推荐使用Lombok简化代码
import javax.persistence.*;
import java.io.Serializable;
import java.util.Objects;

@Embeddable
@Data // 确保生成了getter/setter以及默认的equals/hashCode，但需手动优化
public class BlockAttributeID implements Serializable {

    // 将ManyToOne关联直接嵌入到复合主键类中
    @ManyToOne(fetch = FetchType.LAZY)
    @JsonIgnore // 通常在嵌入式ID中，避免序列化Block实体，防止循环引用
    @JoinColumn(name = "block_id", referencedColumnName = "block_id") // 明确指定关联列
    Block block; // 现在直接持有Block实体引用

    String attribute;

    // 构造函数，方便创建复合主键实例
    public BlockAttributeID(Block block, String attribute) {
        this.block = block;
        this.attribute = attribute;
    }

    // JPA规范要求存在无参构造函数
    public BlockAttributeID() {
    }

    // 优化后的equals方法：基于Block的ID和attribute进行比较
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof BlockAttributeID)) return false;
        BlockAttributeID that = (BlockAttributeID) o;
        // 比较Block实体时，应比较其主键ID，而不是整个实体对象，以避免代理问题
        return Objects.equals(
            this.block != null ? this.block.getBlockID() : null,
            that.block != null ? that.block.getBlockID() : null
        ) && Objects.equals(this.attribute, that.attribute);
    }

    // 优化后的hashCode方法：基于Block的ID和attribute生成
    @Override
    public int hashCode() {
        return Objects.hash(
            this.block != null ? this.block.getBlockID() : null,
            this.attribute
        );
    }
}

关键点:

• @ManyToOne Block block; 直接定义在BlockAttributeID中。
• @JoinColumn(name = "block_id", referencedColumnName = "block_id") 明确指定了外键列。
• equals() 和 hashCode() 方法被优化，以Block的ID和attribute字段作为比较和哈希的依据，这对于包含实体引用的@Embeddable类至关重要。

2. 修正后的 BlockAttribute 类

由于BlockAttributeID现在已经包含了Block的关联信息，BlockAttribute实体中的冗余@ManyToOne Block block;字段应该被移除。

import lombok.Data;
import javax.persistence.*;
import java.util.Objects;

@Data
@Table(name = "block_attribute")
@Entity
public class BlockAttribute {

    @EmbeddedId
    BlockAttributeID blockAttributeID; // 复合主键，现在包含了Block的引用

    // 移除冗余的Block字段，因为它已经包含在blockAttributeID中
    // @ManyToOne(fetch = FetchType.LAZY)
    // @JsonIgnore
    // @JoinColumn(name = "block_id")
    // Block block;

    String label;

    @Enumerated(EnumType.STRING)
    Type type;

    @Enumerated(EnumType.STRING)
    Unit unit;

    String value;

    // equals 和 hashCode 应该基于 @EmbeddedId
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof BlockAttribute)) return false;
        BlockAttribute that = (BlockAttribute) o;
        return Objects.equals(blockAttributeID, that.blockAttributeID);
    }

    @Override
    public int hashCode() {
        return Objects.hash(blockAttributeID);
    }
}

关键点:

• 移除了BlockAttribute中直接的@ManyToOne Block block字段，避免了重复映射和潜在的混淆。
• equals()和hashCode()现在完全依赖于blockAttributeID，确保了一致性。

修正后的保存逻辑

在实体映射调整后，保存逻辑也需要相应修改，以确保在创建BlockAttribute时，其@EmbeddedId能够被正确初始化。

// 1. 首先保存父Block实体，确保其主键（blockID）已生成
Block savedBlock = blockRepository.save(block);

// 2. 创建BlockAttributeID实例，传入已保存的Block实体和attribute值
// 此时savedBlock已经拥有了数据库生成的主键ID
BlockAttributeID blockAttributeID = new BlockAttributeID(savedBlock, completeBlockDTO.getBlockAttributeDTO().getAttribute());

// 3. 将创建好的BlockAttributeID设置到BlockAttribute实体中
blockAttribute.setBlockAttributeID(blockAttributeID);

// 4. 保存BlockAttribute实体
blockAttributeRepository.save(blockAttribute);

// 对于其他依赖于Block的子实体（如BlockBoundary），如果其关联方式是ManyToOne，
// 则可以直接设置Block实体引用，因为它的ID是独立的，不作为其复合主键的一部分。
// blockBoundary.setBlock(savedBlock);
// blockBoundaryRepository.save(blockBoundary);

总结与最佳实践

1. 外键作为复合主键的一部分： 当一个外键是@EmbeddedId的一部分时，应将@ManyToOne关联直接定义在@Embeddable类中，而不是在主实体中重复定义。
2. @Embeddable中的equals()和hashCode()： 务必为@Embeddable类正确实现equals()和hashCode()方法。如果@Embeddable类包含实体引用（如Block block），则在这些方法中应比较关联实体的主键ID，而不是整个实体对象，以避免Hibernate代理对象带来的问题。
3. 保存顺序： 在保存使用@EmbeddedId的子实体之前，必须先保存其关联的父实体，以确保父实体的主键已经生成并可用于构建复合主键。
4. 避免冗余映射： 如果外键关联已在@EmbeddedId中定义，则主实体中不应再有重复的@ManyToOne映射到同一外键，这可能导致混淆或错误。
5. @JoinColumn的精确性： 在@ManyToOne映射中使用@JoinColumn时，确保name和referencedColumnName属性准确无误，指向正确的数据库列。

遵循这些最佳实践，可以有效避免JPA/Hibernate中嵌入式复合主键相关的Null ID生成错误，构建出更加健壮和易于维护的数据模型。