JAVA代码实现MongoDB动态条件之分页查询

一、使用QueryByExampleExecutor

1. 继承MongoRepository

public interface StudentRepository extends MongoRepository<Student, String> {

}

2. 代码实现

  • 使用ExampleMatcher匹配器-----只支持字符串的模糊查询,其他类型是完全匹配
  • Example封装实体类和匹配器
  • 使用QueryByExampleExecutor接口中的findAll方法
public Page<Student> getListWithExample(StudentReqVO studentReqVO) {
  Sort sort = Sort.by(Sort.Direction.DESC, "createTime");
  Pageable pageable = PageRequest.of(studentReqVO.getPageNum(), studentReqVO.getPageSize(), sort);

  Student student = new Student();
  BeanUtils.copyProperties(studentReqVO, student);

  //创建匹配器,即如何使用查询条件
  ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
      .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式:模糊查询
      .withIgnoreCase(true) //改变默认大小写忽略方式:忽略大小写
      .withMatcher("name", ExampleMatcher.GenericPropertyMatchers.contains()) //采用“包含匹配”的方式查询
      .withIgnorePaths("pageNum", "pageSize"); //忽略属性,不参与查询

  //创建实例
  Example<Student> example = Example.of(student, matcher);
  Page<Student> students = studentRepository.findAll(example, pageable);

  return students;
}

缺点:

  • 不支持过滤条件分组。即不支持过滤条件用 or(或) 来连接,所有的过滤条件,都是简单一层的用 and(并且) 连接
  • 不支持两个值的范围查询,如时间范围的查询

二、MongoTemplate结合Query

实现一:使用Criteria封装查询条件

public Page<Student> getListWithCriteria(StudentReqVO studentReqVO) {
  Sort sort = Sort.by(Sort.Direction.DESC, "createTime");
  Pageable pageable = PageRequest.of(studentReqVO.getPageNum(), studentReqVO.getPageSize(), sort);

  Query query = new Query();

  //动态拼接查询条件
  if (!StringUtils.isEmpty(studentReqVO.getName())){
    Pattern pattern = Pattern.compile("^.*" + studentReqVO.getName() + ".*$", Pattern.CASE_INSENSITIVE);
    query.addCriteria(Criteria.where("name").regex(pattern));
  }

  if (studentReqVO.getSex() != null){
    query.addCriteria(Criteria.where("sex").is(studentReqVO.getSex()));
  }
  if (studentReqVO.getCreateTime() != null){
    query.addCriteria(Criteria.where("createTime").lte(studentReqVO.getCreateTime()));
  }

  //计算总数
  long total = mongoTemplate.count(query, Student.class);

  //查询结果集
  List<Student> studentList = mongoTemplate.find(query.with(pageable), Student.class);
  Page<Student> studentPage = new PageImpl(studentList, pageable, total);
  return studentPage;
}

实现二:使用Example和Criteria封装查询条件

public Page<Student> getListWithExampleAndCriteria(StudentReqVO studentReqVO) {
  Sort sort = Sort.by(Sort.Direction.DESC, "createTime");
  Pageable pageable = PageRequest.of(studentReqVO.getPageNum(), studentReqVO.getPageSize(), sort);

  Student student = new Student();
  BeanUtils.copyProperties(studentReqVO, student);

  //创建匹配器,即如何使用查询条件
  ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
      .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式:模糊查询
      .withIgnoreCase(true) //改变默认大小写忽略方式:忽略大小写
      .withMatcher("name", ExampleMatcher.GenericPropertyMatchers.contains()) //标题采用“包含匹配”的方式查询
      .withIgnorePaths("pageNum", "pageSize"); //忽略属性,不参与查询

  //创建实例
  Example<Student> example = Example.of(student, matcher);
  Query query = new Query(Criteria.byExample(example));
  if (studentReqVO.getCreateTime() != null){
    query.addCriteria(Criteria.where("createTime").lte(studentReqVO.getCreateTime()));
  }

  //计算总数
  long total = mongoTemplate.count(query, Student.class);

  //查询结果集
  List<Student> studentList = mongoTemplate.find(query.with(pageable), Student.class);
  Page<Student> studentPage = new PageImpl(studentList, pageable, total);
  return studentPage;
}

缺点:

不支持返回固定字段

三、MongoTemplate结合BasicQuery

  • BasicQuery是Query的子类
  • 支持返回固定字段
public Page<Student> getListWithBasicQuery(StudentReqVO studentReqVO) {
  Sort sort = Sort.by(Sort.Direction.DESC, "createTime");
  Pageable pageable = PageRequest.of(studentReqVO.getPageNum(), studentReqVO.getPageSize(), sort);

  QueryBuilder queryBuilder = new QueryBuilder();

  //动态拼接查询条件
  if (!StringUtils.isEmpty(studentReqVO.getName())) {
    Pattern pattern = Pattern.compile("^.*" + studentReqVO.getName() + ".*$", Pattern.CASE_INSENSITIVE);
    queryBuilder.and("name").regex(pattern);
  }

  if (studentReqVO.getSex() != null) {
    queryBuilder.and("sex").is(studentReqVO.getSex());
  }
  if (studentReqVO.getCreateTime() != null) {
    queryBuilder.and("createTime").lessThanEquals(studentReqVO.getCreateTime());
  }

  Query query = new BasicQuery(queryBuilder.get().toString());
  //计算总数
  long total = mongoTemplate.count(query, Student.class);

  //查询结果集条件
  BasicDBObject fieldsObject = new BasicDBObject();
  //id默认有值,可不指定
  fieldsObject.append("id", 1)  //1查询,返回数据中有值;0不查询,无值
        .append("name", 1);
  query = new BasicQuery(queryBuilder.get().toString(), fieldsObject.toJson());

  //查询结果集
  List<Student> studentList = mongoTemplate.find(query.with(pageable), Student.class);
  Page<Student> studentPage = new PageImpl(studentList, pageable, total);
  return studentPage;
} 

四、MongoTemplate结合Aggregation

  • 使用Aggregation聚合查询
  • 支持返回固定字段
  • 支持分组计算总数、求和、平均值、最大值、最小值等等
public Page<Student> getListWithAggregation(StudentReqVO studentReqVO) {
  Sort sort = Sort.by(Sort.Direction.DESC, "createTime");
  Pageable pageable = PageRequest.of(studentReqVO.getPageNum(), studentReqVO.getPageSize(), sort);

  Integer pageNum = studentReqVO.getPageNum();
  Integer pageSize = studentReqVO.getPageSize();

  List<AggregationOperation> operations = new ArrayList<>();
  if (!StringUtils.isEmpty(studentReqVO.getName())) {
    Pattern pattern = Pattern.compile("^.*" + studentReqVO.getName() + ".*$", Pattern.CASE_INSENSITIVE);
    Criteria criteria = Criteria.where("name").regex(pattern);
    operations.add(Aggregation.match(criteria));
  }
  if (null != studentReqVO.getSex()) {
    operations.add(Aggregation.match(Criteria.where("sex").is(studentReqVO.getSex())));
  }
  long totalCount = 0;
  //获取满足添加的总页数
  if (null != operations && operations.size() > 0) {
    Aggregation aggregationCount = Aggregation.newAggregation(operations); //operations为空,会报错
    AggregationResults<Student> resultsCount = mongoTemplate.aggregate(aggregationCount, "student", Student.class);
    totalCount = resultsCount.getMappedResults().size();
  } else {
    List<Student> list = mongoTemplate.findAll(Student.class);
    totalCount = list.size();
  }

  operations.add(Aggregation.skip((long) pageNum * pageSize));
  operations.add(Aggregation.limit(pageSize));
  operations.add(Aggregation.sort(Sort.Direction.DESC, "createTime"));
  Aggregation aggregation = Aggregation.newAggregation(operations);
  AggregationResults<Student> results = mongoTemplate.aggregate(aggregation, "student", Student.class);

  //查询结果集
  Page<Student> studentPage = new PageImpl(results.getMappedResults(), pageable, totalCount);
  return studentPage;
}

以上就是JAVA代码实现MongoDB动态条件之分页查询的详细内容,更多关于JAVA 实现MongoDB分页查询的资料请关注我们其它相关文章!

(0)

相关推荐

  • springboot+mongodb 实现按日期分组分页查询功能

    具体代码如下所示: WalletDetailsResp walletDetailsResp = new WalletDetailsResp(); List<WalletDetailsResp.WalletDetail> list = new ArrayList<>(); WalletDetailsResp.PageInfoBean pageInfoBean = new WalletDetailsResp.PageInfoBean(); List<Integer> typ

  • Java操作MongoDB模糊查询和分页查询

    本文实例为大家分享了Java操作MongoDB模糊查询和分页查询,供大家参考,具体内容如下 模糊查询条件: 1.完全匹配 Pattern pattern = Pattern.compile("^name$", Pattern.CASE_INSENSITIVE); 2.右匹配 Pattern pattern = Pattern.compile("^.*name$", Pattern.CASE_INSENSITIVE); 3.左匹配 Pattern pattern =

  • JAVA代码实现MongoDB动态条件之分页查询

    一.使用QueryByExampleExecutor 1. 继承MongoRepository public interface StudentRepository extends MongoRepository<Student, String> { } 2. 代码实现 使用ExampleMatcher匹配器-----只支持字符串的模糊查询,其他类型是完全匹配 Example封装实体类和匹配器 使用QueryByExampleExecutor接口中的findAll方法 public Page&

  • Spring Data JPA 复杂/多条件组合分页查询

    话不多说,请看代码: public Map<String, Object> getWeeklyBySearch(final Map<String, String> serArgs, String pageNum, String pageSize) throws Exception { // TODO Auto-generated method stub Map<String,Object> resultMap=new HashMap<String, Object&

  • Spring Data JPA实现动态条件与范围查询实例代码

    Spring Data JPA为我们提供了Query With Example来实现动态条件查询,当查询条件为空的时候,我们不用做大量的条件判断.但是Query With Example却不支持范围查询(包括日期范围,数值范围查询),本文通过Specification实现了既支持动态条件查询又支持范围查询的方法. 1 实现方式 1.1 范围对象Range定义 import java.io.Serializable; public class Range<E> implements Serial

  • spring data jpa分页查询示例代码

    最近项目上用就hibernate+spring data jpa,一开始感觉还不错,但是随着对业务的复杂,要求处理一些复杂的sql,就顺便研究了下,把结果记录下,以便日后查看.用到Specification,需要继承JpaSpecificationExecutor接口.(下面代码有的分页从0开始作为第一页,有的从1开始作为作为第一页,我也忘记,请自己测试) DAO层: import java.util.List; import org.springframework.data.domain.Pa

  • Spring Data JPA带条件分页查询实现原理

    最新Spring Data JPA官方参考手册 Version 2.0.0.RC2,2017-07-25 https://docs.spring.io/spring-data/jpa/docs/2.0.0.RC2/reference/html/ JPA参考手册 (找了半天, 在线版的只找到这个) https://www.objectdb.com/java/jpa Spring Data JPA的Specification类, 是按照Eric Evans的<领域驱动设计>书中Specificat

  • 在Spring Boot中使用Spring-data-jpa实现分页查询

    在我们平时的工作中,查询列表在我们的系统中基本随处可见,那么我们如何使用jpa进行多条件查询以及查询列表分页呢?下面我将介绍两种多条件查询方式. 1.引入起步依赖   <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency&

  • 防SQL注入 生成参数化的通用分页查询语句

    使用这种通用的存储过程进行分页查询,想要防SQL注入,只能对输入的参数进行过滤,例如将一个单引号"'"转换成两个单引号"''",但这种做法是不安全的,厉害的黑客可以通过编码的方式绕过单引号的过滤,要想有效防SQL注入,只有参数化查询才是最终的解决方案.但问题就出在这种通用分页存储过程是在存储过程内部进行SQL语句拼接,根本无法修改为参数化的查询语句,因此这种通用分页存储过程是不可取的.但是如果不用通用的分页存储过程,则意味着必须为每个具体的分页查询写一个分页存储过程

  • JPA多条件复杂SQL动态分页查询功能

    概述 ORM映射为我们带来便利的同时,也失去了较大灵活性,如果SQL较复杂,要进行动态查询,那必定是一件头疼的事情(也可能是lz还没发现好的方法),记录下自己用的三种复杂查询方式. 环境 springBoot IDEA2017.3.4 JDK8 pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0&q

  • MybatisPlus实现分页查询和动态SQL查询的示例代码

    目录 一.描述 二.实现方式 三. 总结 一.描述 实现下图中的功能,分析一下该功能,既有分页查询又有根据计划状态.开始时间.公司名称进行动态查询. 二.实现方式 Controller层 /** * @param userId 专员的id * @param planState 计划状态 * @param planStartTime 计划开始时间 * @param emtCode 公司名称-分身id * @return java.util.List<com.hc360.crm.entity.po.

随机推荐