Spring Boot+EclipseLink REST数据接收时JPA继承问题求助

Alright, let's work through this JPA inheritance issue you're hitting in your Spring Boot REST app. First, let's make sure I've got your class hierarchy straight:

• Base class B (presumably an entity)
• Concrete subclass C extending B
• Abstract class D extending B
• Concrete entity E extending abstract class D
• Entity A with a reference attribute attribute1 of type B, which is actually an instance of E

Since you mentioned inheritance strategy troubles, let's break down common pitfalls and fixes tailored to your setup:

1. Validate Your JPA Inheritance Strategy Configuration #

First, double-check how you've configured inheritance for your entity hierarchy—this is the root of most这类 issues. Let's cover the three standard strategies and their gotchas:

SINGLE_TABLE (Most Common for Simple Hierarchies) #

If you're using this strategy (all subclasses stored in one table with a discriminator column):

• Annotate the base class B with:

  @Entity
  @Inheritance(strategy = InheritanceType.SINGLE_TABLE)
  @DiscriminatorColumn(name = "ENTITY_TYPE", discriminatorType = DiscriminatorType.STRING)
  public class B {
      // Common fields/methods
  }
  

• For each concrete subclass, add a discriminator value. Even your abstract class D needs a value (EclipseLink handles abstract parent subclasses fine):

  @Entity
  @DiscriminatorValue("C")
  public class C extends B { /* ... */ }
  
  @Entity
  @DiscriminatorValue("D")
  public abstract class D extends B { /* ... */ }
  
  @Entity
  @DiscriminatorValue("E")
  public class E extends D { /* ... */ }
  

• Ensure your A entity's attribute is mapped correctly:

  @Entity
  public class A {
      @ManyToOne(fetch = FetchType.LAZY) // Use EAGER only if strictly necessary
      private B attribute1;
      // Other fields
  }
  

JOINED (Normalized Table Structure) #

If you're using this strategy (each class has its own table, linked via foreign keys):

• Annotate B with @Inheritance(strategy = InheritanceType.JOINED)
• Each subclass (including D and E) will map to its own table, with foreign keys linking back to B's table. When querying A, use a JOIN FETCH to load the full E instance:

  SELECT a FROM A a JOIN FETCH a.attribute1 WHERE a.id = :id
  

• In Spring Data JPA, you can wrap this in a repository method with @Query to force eager loading of the subclass data.

2. Fix Common REST Serialization/Deserialization Issues #

Since you're using a REST interface to receive data, you might hit problems where Jackson can't map incoming JSON to the correct subclass of B. Here's how to fix that:

• Add Jackson type info annotations to your base class B to tell the serializer/deserializer which subclass to use:

  import com.fasterxml.jackson.annotation.JsonTypeInfo;
  import com.fasterxml.jackson.annotation.JsonSubTypes;
  
  @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "entityType")
  @JsonSubTypes({
      @JsonSubTypes.Type(value = C.class, name = "C"),
      @JsonSubTypes.Type(value = E.class, name = "E")
  })
  @Entity
  // ... JPA inheritance annotations
  public class B { /* ... */ }
  

• When sending data from the frontend, include the entityType field in your JSON payload (e.g., "entityType": "E" for an E instance), and Jackson will correctly deserialize it into the right subclass for A's attribute1.

3. EclipseLink-Specific Tweaks #

Since your first app uses EclipseLink, if this REST app also uses it (instead of Spring's default Hibernate), add these properties to application.properties to avoid conflicts:

spring.jpa.database-platform=org.eclipse.persistence.platform.database.PostgreSQLPlatform
spring.jpa.properties.eclipse.persistence.weaving=false
spring.jpa.properties.eclipse.persistence.persistence-unit.name=yourPersistenceUnitName
spring.jpa.show-sql=true # Enable to debug generated SQL

4. Debugging Tips #

• Turn on SQL logging to verify that JPA is querying the correct tables and including discriminator values (check the properties above for EclipseLink/Hibernate logging).
• Test persistence directly (without the REST layer): Create an A instance, set attribute1 to an E instance, save it, then retrieve it to confirm the full E data is loaded.
• Inspect your PostgreSQL tables to ensure discriminator columns exist (for SINGLE_TABLE) or foreign key links are correct (for JOINED).

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