Question

我正在使用Spring data jpa repositories，要求为搜索功能提供不同的字段。在搜索之前输入字段是可选的。我有5个字段说EmployeeNumber，Name，Married，Profession和DateOfBirth。
在这里，我只需要用户查询给定的值，其他字段应该被忽略.Ex，

Input : EmployeeNumber: ,Name:St,Married: ,Professsion:IT,DateOfBirth: 
Query : Select * from Employee e where Name like 'St%' and Profession like 'IT%';  

Input : EmployeeNumber:10,Name: ,Married: ,Professsion:IT,DateOfBirth:
Query : Select * from Employee e where EmployeeNumber like '10%' and Profession like 'IT%';

所以我们在这里考虑输入和查询的值。在这种情况下，Spring数据具有this post中提到的限制（不可扩展且应编写所有可能的查询）我正在使用Querydsl，但问题仍然存在，因为null字段应该被忽略，几乎所有可能的查询都需要开发。在此case 31 queries。如果搜索字段为6,7,8... ??

，该怎么办？

使用可选字段实施搜索选项的最佳方法是什么？

Answer 1

请注意，使用新版主要版本的QueryDSL（4.x）和querydsl-jpa

可能会有所更改

在我们的一个项目中，我们将QueryDSL与QueryDslPredicateExecutor<T>一起使用。

  public Predicate createPredicate(DataEntity dataEntity) {
    QDataEntity qDataEntity = QDataEntity.dataEntity;
    BooleanBuilder booleanBuilder = new BooleanBuilder();
    if (!StringUtils.isEmpty(dataEntity.getCnsiConsumerNo())) {
      booleanBuilder
        .or(qDataEntity.cnsiConsumerNo.contains(dataEntity.getCnsiConsumerNo()));
    }
    if (!StringUtils.isEmpty(dataEntity.getCnsiMeterNo())) {
      booleanBuilder.or(qDataEntity.cnsiMeterNo.contains(dataEntity.getCnsiMeterNo()));
    }

    return booleanBuilder.getValue();
  }

我们可以在存储库中使用它：

@Repository
public interface DataEntityRepository
  extends DaoRepository<DataEntity, Long> {

DaoRepository

的位置

@NoRepositoryBean
public interface DaoRepository<T, K extends Serializable>
  extends JpaRepository<T, K>,
  QueryDslPredicateExecutor<T> {
}

因为那时，您可以使用存储库谓词方法。

Iterable<DataEntity> results = dataEntityRepository.findAll(dataEntityPredicateCreator.createPredicate(dataEntity));

要获取QClasses，您需要在pom.xml中指定QueryDSL APT Maven plugin。

  <build>
    <plugins>
      <plugin>
        <groupId>com.mysema.maven</groupId>
        <artifactId>maven-apt-plugin</artifactId>
        <version>1.0.4</version>
        <executions>
          <execution>
            <phase>generate-sources</phase>
            <goals>
              <goal>process</goal>
            </goals>
            <configuration>
              <outputDirectory>target/generated-sources</outputDirectory>
              <processor>com.mysema.query.apt.jpa.JPAAnnotationProcessor</processor>
            </configuration>
          </execution>
        </executions>
      </plugin>

依赖性

    <!-- querydsl -->
    <dependency>
        <groupId>com.mysema.querydsl</groupId>
        <artifactId>querydsl-core</artifactId>
        <version>${querydsl.version}</version>
    </dependency>
    <dependency>
        <groupId>com.mysema.querydsl</groupId>
        <artifactId>querydsl-apt</artifactId>
        <version>${querydsl.version}</version>
    </dependency>
    <dependency>
        <groupId>com.mysema.querydsl</groupId>
        <artifactId>querydsl-jpa</artifactId>
        <version>${querydsl.version}</version>
    </dependency>

或Gradle：

sourceSets {
    generated
}
sourceSets.generated.java.srcDirs = ['src/main/generated']
configurations {
    querydslapt
}
dependencies {
    // other deps ....
    compile "com.mysema.querydsl:querydsl-jpa:3.6.3"
    compile "com.mysema.querydsl:querydsl-apt:3.6.3:jpa"
}
task generateQueryDSL(type: JavaCompile, group: 'build', description: 'Generates the QueryDSL query types') {
    source = sourceSets.main.java
    classpath = configurations.compile + configurations.querydslapt
    options.compilerArgs = [
            "-proc:only",
            "-processor", "com.mysema.query.apt.jpa.JPAAnnotationProcessor"
    ]
    destinationDir = sourceSets.generated.java.srcDirs.iterator().next()
}

compileJava {
    dependsOn generateQueryDSL
    source generateQueryDSL.destinationDir
}

compileGeneratedJava {
    dependsOn generateQueryDSL
    classpath += sourceSets.main.runtimeClasspath
}

Answer 2

您可以使用Spring-data为您提供开箱即用的规格。并且能够使用条件API以编程方式构建查询。要支持规范，您可以使用JpaSpecificationExecutor接口扩展存储库接口

public interface CustomerRepository extends SimpleJpaRepository<T, ID>, JpaSpecificationExecutor {

}

附加接口（JpaSpecificationExecutor）带有允许您以各种方式执行规范的方法。

例如，findAll方法将返回与规范匹配的所有实体：

List<T> findAll(Specification<T> spec);

规范界面如下：

public interface Specification<T> {
     Predicate toPredicate(Root<T> root, CriteriaQuery<?> query,
            CriteriaBuilder builder);
}

好的，那么典型的用例是什么？可以轻松地使用规范在实体之上构建可扩展的谓词集，然后可以将其与JpaRepository结合使用，而无需为每个所需组合声明查询（方法）。这是一个例子：例2.15。客户规格

public class CustomerSpecs {
    public static Specification<Customer> isLongTermCustomer() {
        return new Specification<Customer>() {
            public Predicate toPredicate(
                Root<Customer> root, CriteriaQuery<?> query,
                CriteriaBuilder builder) {
                LocalDate date = new LocalDate().minusYears(2);
                return builder.lessThan(root.get('dateField'), date);
            }
        };
    }

    public static Specification<Customer> hasSalesOfMoreThan(MontaryAmount value) {
        return new Specification<Customer>() {
            public Predicate toPredicate(
                Root<T> root, CriteriaQuery<?> query,
                CriteriaBuilder builder) {
                // build query here
            }
        };
    }
}

您在业务需求抽象级别上表达了一些标准，并创建了可执行规范。因此，客户可能会使用如下规范：

List customers = customerRepository.findAll(isLongTermCustomer());

您还可以组合规范示例2.17。组合规格

    MonetaryAmount amount = new MonetaryAmount(200.0, Currencies.DOLLAR);
    List<Customer> customers = customerRepository.findAll(
        where(isLongTermCustomer()).or(hasSalesOfMoreThan(amount)));

正如您所看到的，规格提供了一些链式胶合代码方法并结合规格。因此，扩展您的数据访问层是只需创建新的规范实现和将它们与已经存在的那些相结合。

您可以创建复杂规范，这是一个示例

public class WorkInProgressSpecification {
    public static Specification<WorkInProgress> findByCriteria(final SearchCriteria searchCriteria) {

        return new Specification<WorkInProgress>() {

            @Override
            public Predicate toPredicate(
                Root<WorkInProgress> root,
                CriteriaQuery<?> query, CriteriaBuilder cb) {

                List<Predicate> predicates = new ArrayList<Predicate>();

                if (searchCriteria.getView() != null && !searchCriteria.getView().isEmpty()) {
                    predicates.add(cb.equal(root.get("viewType"), searchCriteria.getView()));
                }
                if (searchCriteria.getFeature() != null && !searchCriteria.getFeature().isEmpty()) {
                    predicates.add(cb.equal(root.get("title"), searchCriteria.getFeature()));
                }
                if (searchCriteria.getEpic() != null && !searchCriteria.getEpic().isEmpty()) {
                    predicates.add(cb.equal(root.get("epic"), searchCriteria.getEpic()));
                }
                if (searchCriteria.getPerformingGroup() != null && !searchCriteria.getPerformingGroup().isEmpty()) {
                    predicates.add(cb.equal(root.get("performingGroup"), searchCriteria.getPerformingGroup()));
                }
                if (searchCriteria.getPlannedStartDate() != null) {
                    System.out.println("searchCriteria.getPlannedStartDate():" + searchCriteria.getPlannedStartDate());
                    predicates.add(cb.greaterThanOrEqualTo(root.<Date>get("plndStartDate"), searchCriteria.getPlannedStartDate()));
                }
                if (searchCriteria.getPlannedCompletionDate() != null) {
                    predicates.add(cb.lessThanOrEqualTo(root.<Date>get("plndComplDate"), searchCriteria.getPlannedCompletionDate()));
                }
                if (searchCriteria.getTeam() != null && !searchCriteria.getTeam().isEmpty()) {
                    predicates.add(cb.equal(root.get("agileTeam"), searchCriteria.getTeam()));
                }

                return cb.and(predicates.toArray(new Predicate[] {}));
            }
        };
    }
}

以下是JPA Respositories docs

Answer 3

从Spring Data JPA 1.10开始，另一个选项是Query By Example。您的存储库应该与JpaRepository以及QueryByExampleExecutor接口分开实现，您可以在其中获得以下方法：

<S extends T> Iterable<S> findAll(Example<S> example)

然后创建Example以搜索like：

Employee e = new Employee();
e.setEmployeeNumber(getEmployeeNumberSomewherFrom());
e.setName(getNameSomewhereFrom());
e.setMarried(getMarriedSomewhereFrom());
e.setProfession(getProfessionSomewhereFrom());
e.setDateOfBirth(getDateOfBirthSomewhereFrom());

然后：

employeeRepository.findAll(Example.of(e));

如果某些参数为null，则不会将其引入WHERE子句，因此您将获得动态查询。

要优化String属性的匹配，请查看ExampleMatcher＆＃39;

ExampleMatcher执行不区分大小写的like，例如：

ExampleMatcher matcher = ExampleMatcher.matching().
          withMatcher("profession", ExampleMatcher.GenericPropertyMatcher.of(ExampleMatcher.StringMatcher.CONTAINING).ignoreCase());

QBE示例：https://github.com/spring-projects/spring-data-examples/tree/master/jpa/query-by-example

Answer 4

游戏有点晚了，但这里的答案过于复杂……如果您更改实体的字段会怎样？如果您想支持对不同实体的搜索怎么办？

您可以只使用这个库：https://github.com/turkraft/spring-filter

它将让您运行搜索查询，例如：

<块引用>

/search?filter= average（评分）> 4.5 和brand.name （'奥迪'、'路虎'）和（年份> 2018或公里< 50000）和颜色：“白色”和事故为空

结合 Spring 的 Pageable，您将能够使用 &page=11&size=20

进行分页

具有任意AND子句的动态spring数据jpa存储库查询

4 个答案: