Spring Data JPA：插入记录时用外键ID与关联实体的技术差异

我想了解以下两种插入Contact实体方式的差异：

1. 将userId作为外键值（如1）映射后保存Contact实体；
2. 通过userId查询对应的User实体，关联到Contact后再保存。

数据库模型 #

数据表user： #

+--+--------+
|id|username|
+--+--------+
|1 |someUser|
+--+--------+

Controller代码 #

@RestController
public class ContactController {
    // 为简洁起见，所有操作均在控制器中实现
    @Resource
    private ContactMapper contactMapper;

    @Resource
    private ContactRepository contactRepository;
    
    @Resource
    private UserRepository userRepository;

    @PostMapping("/as-foreign-key")
    public void addContactWithUserIdForeignKey(@RequestBody ContactDto dto) {
        Contact contact = contactMapper.contactDtoToContact(dto);
        contactRepository.save(contact);
    }

    @PostMapping("/as-entity")
    public void addContactWithUserEntity(@RequestBody ContactDto dto) {
        User user = userRepository.findById(dto.getUserId()).get();

        Contact contact = contactMapper.contactDtoToContact(dto);
        contact.setUser(user);
        contactRepository.save(contact);
    }

}

DTO代码 #

@Data
public class ContactDto implements Serializable {
    private final String firstName;
    private final String lastName;
    private final Integer userId;
}

MapStruct映射器代码 #

@Mapper(unmappedTargetPolicy = ReportingPolicy.IGNORE, componentModel = "spring")
public interface ContactMapper {

    @Mapping(source = "userId", target = "user.id")
    Contact contactDtoToContact(ContactDto contactDto);

}

实体类代码 #

@Data
@Entity
@Table(name = "\"user\"")
public class User {
    @Id
    @Column(name = "id", nullable = false)
    private Integer id;

    @Column(name = "username", nullable = false, length = 50)
    private String username;
}

@Data
@Entity
@Table(name = "contact")
public class Contact {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id", nullable = false)
    private Integer id;

    @Column(name = "first_name", nullable = false, length = 50)
    private String firstName;

    @Column(name = "last_name", nullable = false, length = 50)
    private String lastName;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "user_id", nullable = false)
    private User user;
}

执行请求 #

curl -X 'POST' \
  'http://localhost:8080/as-foreign-key' \
  -H 'accept: */*' \
  -H 'Content-Type: application/json' \
  -d '{
  "firstName": "John",
  "lastName": "Doe",
  "userId": 1
}'

curl -X 'POST' \
  'http://localhost:8080/as-entity' \
  -H 'accept: */*' \
  -H 'Content-Type: application/json' \
  -d '{
  "firstName": "Jane",
  "lastName": "Done",
  "userId": 1
}'

执行结果 #

数据表contact：

+--+----------+---------+-------+
|id|first_name|last_name|user_id|
+--+----------+---------+-------+
|1 |John      |Doe      |1      |
|2 |Jane      |Done     |1      |
+--+----------+---------+-------+

两种方式得到的结果一致。查看控制台输出的Hibernate SQL语句如下：

Hibernate: select user_.id, user_.username as username2_1_ from "user" user_ where user_.id=?
Hibernate: insert into contact (first_name, last_name, user_id) values (?, ?, ?)

Hibernate: select user0_.id as id1_1_0_, user0_.username as username2_1_0_ from "user" user0_ where user0_.id=?
Hibernate: insert into contact (first_name, last_name, user_id) values (?, ?, ?)

我一直认为第二种方式（先查询User实体再关联保存）是正确的做法。请问这两种方式是否存在技术差异？第一种方式是否可以安全使用？有哪些需要注意的问题？

两种方式的技术差异 #

1. 实体状态与Hibernate行为

   • 第一种方式中，通过MapStruct创建的是**游离状态（detached）**的User实例：仅设置了id，无其他属性，且不在Hibernate持久化上下文内。保存Contact时，Hibernate会自动执行SELECT查询验证User存在性（对应日志中的第一条SQL），因为@ManyToOne(optional=false)要求关联的User必须存在。
   • 第二种方式中，findById获取的User是**持久化状态（managed）**的，已在持久化上下文中。此时保存Contact时，Hibernate同样会验证User存在性，但实体已在上下文内，理论上可避免重复查询——不过你的日志仍显示查询，是因为findById默认立即加载实体（即使是LAZY关联），而第一种方式里Hibernate需要确认游离态User的有效性，因此也触发了查询。

2. 性能与内存开销

   • 若业务无需使用User的其他属性，第一种方式可避免将完整User实体加载到内存，节省内存开销。单条操作中差异不明显，但批量插入时优势会更显著。

3. 异常触发时机

   • 第二种方式中，findById().get()若找不到User会直接抛出NoSuchElementException，可在业务层提前捕获处理；第一种方式则会在执行INSERT时触发数据库外键约束异常ConstraintViolationException，异常发生时机更晚。

第一种方式的安全性与注意事项 #

第一种方式可以安全使用，但需注意以下几点：

• 外键约束与数据存在性：必须确保数据库中存在对应User记录，否则会触发数据库外键约束异常。若业务允许userId不存在，需修改@ManyToOne(optional=true)并处理null情况。
• 游离态实体的修改限制：若后续对Contact关联的User执行修改操作（如contact.getUser().setUsername("newName")），游离态User不会被Hibernate自动同步到数据库；而第二种方式的持久态User则会自动同步。
• MapStruct映射正确性：确保仅映射User的id字段，避免误映射其他属性导致游离态User出现不一致值，引发不必要问题。
• LAZY加载的一致性：两种方式下，后续访问Contact关联的User属性（如contact.getUser().getUsername()）都会触发懒加载查询，行为一致。

总结 #

• 若业务无需使用User其他属性，第一种方式更高效，减少内存占用；
• 若需提前验证User存在性，或后续要操作User实体，第二种方式更合适，能更早发现错误，且持久态实体便于后续操作；
• 两种方式的插入结果一致，核心差异在于实体状态、异常时机和后续操作的灵活性。

内容的提问来源于stack exchange，提问作者Rain