mongoTemplate的分页,分组,统计

最新推荐文章于 2024-07-31 16:32:24 发布
最新推荐文章于 2024-07-31 16:32:24 发布
阅读量1.4w 收藏 32
点赞数 5
分类专栏： 大数据/数据处理 mongodb 文章标签： mongoTemplate mongoDB Aggregation
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liao0801_123/article/details/95311837
版权

crud参考:https://blog.csdn.net/weixin_39729846/article/details/82626721

mongoTemplate的分页,分组,统计以及聚合Aggregation和mapReduce的使用 

package com.star.ac.mongodb.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;
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.DateOperators;
import org.springframework.data.mongodb.core.aggregation.GroupOperation;
import org.springframework.data.mongodb.core.aggregation.MatchOperation;
import org.springframework.data.mongodb.core.aggregation.ProjectionOperation;
import org.springframework.data.mongodb.core.aggregation.SortOperation;
import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
import org.springframework.data.mongodb.core.mapreduce.GroupBy;
import org.springframework.data.mongodb.core.mapreduce.GroupByResults;
import org.springframework.data.mongodb.core.query.BasicQuery;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Repository;

import com.alibaba.fastjson.JSON;
import com.star.ac.dto.AlarmStatisDto;
import com.star.ac.dto.CommunitySecurityStatis;
import com.star.ac.dto.CommunitySecurityStatisData;
import com.star.ac.dto.DeviceAlarmStatisDto;
import com.star.ac.dto.SingleAlarm;
import com.star.ac.model.AlarmInfo;
import com.star.ac.model.AlarmStatisPerDay;
import com.star.ac.model.BreakdownInfo;
import com.star.ac.mongodb.AlarmMongodbDao;
import com.star.ac.param.AlarmParam;
import com.star.ac.param.AlarmStatisParam;
import com.star.ac.param.AlarmUpToDateParam;
import com.star.ac.param.CommunitySecurityParam;
import com.star.ac.param.DeviceAlarmStatisParam;
import com.star.common.utils.DateUtil;
import com.star.common.utils.StringUtil;
import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;

@Repository
public class AlarmMongodbDaoImpl implements AlarmMongodbDao {

	private static final Logger logger = Logger.getLogger(AlarmMongodbDaoImpl.class);

	@Autowired
	private MongoTemplate mongoTemplate;

	/**
	 * @Description: 新增告警日志表并返回主键ID
	 * @Author: 
	 * @Date: 2019/5/7 17:13
	 */
	@Override
	public AlarmInfo insertAlarmInfo(AlarmInfo alarmInfo) {
		mongoTemplate.insert(alarmInfo, "alarm_info");
		return alarmInfo;
	}

	/**
	 * @Description: 新增故障日志表并返回主键ID
	 * @Author: 
	 * @Date: 2019/5/8 9:50
	 */
	@Override
	public BreakdownInfo insertBreakdownInfo(BreakdownInfo breakdownInfo) {

		mongoTemplate.insert(breakdownInfo, "breakdown_info");
		return breakdownInfo;
	}

	/**
	 * @Description: 分页查询
	 * @Author: 
	 * @Date: 2019/5/8 9:59
	 */
	
	@Override
	public Map<String, Object> getAlarmLogByDeviceCode(AlarmParam param) {
		logger.info("AlarmMongodbDaoImpl.getAlarmLogByDeviceCode start");

		Map<String, Object> resultMap = new HashMap<>();
		int currentPage = param.getCurPage();
		int pageSize = param.getPageSize();

		// 设置字段
		// 创建查询及条件
		Query query = Query.query(Criteria.where("spCode").is(param.getSpCode()));
		if (!StringUtil.isNil(param.getDeviceCode())) {
			query.addCriteria(Criteria.where("deviceCode").is(param.getDeviceCode()));
		}

		// 设置起始数
		query.skip((currentPage - 1) * pageSize)
				// 设置查询条数
				.limit(pageSize);

		// 查询记录总数
		int totalCount = (int) mongoTemplate.count(query, AlarmInfo.class);
		// 数据总页数
		int totalPage = totalCount % pageSize == 0 ? totalCount / pageSize : totalCount / pageSize + 1;

		// 设置记录总数和总页数
		resultMap.put("totalCount", totalCount);
		resultMap.put("totalPage", totalPage);

		// 按创建时间倒序
		query.with(new Sort(Sort.Direction.DESC, "createDate"));
		// 查询当前页数据集合
		List<AlarmInfo> records = mongoTemplate.find(query, AlarmInfo.class);
		resultMap.put("data", records);
		return resultMap;
	}

	/**
	 * 分页查询
	 */
	@Override
	public Map<String, Object> getBreakdownLogByDeviceCode(AlarmParam param) {
		logger.info("AlarmMongodbDaoImpl.getBreakdownLogByDeviceCode start");

		Map<String, Object> resultMap = new HashMap<>();
		int currentPage = param.getCurPage();
		int pageSize = param.getPageSize();

		// 创建查询及条件
		Query query = Query.query(Criteria.where("spCode").is(param.getSpCode()));

		if (!StringUtil.isNil(param.getDeviceCode())) {
			query.addCriteria(Criteria.where("deviceCode").is(param.getDeviceCode()));
		}

		// 设置起始数
		query.skip((currentPage - 1) * pageSize)
				// 设置查询条数
				.limit(pageSize);

		// 查询记录总数
		int totalCount = (int) mongoTemplate.count(query, BreakdownInfo.class);
		// 数据总页数
		int totalPage = totalCount % pageSize == 0 ? totalCount / pageSize : totalCount / pageSize + 1;

		// 设置记录总数和总页数
		resultMap.put("totalCount", totalCount);
		resultMap.put("totalPage", totalPage);

		// 按创建时间倒序
		query.with(new Sort(Sort.Direction.DESC, "createDate"));
		// 查询当前页数据集合
		List<BreakdownInfo> records = mongoTemplate.find(query, BreakdownInfo.class);
		resultMap.put("data", records);
		return resultMap;
	}

	public static void main(String[] args) {
		String date2string = DateUtil.date2string(new Date());
		System.out.println(date2string.substring(0, 10));
	}

	/*
	 * 指定字段 且返回最新的数据
	 */
	@Override
	public List<AlarmInfo> getAlarmStatisUpToDate(AlarmUpToDateParam param) {
		logger.info("AlarmMongodbDaoImpl.getAlarmStatisUpToDate start");
		BasicDBObject dbObject = new BasicDBObject();
		// dbObject.put("content", "content1");
		// dbObject.put("level", 888); //相当于条件 level = 888
		// dbObject.append(key, val);

		// 指定返回的字段
		BasicDBObject fieldsObject = new BasicDBObject();
		fieldsObject.put("content", true);
		fieldsObject.put("type", true);
		fieldsObject.put("level", true);
		fieldsObject.put("createDate", true);

		Query query = new BasicQuery(dbObject.toJson(), fieldsObject.toJson());

		String today = DateUtil.date2string(new Date()).substring(0, 10);
		// 查询时间 mongoDB存储的是UTC时间 , 但读取和条件查询时会自动转换 不需要额外处理
		Date createDateStart = DateUtil.string2Date(today + " 00:00:00", DateUtil.YYYYMMDDHHMMSS);
		Date createDateEnd = DateUtil.string2Date(today + " 23:59:59", DateUtil.YYYYMMDDHHMMSS);

		query.addCriteria(Criteria.where("createDate").gte(createDateStart).lte(createDateEnd));
		query.addCriteria(Criteria.where("spCode").is(param.getSpCode()));
				
		query.limit(param.getCount());
		query.with(new Sort(Sort.Direction.DESC, "createDate"));

		List<AlarmInfo> list = mongoTemplate.find(query, AlarmInfo.class, "alarm_info");

		return list;
	}

	/**
	 * 先将日期转化成 yyyy-mm-dd格式, 再用日期分组count
	 */
	@Override
	public List<CommunitySecurityStatis> communitySecurityStatis(CommunitySecurityParam param) {
		logger.info("AlarmMongoDaoImpl.communitySecurityStatis start");
		String begin = DateUtil.date2string(param.getBeginDate()).substring(0,10);
		String end = DateUtil.date2string(param.getEndDate()).substring(0,10);
		// 查询时间  mongoDB存储的是UTC时间 , 但读取和条件查询时会自动转换 不需要额外处理
		Date createDateStart = DateUtil.string2Date(begin+" 00:00:00", DateUtil.YYYYMMDDHHMMSS);
		Date createDateEnd = DateUtil.string2Date(end+" 23:59:59", DateUtil.YYYYMMDDHHMMSS);
		
		
		List<CommunitySecurityStatis> stats = new ArrayList<CommunitySecurityStatis>();
		if (CollectionUtils.isNotEmpty(param.getRuleIds())) {
			for (Long ruleId : param.getRuleIds()) {
				
				String ruleName = getRuleName(ruleId);
				Criteria criteria = Criteria.where("createDate").gte(createDateStart).lte(createDateEnd);

				criteria.and("spCode").is(param.getSpCode());
				criteria.and("ruleId").is(ruleId);
				//聚合查询转换格式时需要增加8小时
				Aggregation aggregation1 = Aggregation.newAggregation(Aggregation.match(criteria),
						Aggregation.project().andExpression("{$dateToString:{format:'%Y-%m-%d',date: {$add:{'$createDate',8*60*60000}}}}").as("date"),
						Aggregation.group("date").first("date").as("date")
						.count().as("num"));
				AggregationResults<CommunitySecurityStatisData> outputTypeCount1 = mongoTemplate.aggregate(aggregation1, "alarm_info",
						CommunitySecurityStatisData.class);
				if (null == outputTypeCount1 || CollectionUtils.isEmpty(outputTypeCount1.getMappedResults())) {
					continue;
				}
				
				
				CommunitySecurityStatis statis = new CommunitySecurityStatis();
				List<CommunitySecurityStatisData> list = outputTypeCount1.getMappedResults();
				statis.setName(ruleName);
				statis.setRuleId(ruleId);
				statis.setStatisData(list);
				stats.add(statis);
			}
		}
	
		/*
		 * criteria.andOperator(Criteria.where("createTime").lte(param.getEndDate()),
		 * Criteria.where("createTime").gte(param.getBeginDate()));
		 */


		

		 
		/*
		GroupBy groupBy = GroupBy
				.keyFunction("function(doc){ var date = new Date(doc.createTime);"
						+ "	var dateKey = \"\"+date.getFullYear()+\"-\"+(date.getMonth()+1)+\"-\"+date.getDate();"
						+ "	return {'date':dateKey};"
						+ "}")
				.initialDocument("{num : 0}").reduceFunction("function(doc, out){" 
						+ "out.num += 1;" 
						+ "}");

		GroupBy groupBy1 = new GroupBy("{keyf : function(doc){ var date = new Date(doc.createTime);"
				+ "	var dateKey = \"\"+date.getFullYear()+\"-\"+(date.getMonth()+1)+\"-\"+date.getDate();"
				+ "	return {'date':dateKey};"
				+ "} }")
				.initialDocument("{num : 0}")
						.reduceFunction("function(doc, out){" 
								+ "out.num += 1;" 
								+ "}");

		GroupByResults<CommunitySecurityStatisData> statisResults = mongoTemplate.group(criteria, "alarm_info", groupBy1,
				CommunitySecurityStatisData.class);
		*/
		return stats;
	}

	/**
	 * 单条件查询limit 1
	 * @param ruleId
	 * @return
	 */
	private String getRuleName(Long ruleId) {
		Query query = Query.query(Criteria.where("ruleId").is(ruleId));
		AlarmInfo findOne = mongoTemplate.findOne(query, AlarmInfo.class);
		if (null == findOne) {
			return null;
		}
		return findOne.getRuleName();
	}

	/*
	 * 以deviceTypeName分组 个数求和
	 */
	@Override
	public List<DeviceAlarmStatisDto> deviceAlarmStatis(Map<String, Object> paramMap) {

		Criteria criteria = Criteria.where("createDate").gte(paramMap.get("beginDate")).lte(paramMap.get("endDate"));

		if (StringUtils.isNotBlank((String) paramMap.get("spCode"))) {
			criteria.and("spCode").is(paramMap.get("spCode"));
		}

		// first("") 分组后，如果某属性(非分组属性)出现多个值 ,取第一个
		Aggregation aggregation1 = Aggregation.newAggregation(Aggregation.match(criteria),
				Aggregation.group("deviceTypeName").first("deviceTypeName").as("deviceTypeName").first("deviceType").as("deviceType").count().as("value"));
		AggregationResults<DeviceAlarmStatisDto> outputTypeCount1 = mongoTemplate.aggregate(aggregation1, "alarm_info",
				DeviceAlarmStatisDto.class);
		if (null == outputTypeCount1) {
			return null;
		}

		return outputTypeCount1.getMappedResults();
	}

	/*
	 * 分组统计  以statisDate分组并且将total值求和
	 */
	@Override
	public List<AlarmStatisDto> getAlarmStatis(Map<String, Object> paramMap) {
		Date beginDate = (Date) paramMap.get("beginDate");
		Date endDate = (Date) paramMap.get("endDate");
		AlarmStatisParam paramDto = (AlarmStatisParam) paramMap.get("paramDto");
		
		Criteria criteria = Criteria.where("updateTime").gte(beginDate).lte(endDate);
        if (StringUtils.isNotBlank(paramDto.getSpCode())) {
            criteria.and("spCode").is(paramDto.getSpCode());
        }
        if (StringUtils.isNotBlank(paramDto.getProductCode())) {
            criteria.and("produCode").is(paramDto.getProductCode());
        }
        if (StringUtils.isNotBlank(paramDto.getDeviceType())) {
            criteria.and("deviceType").is(paramDto.getDeviceType());
        }
        if (StringUtils.isNotBlank(paramDto.getDeviceCode())) {
            criteria.and("deviceCode").is(paramDto.getDeviceCode());
        }
        if (StringUtils.isNotBlank(paramDto.getDeviceGroupCode())) {
            criteria.and("deviceGroupCodes").is(paramDto.getDeviceGroupCode());
        }
        
        
        Aggregation aggregation1 = Aggregation.newAggregation(Aggregation.match(criteria),
				Aggregation.group("statisDate").first("statisDate").as("date").first("updateTime").as("updateTime").sum("total").as("value"),
				Aggregation.sort(new Sort(Sort.Direction.ASC, "updateTime")));
        String collectionName = "";
        //按天
        if (1 == (Integer)paramMap.get("type")) {
			collectionName = "alarm_statis_per_day";
		//按小时
		}else if(0 == (Integer)paramMap.get("type")){
			collectionName = "alarm_statis_per_hour";
		}
        
		AggregationResults<AlarmStatisDto> outputTypeCount1 = mongoTemplate.aggregate(aggregation1, collectionName,
				AlarmStatisDto.class);
		List<AlarmStatisDto> mappedResults = outputTypeCount1.getMappedResults();

        // 分组函数 同样可以实现上面分组求和功能
        /*GroupBy groupBy = new GroupBy("statisDate").
                initialDocument("{date : '', value : 0}").
                reduceFunction("function(doc, prev){"
                        + "prev.date = doc.statisDate;"
                        + "prev.value += doc.total;"
                        + "}");

        GroupByResults<AlarmStatisDto> statisResults = mongoTemplate.group(criteria, "alarm_statis_per_day", groupBy, AlarmStatisDto.class);

        Iterator<AlarmStatisDto> iterator = statisResults.iterator();*/
		return mappedResults;
	}

	@Override
	public AlarmStatisDto getAlarmStatisParam(AlarmStatisParam param) {
	       logger.info("getAlarmStatisToday start");

	        Criteria criteria = Criteria.where("createDate").gte(param.getBegin()).lte(param.getEnd());
	        if (StringUtils.isNotBlank(param.getSpCode())) {
	        	criteria.and("spCode").is(param.getSpCode());
	        }
	        if (StringUtils.isNotBlank(param.getProductCode())) {
	            criteria.and("produCode").is(param.getProductCode());
	        }
	        if (StringUtils.isNotBlank(param.getDeviceType())) {
	            criteria.and("deviceType").is(param.getDeviceType());
	        }
	        if (StringUtils.isNotBlank(param.getDeviceCode())) {
	            criteria.and("deviceCode").is(param.getDeviceCode());
	        }
	        if (StringUtils.isNotBlank(param.getDeviceGroupCode())) {
	        	criteria .and("deviceGroupCodes").is(param.getDeviceGroupCode());
	        }

	        Query query = Query.query(criteria);
	        int count = (int) mongoTemplate.count(query, AlarmInfo.class);
	        AlarmStatisDto dto = new AlarmStatisDto();
	        if (param.getStatisType() == 1) {
	        	dto.setDate(DateUtil.date2string(param.getEnd(), DateUtil.YYYYMMDD));
			}else {
				dto.setDate(DateUtil.date2string(param.getEnd(), DateUtil.YYYYMMDDHH).substring(0,13)+":00:00");
			}
	        dto.setUpdateTime(new Date());
	        dto.setValue(count);
	        return dto; 
	}

}

 对内嵌文档的某个字段按天(小时)分组求最大值

数据格式

{
    "_id" : ObjectId("5eb66d53fa92d16ba17cedc6"),
    "spCode" : "project_99c7041d7c274df6a0049935231d9f6c",
    "spName" : "交付中心",
    "productId" : "PC_1578358882051",
    "productName" : "红外传感器",
    "deviceType" : "WeiChuanInfraredSensor_304C",
    "deviceCode" : "ffffff100000a58b",
    "deviceName" : "公司红外感应",
    "reportData" : {
        "voltage" : "18.8"
    },
    "createDate" : ISODate("2020-05-09T08:44:03.000Z"),
    "deviceTypeName" : "人体红外",
    "productGroupCodes" : [],
    "msgSource" : "da",
    "msgCode" : "updata",
    "msgId" : "5608",
    "msgStatus" : "100",
    "serviceId" : "CoshipElevator",
    "confirm" : "false",
    "port" : "10",
    "imageCodes" : [],
    "_class" : "com.coship.da.model.DcReportRecords"
}

 代码

Criteria criteria = Criteria.where("createDate").gte(DateUtil.string2Date(param.getStartTime())).lte(DateUtil.string2Date(param.getEndTime()));

		criteria.and("deviceCode").is(param.getDeviceCode());
		String propertyName = "reportData."+ param.getPropertyCode();
		String format ;
		if("1".equals(param.getGroupType())){
			format = "%Y-%m-%d";
		}else{
			format = "%H:00";
		}

		Aggregation aggregation = Aggregation.newAggregation(
				Aggregation.match(criteria),
				Aggregation.project("reportData", "createDate").andExpression("{$dateToString:{format:'"+format+"', date: '$createDate', timezone: 'Asia/Shanghai'}}").as("date"),
				Aggregation.group("date")
						.max(propertyName).as("propertyValue")
						.first("createDate").as("createDate").first("date").as("date"));
		AggregationResults<JSONObject> results = mongoTemplate.aggregate(aggregation, "t_dc_report_records", JSONObject.class);


		List<JSONObject> mappedResults = results.getMappedResults();

返回

[{
      "_id": "16:00",
      "propertyValue": "18.8",
      "createDate": {
        "date": 9,
        "day": 6,
        "hours": 16,
        "minutes": 44,
        "month": 4,
        "seconds": 3,
        "time": 1589013843000,
        "timezoneOffset": -480,
        "year": 120
      },
      "date": "16:00"
    },

{
    "_id": "17:00",
      "propertyValue": "19.8",
      "createDate": {
        "date": 9,
        "day": 6,
        "hours": 16,
        "minutes": 44,
        "month": 4,
        "seconds": 3,
        "time": 1589013843000,
        "timezoneOffset": -480,
        "year": 120
      },
      "date": "17:00"
    },
}]

 

liao0801_123
关注
专栏目录
springboot使用MongoTemplate分组统计数据
Mr_Dai的博客
06-02 6433
根据messageStatus字段分组统计不同状态的数据量，相当于mysql里的group by 关键字。 使用mongo里的aggregation聚合关键字。 import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.data.mongodb.c..
mongoTemplate 聚合分组统计，aggregate分页
liupan7891的博客
08-20 7639
/** *mongoTemplate 聚合分组统计返回分组列表 */ public Page<Log> groupStatistics(String compCampId, Long productId, Integer page, Integer size) { if (page<1){page=1;} Integer star...
Java MongoTemplate 根据时间进行分组统计
heart_hj的博客
12-09 1043
Java MongoTemplate 根据时间进行分组统计
MongoDB mongoTemplate 分组统计并修改返回值名
最新发布
王小工小工历程
07-31 798
请注意，我在group阶段中按field1和field2进行了分组，并计算了每个组的文档数（使用.count().as(“count”)）。然后，在project阶段中，我重命名了这些字段（尽管在这个特定示例中，field1和field2只是被简单地传递并重新命名，但可能想根据需要进行更复杂的操作）。注意：上面的代码示例中，我使用了Aggregation.project(“quota”).and(“quota”).as(“quotaLimit”)来重命名quota字段为quotaLimit。
mongoTemplate实现统计和分组
11-29
附件为mongoDB之Java通过group函数来实现统计和分组的文档描述
mongoTemplate使用group函数进行分组和统计
热门推荐
不当初
11-28 2万+
1 简介 在工作的过程中，使用MongoDB存储业务数据，有时候想做的不仅仅是将数据从MongoDB中提取出来，可能需要对数据进行分析并加以利用。在党费收缴模块开发过程中，需要根据党支部名称进行分组，统计出党支部内人员的数目，每个党支部应缴党费和实缴党费的总和 等统计信息。 由于spring-data-mongodb-1.9.5.RELEASE版本太低，因此在调用mongoTemplate类型的a...
spring-mongoDB mongoTemplate排序分组|分页|统计
zoeou的博客
11-11 5934
包含一些mongo的常用操作：统计求和，常规排序，分页，查询子文档，查询子文档的数组，排序后分组，按条件删除等
mongoTemplate条件查询，排序，分页，聚合分组查询
rwh19951022的博客
05-24 1174
mongoTemplate条件查询，排序，分页，聚合分组查询
使用MongoTemplate 对 mongodb数据进行分组、排序、分页、连表查询
知道的越多 不知道的就越多
09-23 7783
聚合查询（分组、排序、分页、连表）
MongoTemplate聚合查询代码解析
qq_51493136的博客
11-02 745
语法:aggregate([{$group:{_id:"$要分组的字段",分组函数处理后的数据名:{分组函数:"执行分组函数的字段"}}}])(6).$addToSet:把值加入数组中,若存在重复则不添加。(4).$first/$last:分组的第一条/最后一条数据。(5).$push:把值加入数组中,允许存在重复。(3).$min/$max:求最小/大值。(2).$avg:求平均值。(2) 不展示该字段:0。6.集合合并:$merge。(1) 展示该字段:1。(1).$sum:求和。
mongoTemplate 按播放量统计,按分类分组,分页查询
05-18
可以使用 MongoDB 的聚合操作来实现按播放量统计、按分类分组、分页查询的功能。以下是一个示例代码： ```java public List<Document> aggregateByCategoryAndViews(int pageSize, int pageNumber) { Aggregation ...
mongotemplate模糊查_开发中使用mongoTemplate进行Aggregation聚合查询
weixin_39942995的博客
12-22 448
笔记:使用mongo聚合查询(一开始根本没接触过mongo，一点一点慢慢的查资料完成了工作需求)需求：在订单表中，根据buyerNick分组，统计每个buyerNick的电话、地址、支付总金额以及总商品数，返回结果是CustomerDetail。/** project:列出所有本次查询的字段，包括查询条件的字段和需要搜索的字段；* match:搜索条件criteria* unwind：某一个字段是...
利用MongoTemplate 简单实现MongoDB 增删改查
MR_wb的博客
06-06 1451
MongoTemplate简单实现数据的增删查改
mongoTemplate 聚合分组统计复杂条件分组sum\去重\$project\$cond\$addToSet
liupan7891的博客
12-14 3727
sql 原型：在这里插入代码片db.order.aggregate({ $match: { “course_mode”: { $gt: 2 }, “is_new”: 1 } }, { KaTeX parse error: Expected '}', got 'EOF' at end of input: … "part_mode": "part_mode" }, “student_total”: {...
java mongoTemplate的group统计
weixin_30894583的博客
06-20 675
@Service public class MongoCountServiceImpl implements MongoCountService { @Autowired private MongoTemplate mongoTemplate; @Override public List<MongoCountDTO> count(Str...
JAVA mongodb mongoTemplate 多字段多条件 分组统计 时间转换 并且返回想要的值
流浪猿
03-30 4130
最近在做订单汇总、商品汇总等等查询，mongo 以前用的不多，最近研究的一点东西，记录一下 javabean 订单详情明细类(包含商品信息) @Data @Document(collection = "order_info") public class OrderMongoEntity extends BaseEntity implements Serializable { private static final long serialVersionUID = 1L; ..
使用mongoTemplate进行数据统计，部分数据在mongodb
jesseXu的博客
09-18 1174
带分页的数据查询，主数据还是从关系型数据库MySQL中查询出来的，然后从结果集中获取相关条件，然后根据条件去mongodb中进行数据统计。 注意： mongodb对数据类型敏感，类型一定要填对，不然查询不到数据。 话不多说，直接上代码。 package com.xjx.services; import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang.StringUtils; import org.springframework.bea
spring mongoTemplate 统计
eumenides_的博客
09-10 4637
背景介绍 上篇spring mongoTemplate 分表分页查询介绍了数据被分散到多个集合中怎么查，现在同时也迎来了怎么统计的问题，由于原来所有数据在mysql一张表所以不管怎么查，怎么统计都很方便，我查看了一下原来统计的代码，发现大佬就写了一行，当然sql不止一行，后来我改好后发现，卧槽！！！写了300多行。 统计计划 由于发出去的短信实时都有状态报告回来，上篇文章中提到的2个集合实...
mongotemplate分页
09-03
使用MongoTemplate进行分页查询，可以按照以下步骤进行操作： 1. 创建一个Query对象，设置需要查询的条件。例如，如果要查询所有数据，可以使用new Query()。 2. 使用MongoTemplate的count方法获取符合条件的总记录数。这将用于计算分页信息。 ```java long totalCount = mongoTemplate.count(query, YourEntity.class); ``` 3. 设置分页参数，包括页码和每页显示的记录数。 ```java int pageNumber = 1; // 页码从1开始 int pageSize = 10; // 每页显示10条记录 ``` 4. 创建一个Pageable对象，指定分页参数。 ```java Pageable pageable = PageRequest.of(pageNumber - 1, pageSize); ``` 5. 使用MongoTemplate的find方法进行分页查询。 ```java List<YourEntity> resultList = mongoTemplate.find(query.with(pageable), YourEntity.class); ``` 6. 返回分页结果，包括查询到的数据列表和分页信息。 ```java Page<YourEntity> pageResult = new PageImpl<>(resultList, pageable, totalCount); return pageResult; ``` 这样，你就可以通过MongoTemplate执行分页查询了。注意替换"YourEntity"为你的实体类名，并根据实际需求设置查询条件和分页参数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值