Spring Boot 处理 ManyToOne 实体更新与创建技巧

理解 ManyToOne 关系与实体操作的挑战

在 Spring Boot 和 JPA 应用中，当一个实体（例如 Flight）与多个其他实体（例如 Airport、Airline、Airplane）存在 ManyToOne 关系时，通常在持久化操作（如保存或更新）中，JPA 框架期望获得完整的关联实体对象。例如，Flight 实体定义如下：

@Entity
@Table
public class Flight {
    @Id
    @Column(name = "flight_number")
    private String flightNumber;

    @ManyToOne
    @JoinColumn(name = "origin")
    private Airport origin; // 关联 Airport 对象

    @ManyToOne
    @JoinColumn(name = "destination")
    private Airport destination; // 关联 Airport 对象

    @Column(name = "departure_time")
    private Timestamp departureTime;

    @Column(name = "arrival_time")
    private Timestamp arrivalTime;

    @ManyToOne
    @JoinColumn(name = "airline")
    private Airline airline; // 关联 Airline 对象

    @ManyToOne
    @JoinColumn(name = "airplane")
    private Airplane airplane; // 关联 Airplane 对象

    private Time duration;
    private int passengers;

    // Getters and Setters
    // ...
}

直接将外部传入的关联实体ID（如机场ID、航空公司ID）赋值给 Flight 实体中的 Airport 或 Airline 字段是不可行的，因为这些字段期望的是 Airport 或 Airline 类型的对象，而非简单的字符串或长整型ID。如果尝试通过自定义 @Query 并直接传递ID字符串进行更新，JPA 会因类型不匹配而报错。

解决方案：DTOs 与服务层映射

为了解决上述问题，最佳实践是引入数据传输对象（DTO）并在服务层进行映射。

1. 定义数据传输对象 (DTO)

首先，创建一个 DTO 来表示客户端请求的数据，其中包含关联实体的 ID，而不是完整的对象。

import java.sql.Time;
import java.sql.Timestamp;

public record FlightRequest(
        String flightNumber,
        String airportOriginId, // 仅传入始发机场ID
        String airportDestinationId, // 仅传入目的机场ID
        Timestamp departureTime,
        Timestamp arrivalTime,
        String airlineId, // 仅传入航空公司ID
        Long airplaneId, // 仅传入飞机ID
        Time duration,
        int passengers
        // ... 其他字段
) {
}

这里使用了 Java 16+ 的 record 特性，它是一种简洁的 DTO 定义方式。如果使用旧版本 Java，可以定义一个常规的 Java 类，并包含相应的字段、构造函数和 getter/setter。

2. 服务层处理逻辑

在服务层，我们将接收 FlightRequest DTO，然后根据 DTO 中提供的 ID 从数据库中检索出对应的关联实体，并将它们设置到 Flight 实体中。

创建新航班 (addFlight)

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Optional;

@Service
public class FlightService {

    private final FlightRepository flightRepository;
    private final AirportRepository airportRepository;
    private final AirlineRepository airlineRepository;
    private final AirplaneRepository airplaneRepository;

    public FlightService(FlightRepository flightRepository,
                         AirportRepository airportRepository,
                         AirlineRepository airlineRepository,
                         AirplaneRepository airplaneRepository) {
        this.flightRepository = flightRepository;
        this.airportRepository = airportRepository;
        this.airlineRepository = airlineRepository;
        this.airplaneRepository = airplaneRepository;
    }

    @Transactional
    public Flight addFlight(FlightRequest flightRequest) {
        if (flightRepository.existsById(flightRequest.flightNumber())) {
            throw new IllegalStateException("航班号 " + flightRequest.flightNumber() + " 已存在");
        }

        Flight flight = new Flight();

        // 根据ID查找并设置关联实体，如果不存在则抛出异常
        Airport origin = airportRepository.findById(flightRequest.airportOriginId())
                .orElseThrow(() -> new IllegalStateException("始发机场 " + flightRequest.airportOriginId() + " 不存在"));
        flight.setOrigin(origin);

        Airport destination = airportRepository.findById(flightRequest.airportDestinationId())
                .orElseThrow(() -> new IllegalStateException("目的机场 " + flightRequest.airportDestinationId() + " 不存在"));
        flight.setDestination(destination);

        Airline airline = airlineRepository.findById(flightRequest.airlineId())
                .orElseThrow(() -> new IllegalStateException("航空公司 " + flightRequest.airlineId() + " 不存在"));
        flight.setAirline(airline);

        Airplane airplane = airplaneRepository.findById(flightRequest.airplaneId())
                .orElseThrow(() -> new IllegalStateException("飞机 " + flightRequest.airplaneId() + " 不存在"));
        flight.setAirplane(airplane);

        // 设置 Flight 的其他属性
        flight.setFlightNumber(flightRequest.flightNumber());
        flight.setDepartureTime(flightRequest.departureTime());
        flight.setArrivalTime(flightRequest.arrivalTime());
        flight.setDuration(flightRequest.duration());
        flight.setPassengers(flightRequest.passengers());

        return flightRepository.save(flight);
    }
}

更新现有航班 (updateFlight)

更新操作与创建类似，但需要先根据主键查找要更新的 Flight 实体。

    @Transactional
    public Flight updateFlight(String flightNumber, FlightRequest flightRequest) {
        Flight flight = flightRepository.findById(flightNumber)
                .orElseThrow(() -> new IllegalStateException("航班号 " + flightNumber + " 不存在，无法更新"));

        // 根据ID查找并设置关联实体，如果不存在则抛出异常
        // 注意：这里可以根据业务需求判断是否需要更新关联实体
        if (flightRequest.airportOriginId() != null) {
            Airport origin = airportRepository.findById(flightRequest.airportOriginId())
                    .orElseThrow(() -> new IllegalStateException("始发机场 " + flightRequest.airportOriginId() + " 不存在"));
            flight.setOrigin(origin);
        }
        if (flightRequest.airportDestinationId() != null) {
            Airport destination = airportRepository.findById(flightRequest.airportDestinationId())
                    .orElseThrow(() -> new IllegalStateException("目的机场 " + flightRequest.airportDestinationId() + " 不存在"));
            flight.setDestination(destination);
        }
        if (flightRequest.airlineId() != null) {
            Airline airline = airlineRepository.findById(flightRequest.airlineId())
                    .orElseThrow(() -> new IllegalStateException("航空公司 " + flightRequest.airlineId() + " 不存在"));
            flight.setAirline(airline);
        }
        if (flightRequest.airplaneId() != null) {
            Airplane airplane = airplaneRepository.findById(flightRequest.airplaneId())
                    .orElseThrow(() -> new IllegalStateException("飞机 " + flightRequest.airplaneId() + " 不存在"));
            flight.setAirplane(airplane);
        }

        // 更新 Flight 的其他属性
        // 仅更新 FlightRequest 中非空的字段，以支持部分更新
        Optional.ofNullable(flightRequest.departureTime()).ifPresent(flight::setDepartureTime);
        Optional.ofNullable(flightRequest.arrivalTime()).ifPresent(flight::setArrivalTime);
        Optional.ofNullable(flightRequest.duration()).ifPresent(flight::setDuration);
        if (flightRequest.passengers() > 0) { // 假设乘客数大于0才更新
            flight.setPassengers(flightRequest.passengers());
        }
        // ... 其他属性的更新

        return flightRepository.save(flight); // save方法会根据ID判断是插入还是更新
    }

性能优化：使用 getReferenceById

从 Spring Data JPA 2.7 版本开始，JpaRepository 接口提供了 getReferenceById(ID id) 方法（在旧版本中是 getById(ID id)）。这个方法与 findById 的主要区别在于：

• findById: 会立即执行数据库查询，返回一个 Optional，如果实体不存在，则返回 Optional.empty()。
• getReferenceById: 不会立即执行数据库查询，而是返回一个代理（Proxy）对象。只有当你尝试访问这个代理对象的非ID属性时，JPA 才会去数据库加载实际数据。这意味着，如果你仅仅需要设置一个外键关联，而不需要访问关联实体的其他属性，使用 getReferenceById 可以避免一次不必要的 SELECT 查询，从而提升性能。

使用 getReferenceById 优化服务层逻辑：

    @Transactional
    public Flight addFlightOptimized(FlightRequest flightRequest) {
        if (flightRepository.existsById(flightRequest.flightNumber())) {
            throw new IllegalStateException("航班号 " + flightRequest.flightNumber() + " 已存在");
        }

        Flight flight = new Flight();

        // 使用 getReferenceById 获取关联实体的代理对象
        // 注意：getReferenceById 不会检查实体是否存在，如果ID不存在，后续访问代理对象时会抛出 EntityNotFoundException
        // 因此，如果业务上需要严格检查关联实体是否存在，仍建议使用 findById
        flight.setOrigin(airportRepository.getReferenceById(flightRequest.airportOriginId()));
        flight.setDestination(airportRepository.getReferenceById(flightRequest.airportDestinationId()));
        flight.setAirline(airlineRepository.getReferenceById(flightRequest.airlineId()));
        flight.setAirplane(airplaneRepository.getReferenceById(flightRequest.airplaneId()));

        // 设置 Flight 的其他属性
        flight.setFlightNumber(flightRequest.flightNumber());
        flight.setDepartureTime(flightRequest.departureTime());
        flight.setArrivalTime(flightRequest.arrivalTime());
        flight.setDuration(flightRequest.duration());
        flight.setPassengers(flightRequest.passengers());

        return flightRepository.save(flight);
    }

注意事项：

• getReferenceById 适用于你确定关联实体存在，或者不关心其是否存在（JPA 会在需要时抛出异常）的场景。
• 如果关联实体不存在，getReferenceById 返回的代理对象在首次访问其非ID属性时会抛出 jakarta.persistence.EntityNotFoundException。因此，如果业务逻辑要求在保存前验证所有关联实体都存在，findById 配合 orElseThrow 仍然是更安全的做法。

总结与最佳实践

在 Spring Boot 中处理 ManyToOne 关联实体的创建和更新，推荐采用以下策略：

1. 使用 DTOs 作为 API 输入/输出： 隔离领域模型与外部接口，提高灵活性和安全性。对于关联实体，DTO 只需包含其 ID。
2. 服务层负责 DTO 到实体映射： 在服务层根据 DTO 中的 ID 查找并设置关联实体，确保领域模型的完整性。
3. 合理选择 findById 或 getReferenceById：
   • 当需要验证关联实体是否存在，或需要访问关联实体的其他属性时，使用 findById。
   • 当仅需要设置外键关联，且不关心或已确保关联实体存在时，使用 getReferenceById 来避免不必要的数据库查询，提升性能。
4. 完善错误处理： 对于关联实体不存在的情况，及时抛出明确的业务异常，提高系统的健壮性。
5. 事务管理： 确保服务层方法被 @Transactional 注解，以保证数据库操作的原子性和一致性。

通过遵循这些实践，您可以有效地管理 Spring Boot 应用中的 ManyToOne 关系，使代码更清晰、更健壮，并具备更好的性能。