Hibernate：如何在继承关系中为Core实体更新External子类数据

Alright, let's tackle this Hibernate inheritance scenario you're dealing with. From what I understand, you have Core as the base entity, External extending it, and you need to update External data through a managed Core instance—including cases where no External record exists yet. Here are a few practical solutions tailored to your setup:

1. Handle Existing External Records Directly #

If the managed Core instance is actually an External under the hood (i.e., an External record exists in the database), you can simply check its type, cast it, and update the fields directly. Since the instance is already managed by Hibernate, changes will automatically sync to the database when the transaction commits.

// Assume `core` is a managed instance fetched from Hibernate
if (core instanceof External) {
    External external = (External) core;
    // Update your External-specific fields
    external.setExternalDetail("Updated external data");
    // No need for manual merge()—Hibernate tracks managed instances
}

2. Create & Update External for Pure Core Records #

When the Core instance has no corresponding External record (it's a pure Core entity), you'll need to convert it to an External instance. The approach varies slightly based on your inheritance strategy:

For Single-Table Inheritance #

This is the most common case where both Core and External share the same database table (with a discriminator column). You'll need to:

1. Detach the managed Core instance to avoid conflicts.
2. Create a new External instance and copy all Core properties.
3. Set your External-specific fields.
4. Merge the new External instance—Hibernate will update the discriminator column and add the new fields to the existing record.

Session session = entityManager.unwrap(Session.class);

// Detach the managed Core to prevent Hibernate from tracking it
session.detach(core);

// Create External instance and copy Core properties
External external = new External();
external.setId(core.getId());
external.setCoreField1(core.getCoreField1());
external.setCoreField2(core.getCoreField2());

// Set External-specific data
external.setExternalField("New external value");

// Merge to update the database record
external = session.merge(external);

For Joined Inheritance #

If Core and External are stored in separate tables (joined by primary key), you don't need to detach the Core instance. Simply create an External instance linked to the Core's ID and save it:

External external = new External();
external.setId(core.getId()); // Link to the existing Core record
external.setExternalField("New external data");

entityManager.persist(external);

3. Wrap It in a Reusable Utility Method #

To avoid repeating code across your application, encapsulate the logic into a utility method. You can use something like Spring's BeanUtils to simplify property copying:

import org.springframework.beans.BeanUtils;

public External updateCoreToExternal(Core core, Consumer<External> updater) {
    Session session = entityManager.unwrap(Session.class);
    External external;

    if (core instanceof External) {
        external = (External) core;
    } else {
        external = new External();
        BeanUtils.copyProperties(core, external); // Copy all Core properties
        session.detach(core);
    }

    // Apply the desired updates to External
    updater.accept(external);

    // Merge only if we created a new External instance
    if (!(core instanceof External)) {
        external = session.merge(external);
    }

    return external;
}

Use it like this:

updateCoreToExternal(core, ext -> {
    ext.setExternalField("Updated value");
    ext.setAnotherExternalField("More data");
});

Key Notes to Keep in Mind #

• Transaction Boundaries: All these operations must run within an active transaction—Hibernate won't sync changes to the database otherwise.
• Discriminator Column: For single-table inheritance, ensure your entities have @DiscriminatorColumn and @DiscriminatorValue configured correctly. Hibernate handles updating this column automatically when converting Core to External.
• Batch Updates: If you need to update multiple records at once, use a JPQL update query instead of loading individual instances—it's much more efficient:

  String jpql = "UPDATE External e SET e.externalField = :value WHERE e.id = :coreId";
  entityManager.createQuery(jpql)
          .setParameter("value", "Bulk updated value")
          .setParameter("coreId", core.getId())
          .executeUpdate();
  

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