如何通过通用DAO与服务层获取特定继承实体？Spring MVC问题求助

Hey there! Based on your setup where UnitAppUser, VStanAppUser, and RjuAppUser inherit from a base User entity using the JOINED inheritance strategy, I’ll walk through the most common pitfalls and solutions you might run into.

First, let’s recap your setup for clarity:

• Your base User entity holds generic user data and maps to the app_user table
• Each child entity adds a reference to a specific domain object (like Unit for UnitAppUser)
• Your base User code starts like this:

@Entity
@Inheritance(strategy=InheritanceType.JOINED)
@Table(name="app_user")
public class User implements Serializable {
    // ... generic fields and methods
}

Common Problems & Solutions #

1. Correctly Mapping Child Entity Associations #

When adding the specific entity references to your child classes, you need to properly configure JPA association annotations to avoid mapping errors. For example, here’s how to set up UnitAppUser with a Unit reference:

@Entity
@Table(name="unit_app_user")
public class UnitAppUser extends User {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "unit_id", nullable = false)
    private Unit unit;

    // Getters, setters, and constructors
}

Pro tip: Use FetchType.LAZY to avoid loading the associated Unit until it’s explicitly needed—this keeps your queries performant. For one-to-one relationships, use @OneToOne(optional = false) to enforce that the association exists.

2. Polymorphic Queries & Type Safety #

When querying User records, JPA will automatically return the correct child class instances. If you need to filter for a specific child type, use JPQL’s TYPE operator:

// Fetch all UnitAppUser instances
List<UnitAppUser> unitUsers = entityManager.createQuery(
    "SELECT u FROM User u WHERE TYPE(u) = UnitAppUser", UnitAppUser.class
).getResultList();

Or if you’re using Spring Data JPA, leverage derived queries for cleaner code:

public interface UserRepository extends JpaRepository<User, Long> {
    List<UnitAppUser> findByUnit(Unit unit);
}

3. Saving Child Entities Without Primary Key Conflicts #

Your base User should define the primary key strategy, and child entities should inherit it—don’t redefine the ID field in child classes. For example, in User:

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;

When you save a UnitAppUser, JPA will automatically insert a record into both app_user and unit_app_user with the same ID, avoiding duplicate key issues.

4. Fixing N+1 Query Performance Issues #

If you’re fetching User records and need their associated domain objects (like Unit), avoid the N+1 query problem by using JOIN FETCH in JPQL:

List<UnitAppUser> unitUsers = entityManager.createQuery(
    "SELECT u FROM UnitAppUser u JOIN FETCH u.unit", UnitAppUser.class
).getResultList();

For Spring Data JPA, use the @EntityGraph annotation to achieve the same:

@EntityGraph(attributePaths = "unit")
List<UnitAppUser> findAll();

5. DTO Conversion for Child Entities #

When converting child entities to DTOs (to avoid exposing internal entity structure), tools like MapStruct work great. Here’s a quick example mapper for UnitAppUser:

@Mapper(componentModel = "spring")
public interface UnitAppUserMapper {
    UnitAppUserMapper INSTANCE = Mappers.getMapper(UnitAppUserMapper.class);

    UnitAppUserDto toDto(UnitAppUser user);
}

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