Spring Boot3.4+Java21：如何基于复合候选键用saveAll更新数据？

Spring Boot 3.4默认集成Hibernate 6.x，它是JPA 3.1的官方实现，完全支持通过复合业务键（你的customerId+brandId）实现按需保存，无需修改现有表结构。下面是几种可行方案：

方案一：利用Hibernate @NaturalId实现单条/批量按需保存 #

@NaturalId是Hibernate提供的扩展注解，用来标记业务层面的唯一键（即你的复合候选键），配合EntityManager的merge()方法可自动识别数据是否存在，实现按需更新/插入。

1. 修改实体类 #

给复合候选键字段添加@NaturalId注解，同时规范字段与数据库列的映射：

@Entity
@Table(name = "customer_prefs", 
       uniqueConstraints = @UniqueConstraint(columnNames = {"customer_id", "brand_id"})) // 与表结构的唯一约束对应
public class CustomerPrefs {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @NaturalId
    @Column(name = "customer_id", nullable = false)
    private Long customerId;

    @NaturalId
    @Column(name = "brand_id", nullable = false)
    private Long brandId;

    @Column(name = "customer_name", nullable = false)
    private String customerName;

    @Column(name = "customer_pref", nullable = false)
    private String customerPref;

    // 构造器、getter/setter省略
}

2. 自定义Repository实现批量处理 #

Spring Data JPA的saveAll()默认依赖@Id判断操作类型，因此需要自定义方法，通过EntityManager批量执行merge()：

@Repository
public class CustomerPrefsRepositoryImpl {
    @PersistenceContext
    private EntityManager entityManager;

    @Transactional
    public void saveOrUpdateAll(List<CustomerPrefs> prefsList) {
        for (CustomerPrefs prefs : prefsList) {
            entityManager.merge(prefs);
        }
    }
}

说明：merge()会先根据@NaturalId查询数据库中是否存在对应记录，存在则更新，不存在则插入。如果数据量极大，可配合@BatchSize注解优化批量操作性能。

方案二：原生SQL批量Upsert（性能最优） #

如果每日导入的数据量很大，使用原生数据库的Upsert语法（比如PostgreSQL的ON CONFLICT）是性能最高的方案，直接在数据库层面完成批量判断和操作。

1. 在Spring Data Repository中定义自定义批量Upsert方法 #

public interface CustomerPrefsRepository extends JpaRepository<CustomerPrefs, Long> {
    @Transactional
    @Modifying
    @Query(value = """
            INSERT INTO customer_prefs (customer_id, brand_id, customer_name, customer_pref)
            VALUES (:customerId, :brandId, :customerName, :customerPref)
            ON CONFLICT (customer_id, brand_id) DO UPDATE 
            SET customer_name = EXCLUDED.customer_name, customer_pref = EXCLUDED.customer_pref
            """, nativeQuery = true)
    void upsert(@Param("customerId") Long customerId, 
                @Param("brandId") Long brandId, 
                @Param("customerName") String customerName, 
                @Param("customerPref") String customerPref);

    // 批量版本（适配PostgreSQL批量VALUES语法，可根据数据库调整）
    @Transactional
    @Modifying
    @Query(value = """
            INSERT INTO customer_prefs (customer_id, brand_id, customer_name, customer_pref)
            VALUES (?1, ?2, ?3, ?4), (?5, ?6, ?7, ?8)
            ON CONFLICT (customer_id, brand_id) DO UPDATE 
            SET customer_name = EXCLUDED.customer_name, customer_pref = EXCLUDED.customer_pref
            """, nativeQuery = true)
    void batchUpsert(List<Object[]> batchParams);
}

注：不同数据库的Upsert语法不同，比如MySQL用ON DUPLICATE KEY UPDATE，Oracle用MERGE INTO，需根据你的数据库类型调整SQL。

方案三：Spring Data JPA分组处理（兼容所有JPA实现） #

如果不想依赖Hibernate扩展或原生SQL，可以先批量查询已存在的复合键，再将导入数据分为“插入组”和“更新组”分别处理：

1. 扩展Repository添加批量查询方法 #

public interface CustomerPrefsRepository extends JpaRepository<CustomerPrefs, Long> {
    List<CustomerPrefs> findByCustomerIdInAndBrandIdIn(List<Long> customerIds, List<Long> brandIds);
    CustomerPrefs findByCustomerIdAndBrandId(Long customerId, Long brandId);
}

2. 业务层处理逻辑 #

@Service
public class CustomerPrefsService {
    @Autowired
    private CustomerPrefsRepository repository;

    @Transactional
    public void batchSaveOrUpdate(List<CustomerPrefs> importList) {
        // 提取所有导入数据的复合键（用字符串拼接作为唯一标识）
        Set<String> importKeys = importList.stream()
                .map(p -> p.getCustomerId() + ":" + p.getBrandId())
                .collect(Collectors.toSet());

        // 查询数据库中已存在的复合键
        List<Long> customerIds = importList.stream().map(CustomerPrefs::getCustomerId).toList();
        List<Long> brandIds = importList.stream().map(CustomerPrefs::getBrandId).toList();
        Set<String> existingKeys = repository.findByCustomerIdInAndBrandIdIn(customerIds, brandIds).stream()
                .map(p -> p.getCustomerId() + ":" + p.getBrandId())
                .collect(Collectors.toSet());

        // 分组处理：插入新数据，更新已有数据
        List<CustomerPrefs> toInsert = importList.stream()
                .filter(p -> !existingKeys.contains(p.getCustomerId() + ":" + p.getBrandId()))
                .toList();
        List<CustomerPrefs> toUpdate = importList.stream()
                .filter(p -> existingKeys.contains(p.getCustomerId() + ":" + p.getBrandId()))
                .map(p -> {
                    // 从数据库获取已有记录的id，设置到导入对象中
                    CustomerPrefs existing = repository.findByCustomerIdAndBrandId(p.getCustomerId(), p.getBrandId());
                    p.setId(existing.getId());
                    return p;
                })
                .toList();

        repository.saveAll(toInsert);
        repository.saveAll(toUpdate);
    }
}

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