Java实现MongoDB的增删改与条件、分组查询

        看简单的MongoDB的查询语句，按照关系型数据库脚本的思维，大概还可以理解，但是一些复杂的语句确实有些懵，由于在实际开发中用到了下面的几种种方式，所以记录一下，以备再用。

引入依赖：

<!-- spring-boot-starter-data-mongodb -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-mongodb</artifactId>
		</dependency>

配置信息：

spring.data.mongodb.primary.host=127.0.0.1
spring.data.mongodb.primary.port=27017
spring.data.mongodb.primary.username=demo
spring.data.mongodb.primary.password=password
spring.data.mongodb.primary.database=application

 

一、普通条件查询，

  //查询所有  
  public List<BookUseRecord> findAll() {
        return primaryMongoTemplate.findAll(BookUseRecord.class);
   }

  //指定id进行查询
  public BookUseRecord getBookDownLoad(String uuid) {
        return primaryMongoTemplate.findOne(
                new Query(Criteria.where("uuid").is(uuid)),
                BookUseRecord.class);
   }

二、新增

    //新增
    public void insert(BookUseRecord bookDownLoad) {
        primaryMongoTemplate.insert(bookDownLoad);
    }

    //批量新增
    public void insertAll(List<BookUseRecord> bookDownLoads) {
        primaryMongoTemplate.insertAll(bookDownLoads);
    }

三、修改

  public void update(Book book) {
        Criteria criteria = Criteria.where("uuid").is(book.getUuid());
        Query query = new Query(criteria);
        Update update = Update.update("bookId", book.getBookId())
                .set("bookName", book.getBookName())
                .set("LoadUserId", book.getUseUserId())
                .set("LoadTime", book.getUseTime())
                .set("userType", book.getUserType())
                .set("Area", book.getSchoolArea())
                .set("subject", book.getSubject())
                .set("Section", book.getStudySection())
                .set("terminalType", book.getTerminalType())
                .set("grade", book.getGrade())
                .set("sakuji", book.getSakuji())
                .set("Edition", book.getTextbookEdition());
        primaryMongoTemplate.updateMulti(query, update, Book.class);

    }

四、删除

 //删除
 public void remove(Integer uuid) {
        Criteria criteria = Criteria.where("uuid").is(uuid);
        Query query = new Query(criteria);
        primaryMongoTemplate.remove(query, BookUseRecord.class);
    }

五、聚合查询，使用Map进行数据的接收，在逻辑处理中再进行取值。

   @SuppressWarnings("rawtypes")
    public List<Map> getUseCount(String bookId, String activationId, String areaId,
            String schoolId, String grade, String subject, Integer userType,
            Date startTime, Date endTime) {
        Criteria criteria = new Criteria();
        if (startTime != null && endTime != null && startTime.getTime() < endTime.getTime()) {
            criteria = Criteria.where("useTime").gte(startTime).lte(endTime);//只限定上线时间
            if (StringUtils.isNotBlank(bookId)) {
                criteria = criteria.and("bookId").is(bookId);
            }
            if (StringUtils.isNotBlank(activationId)) {
                criteria = criteria.and("ditch").is(activationId);
            }
            if (StringUtils.isNotBlank(areaId)) {
                criteria = criteria.and("schoolArea").is(areaId);
            }
            if (StringUtils.isNotBlank(schoolId)) {
                criteria = criteria.and("school").is(schoolId);
            }
            if (StringUtils.isNotBlank(grade)) {
                criteria = criteria.and("grade").is(grade);
            }
            if (StringUtils.isNotBlank(subject)) {
                criteria = criteria.and("subject").is(subject);
            }
            if (userType != null) {
                criteria = criteria.and("userType").is(userType);
            }
            //将时间格式化到年月日，并根据年月日进行分组
            ProjectionOperation as = Aggregation.project("useTime")
                    .andExpression("useTime").extractYear().as("year")
                    .andExpression("useTime", "useTime").extractMonth()
                    .as("month").andExpression("useTime", "useTime")
                    .extractDayOfMonth().as("day");
            //根据年月日进行分组
            GroupOperation groupOperation = Aggregation
                    .group("year", "month", "day").count().as("count");
            //根据年月日进行排序
            SortOperation sort = Aggregation.sort(Direction.DESC,"year","month","day");
            if (criteria != null) {
                Aggregation agg = Aggregation.newAggregation(Aggregation.match(criteria), 
                        as,groupOperation,sort);
                AggregationResults<Map> results = primaryMongoTemplate
                        .aggregate(agg, "bookUseRecord", Map.class);
                return results.getMappedResults();
            }
        }
        return null;
    }

六、模糊查询

public List<UseRecord> findByPage(Record record ,
            Pageable pageable) {
        Query query = new Query();
        if (record != null && record .getUuid() != null) {
            // 模糊查询
            query = new Query(
                    Criteria.where("uuid").regex("^" + record .getUuid()));
        }
        List<UseRecord> list = primaryMongoTemplate
                .find(query.with(pageable), UseRecord.class);
        return list;
    }

七、查询记录条数

 @Override
    public long getCount(Date startTime, Date endTime, String userType,
            String schoolArea, String subject, String studySection,
            String terminalType, String grade, String sakuji,
            String textbookEdition) {
        Query query = new Query();
        if (startTime != null && endTime != null
                && startTime.getTime() < endTime.getTime()) {
            query.addCriteria(
                    Criteria.where("downLoadTime").gte(startTime).lt(endTime));
        }
        if (StringUtils.isNotBlank(userType)) {
            query.addCriteria(Criteria.where("userType").is(userType));
        }
        if (StringUtils.isNotBlank(schoolArea)) {
            query.addCriteria(Criteria.where("schoolArea").is(schoolArea));
        }
        if (StringUtils.isNotBlank(subject)) {
            query.addCriteria(Criteria.where("subject").is(subject));
        }
        if (StringUtils.isNotBlank(studySection)) {
            query.addCriteria(Criteria.where("studySection").is(studySection));
        }
        if (StringUtils.isNotBlank(terminalType)) {
            query.addCriteria(Criteria.where("terminalType").is(terminalType));
        }
        if (StringUtils.isNotBlank(grade)) {
            query.addCriteria(Criteria.where("grade").is(grade));
        }
        if (StringUtils.isNotBlank(sakuji)) {
            query.addCriteria(Criteria.where("sakuji").is(sakuji));
        }
        if (StringUtils.isNotBlank(textbookEdition)) {
            query.addCriteria(
                    Criteria.where("textbookEdition").is(textbookEdition));
        }
        return primaryMongoTemplate.count(query, BookUseRecord.class);
    }