Spring通用JpaRepository实现：按实体类型动态匹配size/color查询

方法一：自定义Repository实现类（推荐） #

Spring Data JPA支持自定义Repository实现，你可以通过泛型判断实体类型，动态构建对应查询条件：

1. 拆分泛型Repository接口，抽离自定义方法：

public interface MyRepository<T extends BaseEntity, IdT> extends JpaRepository<T, IdT>, MyRepositoryCustom<T> {
}

// 自定义方法的独立接口
public interface MyRepositoryCustom<T extends BaseEntity> {
    Optional<T> findFirstByIdentifier(String identifier);
}

2. 实现自定义接口，根据实体类型动态生成查询：

@Repository
public class MyRepositoryImpl<T extends BaseEntity> implements MyRepositoryCustom<T> {

    @Autowired
    private EntityManager entityManager;

    @Override
    @SuppressWarnings("unchecked")
    public Optional<T> findFirstByIdentifier(String identifier) {
        // 获取当前泛型对应的实体类类型
        Class<T> entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass())
                .getActualTypeArguments()[0];
        
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<T> query = cb.createQuery(entityClass);
        Root<T> root = query.from(entityClass);
        
        // 根据实体类型匹配对应的查询字段
        Predicate predicate;
        if (SizeEntity.class.isAssignableFrom(entityClass)) {
            predicate = cb.equal(root.get("size"), identifier);
        } else if (ColorEntity.class.isAssignableFrom(entityClass)) {
            predicate = cb.equal(root.get("color"), identifier);
        } else {
            throw new IllegalArgumentException("不支持的实体类型: " + entityClass.getName());
        }
        
        query.select(root).where(predicate);
        return entityManager.createQuery(query).setMaxResults(1).getResultStream().findFirst();
    }
}

后续每个子类Repository（比如SizeEntityRepository extends MyRepository<SizeEntity, Long>）可以直接调用findFirstByIdentifier方法，内部会自动适配对应字段的查询。

方法二：利用Default方法封装专属查询 #

如果不想写复杂的自定义实现，可以给每个子类Repository通过default方法封装统一调用入口：

1. 定义基础Repository：

public interface BaseRepository<T extends BaseEntity, IdT> extends JpaRepository<T, IdT> {
}

2. 为每个子类创建专属Repository，实现统一方法名：

public interface SizeEntityRepository extends BaseRepository<SizeEntity, Long> {
    default Optional<SizeEntity> findFirstByIdentifier(String identifier) {
        return findFirstBySize(identifier);
    }

    Optional<SizeEntity> findFirstBySize(String size);
}

public interface ColorEntityRepository extends BaseRepository<ColorEntity, Long> {
    default Optional<ColorEntity> findFirstByIdentifier(String identifier) {
        return findFirstByColor(identifier);
    }

    Optional<ColorEntity> findFirstByColor(String color);
}

这种方式更轻量，每个子类Repository通过default方法封装自身的专属查询，上层调用时可以统一使用findFirstByIdentifier方法。

方法三：反射调用已定义的查询方法 #

如果已经在泛型Repository中定义了所有可能的查询方法，也可以通过反射动态调用：

@Repository
public class MyRepositoryImpl<T extends BaseEntity, IdT> implements MyRepositoryCustom<T> {

    @Autowired
    private MyRepository<T, IdT> repository;

    @Override
    @SuppressWarnings("unchecked")
    public Optional<T> findFirstByIdentifier(String identifier) {
        Class<T> entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass())
                .getActualTypeArguments()[0];
        
        String methodName;
        if (SizeEntity.class.isAssignableFrom(entityClass)) {
            methodName = "findFirstBySize";
        } else if (ColorEntity.class.isAssignableFrom(entityClass)) {
            methodName = "findFirstByColor";
        } else {
            throw new IllegalArgumentException("不支持的实体类型");
        }
        
        try {
            Method method = MyRepository.class.getMethod(methodName, String.class);
            return (Optional<T>) method.invoke(repository, identifier);
        } catch (Exception e) {
            throw new RuntimeException("调用查询方法失败", e);
        }
    }
}

这种方式需要确保泛型Repository中包含所有对应的查询方法，适合不想重复定义default方法的场景，但反射会带来少量性能开销。

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