MongoTemplate实现mongodb聚合管道查询

已于 2023-12-11 16:44:09 修改
阅读量3.8k 收藏 16
点赞数 1
分类专栏： MongoDB 文章标签： mongodb 数据库 mongotemplate 非关系型数据库
于 2022-09-10 13:28:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011174699/article/details/126795491
版权

项目中使用mongodb也有5个多月了，总结一下MongoTemplate的聚合查询(使用练习实例演示)

在对应项目中引入对应版本的spring-boot-data-mongodb依赖

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

然后yml配置文件中配置好mongodb的连接信息就可以了

spring:
  data:
    mongodb:
      uri: mongodb://账号:密码@ip:port/库名 
logging:
  level:
    org.springframework.data.mongodb.core: debug

 monggodb集合对应的实体类：

package com.xiaomifeng1010.mongodb.entity;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

import java.util.List;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date:
 * @Description
 */
@Document("businessDetail")
@ApiModel(value = "xx详情信息")
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public class BusinessDetail {

    private Long businessTaskId;

    @Id
    private Long id;

  
    private Integer businessStatus;


    @ApiModelProperty(name = "businessDetailDescription",value = "xx详情说明")
    private String businessDetailDescription;

    
    @ApiModelProperty(name = "attachmentList",value = "业务附件")
    private List<Attachment> attachmentList;

  
    @ApiModelProperty(name = "pictureList",value = "活动图片")
    private List<Attachment> pictureList;


    @ApiModelProperty(name = "enterpriseBaseInfo",value = "企业基本信息")
    private EnterpriseBaseInfo enterpriseBaseInfo;


     private String executor;

   
     * 企业标签
     */
    @ApiModelProperty(name = "enterpriseLabel",value = "企业标签")
    private String enterpriseLabel;

@ApiModelProperty(name = "produceTime", value = "产生日期")
    private String produceTime;

   private String createTime;

   private String updateTime;

   private String createBy;

   private String updateBy;

}

内嵌对象

package com.xiaomifeng1010.mongodb.entity;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date: 
 * @Description 企业基本信息
 */
@Data
@ApiModel(value = "企业基本信息")
@JsonIgnoreProperties(ignoreUnknown = true)
public class EnterpriseBaseInfo {


   private String enterpriseName;

    @ApiModelProperty(name = "unifiedSocialCreditCode", value = "统一社会信用代码")
    private String unifiedSocialCreditCode;

    @ApiModelProperty(name = "industry",value = "所属行业")
    private Integer industry;

   
    @ApiModelProperty(name = "legalRepresentative",value = "法定代表人")
    private String legalRepresentative;

    @ApiModelProperty(name = "registryAddress",value = "注册地")
    private String registryAddress;

}

内部数组对象:

package com.xiaomifeng1010..mongodb.entity;

import lombok.Data;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date: 
 * @Description
 */
@Data
public class Attachment {

    /**
     * minio文件id
     */
    private Long fileId;

    private String fileUrl;

    private String originalFileName;
}

查询例子1

package com.xiaomifeng1010.task.service.impl;


import com.xiaomifeng1010.task.common.PageListResponse;
import com.xiaomifeng1010.task.service.PortalService;
import com.xiaomifeng1010.task.vo.SimpleRecordVO;
import lombok.Setter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date: 
 * @Description
 */
@Service
@Setter(onMethod_=@Autowired)
public class PortalServiceImpl implements PortalService {

    private MongoTemplate mongoTemplate;

    @Override
    public PageListResponse<SimpleRecordVO> getRecords(Long page,Integer size,String enterpriseName) {
        Criteria criteria = Criteria.where("enterpriseBaseInfo.enterpriseName").is(enterpriseName);
        Query query = Query.query(criteria);
        TypedAggregation<BusinessDetail> businessDetailTypedAggregation = Aggregation.newAggregation(
                BusinessDetail.class,
//                 相当于select
                Aggregation.project()
                        .and("executor").as("userName")
                        .and("enterpriseBaseInfo.enterpriseName").as("enterpriseName")
                        .and("produceTime").as("produceTime").andExclude("_id")
                .and("createTime").as("createTime"),
//                查询条件，相当于where
                Aggregation.match(Criteria.where("enterpriseName").is(enterpriseName)),
                Aggregation.sort(Sort.Direction.DESC, "createTime"),
                Aggregation.skip((page - 1) * size),
                Aggregation.limit(size)
        );
        AggregationResults<SimpleRecordVO> mapAggregationResults = mongoTemplate.aggregate(businessDetailTypedAggregation , SimpleRecordVO.class);
        List<SimpleRecordVO> mappedResults = mapAggregationResults.getMappedResults();
        mappedResults.forEach(System.out ::println);
        long totalCount = mongoTemplate.count(query, BusinessDetail.class);
        PageListResponse<SimpleRecordVO> pageListResponse = new PageListResponse<>();
        pageListResponse.setRecordList(mappedResults);
        pageListResponse.setTotalCount(totalCount);
        return pageListResponse;
    }
}

,这是一个分页查询，需要分页查询出结果，并且还要查询出总条数，提供给前端，所以只用一个聚合管道查询不够，聚合管道查询出分页的数据，然后还有一个查询查满足查询条件的总条数，然后封装返回给前端

mongodb聚合查询分页查出来的数据，对应的VO实体类：

package com.xiaomifeng1010.task.vo;

import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date:
 * @Description
 */
@NoArgsConstructor
@Data
public class SimpleRecordVO {

    private String produceTime;
    private String userName;
    private String enterpriseName;
}

还有一种情况，mongodb集合collection是这样创建的，实体类是这样的：


import com.baomidou.mybatisplus.annotation.TableField;
import com.fasterxml.jackson.annotation.JsonInclude;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.experimental.Accessors;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

/**
 * @description: 
 * @date: 
 * @author: 
 * @version: 1.0
 */
@Document(collection = "otherCondition")
@ApiModel(value = "其他示例")
@Data
@Accessors(chain = true)
@JsonInclude(JsonInclude.Include.NON_NULL)
public class OtherCondition implements Serializable {

    @ApiModelProperty(value = "_id")
    private String _id;

    @ApiModelProperty(value = "数据")
    private Object data;

    @ApiModelProperty(value = "类别")
    private String category;

    @ApiModelProperty(value = "备注")
    private List<Object> remarks;

    @ApiModelProperty(value = "创建时间")
    private String createTime;

    @ApiModelProperty(value = "修改时间")
    private String updateTime;
}

那么在使用聚合管道查询时：

int thisYear = DateUtil.thisYear();
            String thisYearStr = String.valueOf(thisYear);
            Aggregation aggregation  = Aggregation.newAggregation(
                    Aggregation.project().and("data.enterpriseName").as("enterpriseName")
                          .and("data.unifiedSocialCreditCode").as("unifiedSocialCreditCode")
                            .andExclude("_id")
                            .and("createTime").as("createTimeStr")
                            .and("createTime").substring(5,2).as("month")
                            .and("createTime").substring(0,4).as("year")
                            .and("data.type").as("typeCode"),
                    Aggregation.match(Criteria.where("typeCode").is(typeCode).and("year").is(thisYearStr)),
                    Aggregation.sort(Sort.Direction.DESC, "createTimeStr")

            );
            AggregationResults<EnterpriseDetailForTypeBO> aggregate = mongoTemplate.aggregate(aggregation,mongoTemplate.getCollectionName(OtherCondition .class),EnterpriseDetailForTypeBO.class);
            List<EnterpriseDetailForTypeBO> mappedResults = aggregate.getMappedResults();

说明，由于 OtherCondition 类中有个属性data是Object类型，所以不能使用TypedAggregation<OtherCondition >,需要使用不指定泛型类型的Aggregation 然后在使用mongoTemplate.aggregate方法时，使用 mongoTemplate.getCollectionName(OtherCondition .class)，传入集合名;

如果使用TypedAggregation<OtherCondition >这种带泛型类型聚合api，会报异常，提示没有实体类可以转换成Object类(Couldn't find PersistentEntity for type java.lang.Object!)

比如之前的写法和异常出错

 因为属性data是Object类型 

出现异常提示

所以改成上边的写法就可以正常聚合查询了;

而上一个查询例子中，我自己创建的一个mongodb的collection对应的实体类可以使用TypedAggregation<BusinessDetail>是因为，我创建的实体类BusinessDetail的属性中没有Object类型

查询3

聚合中如果带有分组和求和，则查询出来的字段会只有分组的字段和求和的字段，其他字段是查询不出来的，而且查询出来的结构也是分组字段和求和字段是隔离开的

例如：

for (int i = 1; i <= 10 ; i++) {
            String typeCode = EnterpriseTypeEnum.getTypeCode(i);
            Aggregation aggregation  = Aggregation.newAggregation(
                    Aggregation.project().and("data.enterpriseName").as("enterpriseName")
                            .and("data.unifiedSocialCreditCode").as("unifiedSocialCreditCode")
                            .andExclude("_id")
                            .and("createTime").as("createTime")
                            .and("createTime").substring(5,2).as("month")
                            .and("createTime").substring(0,4).as("year")
                            .and("data.type").as("typeCode")
                            .and("enterpriseNum"),
                    Aggregation.match(Criteria.where("typeCode").is(typeCode)),
                    Aggregation.sort(Sort.Direction.DESC, "createTime"),
                    Aggregation.group("month","year","typeCode").count().as("enterpriseNum")

            );
            AggregationResults<Map> aggregate = mongoTemplate.aggregate(aggregation,mongoTemplate.getCollectionName(OtherCondition.class),Map.class);
            List<Map> mappedResults = aggregate.getMappedResults();
            if (CollectionUtils.isNotEmpty(mappedResults)){
                JSONArray jsonArray = JSONUtil.parseArray(mappedResults);
                int size = jsonArray.size();
                for (int j = 0; j < size; j++) {
                    JSONObject jsonObject = jsonArray.getJSONObject(j);
                    Integer enterpriseNum = jsonObject.getInt("enterpriseNum", NumberUtils.INTEGER_ZERO);
                    JSONObject groupInfo = jsonObject.getJSONObject("_id");
                    String month = groupInfo.getStr("month");
                    Integer monthNum=0;
                    if (NumberUtil.isInteger(month)){
                        monthNum = Integer.valueOf(month);
                    }
                    String year = groupInfo.getStr("year");
                    Integer yearNum=0;
                    if (NumberUtil.isInteger(year)) {
                        yearNum = Integer.valueOf(year);
                    }
                    groupInfo.getStr("typeCode");
                    EnterpriseTypeStatistics one = enterpriseTypeStatisticsService.getOne(Wrappers.<EnterpriseTypeStatistics>lambdaQuery()
                            .eq(EnterpriseTypeStatistics::getIsValid, 1)
                            .eq(EnterpriseTypeStatistics::getMonth, monthNum)
                            .eq(EnterpriseTypeStatistics::getType, i)
                            .eq(EnterpriseTypeStatistics::getYear, yearNum));
                    EnterpriseTypeStatistics enterpriseTypeStatistics = new EnterpriseTypeStatistics();
                    enterpriseTypeStatistics.setEnterpriseNum(enterpriseNum);
                    enterpriseTypeStatistics.setYear(yearNum);
                    enterpriseTypeStatistics.setMonth(monthNum);
                    enterpriseTypeStatistics.setTypeCode(typeCode);
                    enterpriseTypeStatistics.setType(i);
                    String typeName = EnterpriseTypeEnum.getTypeName(i);
                    enterpriseTypeStatistics.setIsValid(1);
                    enterpriseTypeStatistics.setTypeName(typeName);
                    if (Objects.isNull(one)){
                        enterpriseTypeStatistics.insert();
                    }else {
                        Long id = one.getId();
                        enterpriseTypeStatistics.setId(id);
                        boolean update = enterpriseTypeStatistics.updateById();
                    }

                }
            }
        }

 聚合查询出来的数据结构是这样的

[{
	"_id": {
		"month": "05",
		"year": "2022",
		"typeCode": "xxxcodetype"
	},
	"enterpriseNum": 4905
}, {
	"_id": {
		"month": "06",
		"year": "2022",
		"typeCode": "abctype"
	},
	"enterpriseNum": 2
}]

如果 Aggregation.group("month","year","typeCode").count().as("enterpriseNum")这个聚合操作，只是分组，没有计数count操作，则可以直接映射给一个实体类的形式

比如这个聚合查询中group操作之后，没有计数或者求和

  /**
     *
     * @return
     */
    public ApiResult twentyEightTypeDetailRecordTest(){
        for (int i = 18; i <= 28; i++) {
            List<EnterpriseTypeDetailRecord> enterpriseTypeDetailRecordList = Lists.newArrayList();
            String typeCode = EnterpriseTypeEnum.getTypeCode(i);
            String typeName = EnterpriseTypeEnum.getTypeName(i);
            List<String> enterpriseTypeChildCodeList = enterpriseTypeDetailRecordService.getEnterpriseTypeChildCode(typeCode);
            Aggregation aggregation = null;
            if (Range.closed(18, 20).contains(i) || Range.closed(25, 28).contains(i)) {
                aggregation = Aggregation.newAggregation(
                        Aggregation.project().and("data.list.enterpriseName").as("enterpriseName")
                                .and("data.list.unifiedSocialCreditCode").as("unifiedSocialCreditCode")
                                .andExclude("_id")
                                .and("createTime").substring(5, 2).as("month")
                                .and("createTime").substring(0, 4).as("year")
                                .and("data.type").as("typeCode"),
                        Aggregation.match(Criteria.where("typeCode").in(enterpriseTypeChildCodeList)),
                        Aggregation.group("month","year","enterpriseName","uscc").last("month")
                        .as("month").last("year").as("year").last("enterpriseName").as("enterpriseName")
                        .last("unifiedSocialCreditCode").as("unifiedSocialCreditCode")

                );
            }
            AggregationResults<EnterpriseDetailForTypeBO> aggregate = mongoTemplate.aggregate(aggregation,mongoTemplate.getCollectionName(OtherCondition.class),EnterpriseDetailForTypeBO.class);
            List<EnterpriseDetailForTypeBO> mappedResults = aggregate.getMappedResults();
            log.info("第{}类表的数据:{}",i, JSONUtil.toJsonPrettyStr(mappedResults));
        }
        return ApiResult.success();
    }

那么最终聚合查询出来的数据的格式就是这样的：

[
    {
        "enterpriseName": "Adong公司",
        "unifiedSocialCreditCode": "xxxxxxxxxY",
        "year": 2022,
        "month": 6
    },
    {
        "enterpriseName": "Bgog公司",
        "unifiedSocialCreditCode": "567890000098877",
        "year": 2022,
        "month": 6
    },
    {
        "enterpriseName": "gungdong公司",
        "unifiedSocialCreditCode": "899999999999999999999999991",
        "year": 2022,
        "month": 6
    },
   
]

就可以直接用定义好的实体类EnterpriseDetailForTypeBO来映射接收数据

package com.xiaomifeng1010.bo;

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;

import java.io.Serializable;
import java.time.LocalDateTime;

/**
 * @author xiaomifeng1010
 * @version 1.0
 * @date: 
 * @Description
 */
@Data
public class EnterpriseDetailForTypeBO implements Serializable {

    private static final long serialVersionUID = 4343533526326L;
    private String enterpriseName;
    
    /**
    * 统一社会信用代码
    */
    private String unifiedSocialCreditCode;

    private String createTimeStr;

    private Integer year;

    private Integer month;

    private Integer enterpriseNum;

    private String typeCode;
}

查询4


    /**
     * @param year
     * @param month
     * @description: 获取某年某月xxxx数量
     * @author: xiaomifeng1010
     * @date: 
     * @return: Integer
     **/
    @Override
    public Integer getSomeConditionStatistics(Integer year, Integer month) {
        String yearStr = StringUtils.EMPTY;
        String monthStr = StringUtils.EMPTY;
        if (Objects.nonNull(year) && Objects.isNull(month)) {
            yearStr = Convert.toStr(year);
        } else if (ObjectUtils.allNotNull(year, month)) {
            yearStr = Convert.toStr(year);
            monthStr = String.format("%02d", month);
        }
        Criteria criteria = new Criteria();
        MatchOperation match = null;
        GroupOperation group = null;
        if (StringUtils.isNotEmpty(yearStr) && StringUtils.isEmpty(monthStr)) {
            match = Aggregation.match(Criteria.where("year").is(yearStr));
            group = Aggregation.group("year", "enterpriseName").last("year").as("year")
                    .last("enterpriseName").as("enterpriseName");
        } else if (!StringUtils.isAnyBlank(monthStr, yearStr)) {
            match = Aggregation.match(Criteria.where("year").is(yearStr).and("month").is(monthStr));
            group = Aggregation.group("year", "month", "enterpriseName").last("year").as("year")
                    .last("month").as("month")
                    .last("enterpriseName").as("enterpriseName");
        } else {
            match = Aggregation.match(criteria);
            group = Aggregation.group("enterpriseName")
                    .last("enterpriseName").as("enterpriseName");
        }
        TypedAggregation<BusinessDetail> businessDetailTypedAggregation = Aggregation.newAggregation(
                BusinessDetail.class,
                Aggregation.project().and("produceTime").substring(0, 4).as("year")
                        .and("produceTime").substring(5, 2).as("month")
                        .and("enterpriseBaseInfo .enterpriseName").as("enterpriseName")
                        .andExclude("_id"),
//              只获取指定年份的数据
                match,
//                使用group去重
                group,
//                统计今年xxx数量
                Aggregation.count().as("count")

        );
        AggregationResults<Map> aggregateResults = mongoTemplate.aggregate(businessDetailTypedAggregation, Map.class);
        List<Map> mappedResults = aggregateResults.getMappedResults();
        Integer yearOrMonthCount = 0;
        if (CollectionUtils.isNotEmpty(mappedResults)) {
            yearOrMonthCount = MapUtils.getInteger(mappedResults.get(0), "count");
        }
        return yearOrMonthCount;
    }

各类的Aggregation对象是可以抽取出来的，因为有时候，查询条件是变化的，所以需要根据查询条件是否有值，来进行判断是否需要进行某种类型的聚合操作，因为mongodb的聚合管道查询类似于linux中的管道符操作，前一步的操作结果会直接影响下一步的聚合操作，所以聚合查询时，project,match,goup,count等的顺序很重要，比如你在Aggregation.newAggregation()中最先传入了project类型的聚合并给对应的字段取了别名也就是as后的名称，那么你在第二步match的时候，字段就需要使用project操作后的别名，如果还是使用mongodb中collection中的原始的字段名就会报错，就会提示无法找到reference_name,所以这就是管道操作需要注意的地方，第一步操作的结果是下一步操作时的入参参数值，所以一般情况下，需要根据你的查询需求，project,match,goup,sort,sikp,count，unwind,bucket等操作，放在Aggregation.newAggregation()中的顺序都会不一样的,对于mongodb中内置的一些字符串函数和日期函数，主要都是在project类型的聚合操作中进行的，比如上边的例子，为了取出日期中的年份，使用substring函数操作提取日期字符串的前四位，当然如果你保存日期的时候，不是使用String类型，而且DateTime类型，则可以直接使用year,month这类的函数提取，更方便

下边罗列一下，mongodb中常用的一些函数操作

字符串类型的操作：

$substr,$indexOfBytes,$switch,$strLenBytes,$toLower,$toUpper,$concat,$split,

对数字型字段可以做加减乘除，取余等操作$add,$subtract,$multiply,$divide,$mod

时间类型字段：$year,$month,$week,$hour,$minute,$second,$millsecond,$dayOfYear,$dayOfMonth,$dayOfWeek

如果你创建了多个collection，并且之间有关联关系，你想实现类似mysql的联表查询，你需啊哟使用聚合中的lookup

$lookup操作符可以查找出集合中与另一个集合天剑匹配的文档，此功能类似于关系型数据库中的join查询，此操作符需要以下参数：

from：想要关联的另一个集合

localField: 集合中需要关联的键

foreignField: 与另一个集合关联的键

as: 关联后将另外一个结合的数据嵌入到此字段下

有时候，你需要做一些报表统计，为了查询速度加快，那么你可能需要将聚合的操作放在另一个collection中，平时用定时任务去聚合查询，查询结构汇出到另一个新的collection中，这样以后每次查询只需要从新的collection中普通查询就可以了，那么你需要使用到聚合操作中的out操作符

用$out可以将聚合出来的结果写入到一个指定的结合中，如果指定的集合不存在，则会创建一个新集合，如果指定的集合已存在，则会覆写到此集合中。但如果原有的集合中存在索引，而使用$out写入文档违反此索引，则会写入失败

xiaomifeng1010
关注
  • 1
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA mongodb 聚合几种查询方式详解
08-27
主要介绍了JAVA mongodb 聚合几种查询方式详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Mongodb—MongoTemplate详解及示例代码
深圳市多克创新科技有限公司
03-21 3290
MongoTemplate简介
Springboot与mongodb集成及聚合查询
最新发布
沙门空海
05-31 555
Springboot与mongodb集成及聚合查询
MongoTemplate基本学习
CodersCoder的博客
06-11 1825
使用背景 项目中偶尔需要对接大数据平台组，因为对接方有使用MongoDB，因此也需要做一些关于MongoDB的简要工作。
SpringBoot 2.X MongoTemplate 分组聚合查询一网打尽
Mrqiang9001
11-19 5449
文章目录1 摘要2 按照固定字段分组查询3 分组分页查询4 按照日期分组查询(字段为精确到秒的时间戳)5 按照日期分组查询(字段为精确到毫秒的时间戳)6 按照日期分组查询(字段为Date)7 按照自定义时间区间分组查询8 数据库实体类及其他相关类8.1 数据库实体类8.2 统计结果类8.3 日期分组信息类8.4 获取日期分组信息的方法9 推荐参考资料10 本次提交记录 ​ ​ 1 摘要 MongoDb 如何实现聚合查询？分组查询？分组分页查询？自定义时间区间查询？时间格式转换查询？不要慌，本文将介绍基于 S
10、MongoDB -- MongoDB 的 MongoTemplate 的功能和用法介绍
Java 领域技术分享
03-09 1534
MongoDB -- MongoDB 的 MongoTemplate 的功能和用法介绍
SpringBoot整合MongoDB，使用mongoTemplate实现高级查询
热门推荐
我的博客
08-30 5万+
一、前言 最近项目使用MongoDB作为数据主要存取的地方 又是第一次接触MongoDB，也是踩了不少坑... 维护数据无非就是增删改查，而里面最复杂的就是查询了 所以来总结一下有关MongoDB的查询方法 当然如果你在此之前你对MongoDB一点都不了解的话 个人建议点击这里，花三十分钟初步了解一下MongoDB ok，正文开始 二、正文 1.使用mongoTemplate对象...
MongoDB 高级查询 aggregate 聚合管道
12-14
使用聚合管道可以对集合中的文档进行变换和组合，常用于多表关联查询、数据的统计。 db.COLLECTION_NAME.aggregate() 方法用来构建和使用聚合管道，下图是官网给的实例，可以看出来聚合管道的用法还是比较简单的。 ...
spring data mongodb 聚合 管道
08-07
在Java中，我们可以使用Spring Data MongoDB的API来构建并执行这个聚合管道。以下是一个具体的Java代码示例： ```java import static org.springframework.data.mongodb.core.aggregation.Aggregation.*; import ...
spring-data使用mongodbTemplate对MongoDB进行读写操作
08-06
MongoDBTemplate mongoTemplate = new MongoDBTemplate(mongoDbFactory); ``` 在`applicationContext.xml`或类似的配置文件中，你会设置MongoDB的相关连接信息，如服务器地址、端口、数据库名和认证信息等。例如： ...
mongoTemplate工具类Dao层方法封装.zip
11-23
- MongoTemplate支持MongoDB的聚合框架，如`aggregate()`方法，可以处理复杂的聚合管道操作，包括 `$match`, `$group`, `$sort`, `$project`, `$unwind` 等。 5. **索引管理**： - 通过`createIndex()`和`drop...
springboot+mongodb 实现按日期分组分页查询功能
08-27
在实现日期分组分页查询功能之前，我们需要了解 MongoDB 的聚合管道（Aggregation Pipeline）。聚合管道是一系列数据处理操作，用于处理和转换数据。它由多个阶段组成，每个阶段都可以对数据进行处理和转换。 在...
Spring Data MongoDB--MongoTemplate查询数据--方法/实例
IT利刃出鞘的博客
11-03 4130
本文用示例介绍Spring Data MongoDB（MongoTemplate）查询数据的方法。
入门：MongoDB基本命令及整合Springboot使用
肥柯博客
08-21 736
MongoDB 1、基本概述 MongoDB是以JSON为数据模型的文档型的介于关系数据库和非关系数据库之间的产品（虽然更多称它为非关系数据库）。它直接操作的对象是内存，通过映射把数据持久化到硬盘。 MongoDB追求一个对象一个数据表，无论对象与对象之间存在怎样的关系，它的表与表之间是没有关联性的。因此，对于关联关系，我们只需要在类中维护好它们的关系就好。因此严格来说，MongoDB又不属于数据库，它应该是一种以数据结构化存储方法的集合。 MongoDB 将数据存储为一个文档，数据结构由键值(key=&
springboot集成mongoDB高级聚合查询,关联查询
m0_54850467的博客
07-29 1090
使用该阶段符分组查询该。
使用MongoTemplate 对 mongodb数据进行分组、排序、分页、连表查询
知道的越多 不知道的就越多
09-23 7179
聚合查询（分组、排序、分页、连表）
使用java操作Mongo对复杂数据结构进行聚合查询统计
qq_54780023的博客
11-29 1120
使用java操作Mongo对复杂数据结构进行聚合查询统计
MongoDB-Java MongoDB MongoTemplate 查询
Eistert
10-11 2348
lt:小于 lte: 小于等于 gte :大于等于 gt: 大于 lte less than equal gte greater than equal // xxx时间大于等于开始时间 if (caseListBO.getReceiveBeginTime() != null) { criteria.and("xxxTime").gte(caseListBO.getBeginTime()); } // xxx时间小于等于结束时间 if (caseListBO.getRecei
MongoDB之通过mongoTemplate利用aggregate管道聚合操作获取某一个或多个字段的最大值和最小值
熊凯瑞的博客
11-08 3078
有时候在操作mongodb数据库时需要找出某个字段的最大值和最小值，网上的方法就两种，一种是先排序，按升序或者按降序，然后取第一个值就可以得到最大值或最小值了，听起来很美好，但一旦数据库内数据非常多的时候，而且还是mongoDB这样的数据库，如果查一遍库才能拿到值，代价是非常大的。所以我主要采用第二种方法，也就是利用mongodbTemplate来进行管道操作来获取mongodb数据库中某一个或多个字段的最大值和最小值。
mongotemplate聚合查询
07-28
您好！对于MongoTemplate的聚合查询，您可以使用Aggregation类来构建聚合查询管道。以下是一个简单的示例： ```java import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.data.mongodb.core.aggregation.Aggregation; import org.springframework.data.mongodb.core.aggregation.TypedAggregation; import org.springframework.data.mongodb.core.aggregation.AggregationResults; import static org.springframework.data.mongodb.core.aggregation.Aggregation.*; public class AggregationExample { private MongoTemplate mongoTemplate; public AggregationExample(MongoTemplate mongoTemplate) { this.mongoTemplate = mongoTemplate; } public void performAggregation() { TypedAggregation aggregation = newAggregation( // 添加聚合操作 match(Criteria.where("fieldName").is("value")), group("groupField").count().as("count"), sort(Sort.Direction.DESC, "count") ); AggregationResults<AggregateResultClass> results = mongoTemplate.aggregate(aggregation, "collectionName", AggregateResultClass.class); List<AggregateResultClass> resultList = results.getMappedResults(); // 处理结果 for (AggregateResultClass result : resultList) { // 进行相应的操作 // result.getGroupField(); // result.getCount(); } } } // 聚合结果的POJO类 class AggregateResultClass { private String groupField; private int count; // 省略构造函数、getter和setter } ``` 请根据您的具体需求修改上述示例中的字段和条件。希望对您有所帮助！如果您有任何其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值