如何让泛型Spring Data JPA Repository的findAll()返回指定实体？

首先明确：直接使用泛型AnimalRepository<T>.findAll()无法自动只返回T类型的实例。原因在于Spring Data JPA启动时泛型类型会被擦除，它无法从泛型参数中确定具体的子类类型；加上你用的是JOINED继承策略，默认的findAll()会从父类Animal表查询并关联所有子类表，最终返回所有Animal子类的实例。

下面是几种从优雅到实用的解决方案，帮你避免为每个子类重复创建Repository和Service：

方案1：自定义泛型Repository实现（最优解） #

通过重写findAll()方法，利用JPA的Criteria API直接针对泛型对应的子类类型查询，这样就能自动过滤出目标类型的实例。

步骤1：定义自定义Repository接口 #

public interface CustomAnimalRepository<T extends Animal> {
    // 重写findAll方法，确保只返回T类型实例
    List<T> findAll();
}

步骤2：实现自定义Repository逻辑 #

public class CustomAnimalRepositoryImpl<T extends Animal> implements CustomAnimalRepository<T> {

    @PersistenceContext
    private EntityManager entityManager;
    private final Class<T> entityType;

    public CustomAnimalRepositoryImpl() {
        // 利用Spring的GenericTypeResolver解析泛型参数，获取实际的子类类型
        this.entityType = (Class<T>) GenericTypeResolver.resolveTypeArgument(
            getClass(), CustomAnimalRepositoryImpl.class
        );
    }

    @Override
    public List<T> findAll() {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<T> query = cb.createQuery(entityType);
        Root<T> root = query.from(entityType);
        query.select(root);
        return entityManager.createQuery(query).getResultList();
    }
}

步骤3：让泛型Repository继承自定义接口 #

public interface AnimalRepository<T extends Animal> 
    extends JpaRepository<T, Long>, CustomAnimalRepository<T> { }

这样修改后，你的AnimalServiceImpl<T>.findAll()调用的就是我们自定义的方法，只会返回T对应的子类实例，比如AnimalRepository<Dog>.findAll()只会返回Dog对象。

方案2：添加基于类型的查询方法 #

在泛型Repository中新增一个带类型参数的查询方法，手动指定要查询的子类类型，然后在Service中调用该方法。

修改AnimalRepository #

public interface AnimalRepository<T extends Animal> extends JpaRepository<T, Long> {
    @Query("SELECT a FROM Animal a WHERE TYPE(a) = :type")
    List<T> findAllByType(@Param("type") Class<T> type);
}

修改AnimalServiceImpl #

@Service("animalService")
public class AnimalServiceImpl<T extends Animal> implements AnimalService<T> {
    private final AnimalRepository<T> animalRepository;
    private final Class<T> entityType;

    @Autowired
    public AnimalServiceImpl(AnimalRepository<T> animalRepository) {
        this.animalRepository = animalRepository;
        // 解析当前Service的泛型参数，获取实际子类类型
        this.entityType = (Class<T>) GenericTypeResolver.resolveTypeArgument(
            getClass(), AnimalServiceImpl.class
        );
    }

    @Override
    public List<T> findAll() {
        return animalRepository.findAllByType(entityType);
    }
}

这个方案比自定义实现更轻量，但需要手动调用带类型参数的方法，适合不想重写整个Repository实现的场景。

方案3：用工厂模式管理子类Repository #

如果需要保留每个子类的Repository实例，但不想写大量重复的Service，可以用工厂类来动态获取对应的Repository。

步骤1：为每个子类创建Repository（仅需一次） #

@Repository
public interface DogRepository extends AnimalRepository<Dog> { }

@Repository
public interface CapybaraRepository extends AnimalRepository<Capybara> { }

步骤2：实现Repository工厂 #

@Component
public class AnimalRepositoryFactory {
    private final Map<String, AnimalRepository<? extends Animal>> repositoryMap;

    // Spring会自动注入所有AnimalRepository类型的Bean
    @Autowired
    public AnimalRepositoryFactory(Map<String, AnimalRepository<? extends Animal>> repositoryMap) {
        this.repositoryMap = repositoryMap;
    }

    @SuppressWarnings("unchecked")
    public <T extends Animal> AnimalRepository<T> getRepository(Class<T> animalType) {
        // 按Spring默认的Bean命名规则（类名首字母小写+Repository）查找
        String beanName = StringUtils.uncapitalize(animalType.getSimpleName()) + "Repository";
        return (AnimalRepository<T>) repositoryMap.get(beanName);
    }
}

使用工厂获取Repository #

比如在业务代码中：

@Autowired
private AnimalRepositoryFactory repositoryFactory;

public void someBusinessMethod() {
    AnimalRepository<Dog> dogRepo = repositoryFactory.getRepository(Dog.class);
    List<Dog> dogs = dogRepo.findAll();
}

这个方案适合需要灵活切换不同子类Repository的场景，但需要为每个子类创建对应的Repository接口（不过代码量极少，只是继承泛型接口而已）。

内容的提问来源于stack exchange，提问作者Cleyton Gonçalves