咨询：整合JpaRepository与QueryDslPredicateExecutor的设计模式

完全可以实现你的需求！这里推荐结合Spring Data的自定义仓储扩展机制，搭配一个独立的QueryDSL查询处理器类，既可以通过单个接口对外暴露整合后的能力，又能把QueryDSL相关逻辑完全隔离，还不需要直接操作EntityManager。

1. 定义统一的顶层仓储接口（单个入口） #

首先创建一个统一的基础仓储接口，整合Spring Data的标准CRUD能力，同时声明你需要的QueryDSL相关查询方法：

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.repository.NoRepositoryBean;
import java.util.List;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;

@NoRepositoryBean // 告诉Spring这不是一个可实例化的Repository
public interface BaseRepository<T, ID> extends JpaRepository<T, ID> {
    // 声明QueryDSL相关的自定义方法，比如按动态条件查询
    List<T> findByDynamicConditions(com.querydsl.core.types.Predicate predicate);
    
    // 带分页的动态条件查询
    Page<T> findByDynamicConditionsWithPage(com.querydsl.core.types.Predicate predicate, Pageable pageable);
}

2. 实现独立的QueryDSL查询处理器 #

创建一个专门的类来封装所有QueryDSL相关的查询逻辑，这里我们借助Spring Data提供的QuerydslRepositorySupport来避免直接操作EntityManager——它已经帮我们封装好了EntityManager的操作：

import com.querydsl.core.types.Predicate;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.querydsl.QuerydslRepositorySupport;
import org.springframework.stereotype.Component;

@Component
public class QueryDslQueryHandler<T> extends QuerydslRepositorySupport {

    public QueryDslQueryHandler(Class<T> domainClass) {
        super(domainClass);
    }

    // 实现动态条件查询
    public List<T> findByPredicate(Predicate predicate) {
        return getQuerydsl().createQuery().select(from(getDomainClass())).where(predicate).fetch();
    }

    // 实现带分页的动态条件查询
    public Page<T> findByPredicateWithPage(Predicate predicate, Pageable pageable) {
        return findAll(predicate, pageable);
    }
}

3. 实现顶层仓储的基础实现类 #

接下来创建BaseRepository的实现类，依赖上面的QueryDSL查询处理器，把QueryDSL方法的调用委托给处理器：

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.support.SimpleJpaRepository;
import org.springframework.stereotype.Repository;
import javax.persistence.EntityManager;
import java.util.List;

@Repository
public class BaseRepositoryImpl<T, ID> extends SimpleJpaRepository<T, ID> implements BaseRepository<T, ID> {

    private final QueryDslQueryHandler<T> queryHandler;

    // 构造函数注入EntityManager和QueryDSL处理器
    public BaseRepositoryImpl(Class<T> domainClass, EntityManager entityManager, QueryDslQueryHandler<T> queryHandler) {
        super(domainClass, entityManager);
        this.queryHandler = queryHandler;
    }

    @Override
    public List<T> findByDynamicConditions(Predicate predicate) {
        return queryHandler.findByPredicate(predicate);
    }

    @Override
    public Page<T> findByDynamicConditionsWithPage(Predicate predicate, Pageable pageable) {
        return queryHandler.findByPredicateWithPage(predicate, pageable);
    }
}

4. 配置Spring Data使用自定义的基础仓储实现 #

最后需要告诉Spring Data，所有继承BaseRepository的接口都使用我们的BaseRepositoryImpl作为默认实现，这里提供两种配置方式：

方式1：Java配置类 #

import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableJpaRepositories(
        basePackages = "com.yourpackage.repository", // 替换为你的Repository所在包路径
        repositoryBaseClass = BaseRepositoryImpl.class // 指定自定义的基础实现类
)
public class JpaConfig {
}

方式2：application.properties配置 #

spring.data.jpa.repositories.base-class=com.yourpackage.repository.BaseRepositoryImpl

5. 实际使用示例 #

现在你可以创建具体的领域仓储接口，只需要继承BaseRepository，就能同时拥有Spring Data的CRUD能力和QueryDSL的动态查询能力：

import com.yourpackage.domain.User;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends BaseRepository<User, Long> {
    // 这里可以添加Spring Data风格的自定义查询方法，也可以直接用BaseRepository里的QueryDSL方法
}

在业务层调用时，直接注入UserRepository即可，完全不用关心底层的整合细节：

import com.yourpackage.domain.QUser;
import com.yourpackage.repository.UserRepository;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public List<User> getActiveUsers(String keyword) {
        QUser qUser = QUser.user;
        // 构建QueryDSL条件
        var predicate = qUser.isActive.isTrue().and(qUser.username.contains(keyword));
        // 调用统一接口的方法
        return userRepository.findByDynamicConditions(predicate);
    }
}

方案优势匹配你的需求 #

• 单个接口整合：业务代码只需要依赖具体的Repository接口，它继承了BaseRepository，同时包含Spring Data的CRUD和自定义的QueryDSL方法，对外是统一入口。
• QueryDSL逻辑独立：所有QueryDSL相关的查询逻辑都封装在QueryDslQueryHandler里，和仓储实现类解耦，便于维护和扩展。
• 无需直接操作EntityManager：借助Spring Data的QuerydslRepositorySupport和SimpleJpaRepository，已经帮我们封装了EntityManager的操作，不用自己编写相关代码。

内容的提问来源于stack exchange，提问作者MK-rou