Hibernate中如何正确注解引用接口的List类型属性？

Hey there! I get it—working with interfaces in Hibernate can feel confusing at first, since Hibernate relies on concrete entity classes for its persistence mappings. Let’s break down exactly how to handle your scenario where you have a MarketOrder interface implemented by the MarketOrderImpl entity class.

First, let’s make sure your MarketOrderImpl is properly set up as an entity (you already have a great start here):

import jakarta.persistence.*;
import java.math.BigDecimal;

// Your interface definition
public interface MarketOrder {
    String getId();
    OrderType getType();
    BigDecimal getPrice();
    // Add other interface methods as needed
}

// Concrete entity implementing the interface
@Entity
public final class MarketOrderImpl implements MarketOrder {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private String id;
    
    private OrderType type;
    private BigDecimal price;
    private BigDecimal quantity;
    private BigDecimal total;

    // Default constructor (required by Hibernate)
    public MarketOrderImpl() {}

    // Parameterized constructor, getters, setters, and interface method implementations
}

Now, if you have another entity (let’s use Trader as an example) that needs to hold a list of MarketOrder instances, you need to explicitly tell Hibernate which concrete class to map to—since interfaces can’t be persisted directly. Here’s how to do that:

Annotating the List of Interface Type #

Use the targetEntity attribute in your @OneToMany annotation to point to the MarketOrderImpl class:

@Entity
public class Trader {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;

    // Map the List<MarketOrder> to its concrete implementation
    @OneToMany(targetEntity = MarketOrderImpl.class, cascade = CascadeType.ALL, orphanRemoval = true)
    @JoinColumn(name = "trader_id") // Explicitly defines the foreign key column in the MarketOrderImpl table
    private List<MarketOrder> orders = new ArrayList<>();

    // Constructors, getters, setters
}

Key Details to Remember: #

• targetEntity: This is critical—it tells Hibernate that even though the list is declared using the MarketOrder interface, the actual persisted entities are MarketOrderImpl instances.
• Cascade & Orphan Removal: Add these attributes if you want operations (like saving/deleting a Trader) to automatically apply to its associated MarketOrder instances. Adjust based on your business logic needs.
• @JoinColumn: Optional but recommended—this avoids Hibernate creating a separate join table and instead uses a foreign key column directly in the MarketOrderImpl table.

If You Add Multiple Interface Implementations Later #

If you ever introduce another class that implements MarketOrder (e.g., LimitOrderImpl), you’ll need to use Hibernate’s inheritance mapping. For example, you could use @Inheritance(strategy = InheritanceType.SINGLE_TABLE) on a base entity class, or add a @DiscriminatorColumn to distinguish between different implementations. But since you’re just starting out, focus on the single-implementation case first.

That should solve your annotation issue! Let me know if you run into any unexpected behavior with the mapping.

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