MongoTemplate中$in、$gt、$addToSet、$elemMatch、排序、分页的使用

最新推荐文章于 2024-05-24 11:15:53 发布
最新推荐文章于 2024-05-24 11:15:53 发布
阅读量7.8k 收藏 13
点赞数 5
分类专栏： MongoDB基础进阶 文章标签： mongodb
原文链接：https://blog.csdn.net/qq_39198749/article/details/106077957
版权

1. mongoDB中的使用

示例文档

// 1
{
    "_id": "123",
    "age": 25,
    "likes": []
}

// 2
{
    "_id": "456",
    "age": 23,
    "likes": []
}

1.1 $in

相当于sql中的in

db.collcetion.find({"_id":{"$in":["123","456"]}})

1.2 $gt

 

  • (>) 大于 - $gt
  • (<) 小于 - $lt
  • (>=) 大于等于 - $gte
  • (<= ) 小于等于 - $lte
db.collcetion.find({"age":{"$gt":20}})

1.3 $addToSet

添加值到一个数组中，如果该数组中已经存在该值，则不会添加；如果不存在该值，则添加

db.collcetion.update({"_id":"123"}, {"$addToSet":{"likes":"PingPang"}})

如果想要批量添加list，需要配合$each使用

db.collcetion.update({"_id":"123"}, {"$addToSet":{"likes":{"$each":["PingPang","FootBall","BasketBall"]}}})

1.4 $elemMatch

测试文档

// 1
{
    "_id": "123",
    "user": [
        {
            "name": "qushuai1",
            "address": "BeiJing",
            "age": "22"
        },
        {
            "name": "qushuai2",
            "address": "TianJing",
            "age": "23"
        },
        {
            "name": "qushuai3",
            "address": "ShangHai",
            "age": "23"
        },
        {
            "name": "qushuai4",
            "address": "ShenZhen",
            "age": "23"
        }
    ]
}

mongoDB语句

db.my_test.find({"_id":"123"},{"user":{$elemMatch:{"age":"22"}}})

返回结果

{
    "_id": "123",
    "user": [
        {
            "name": "qushuai1",
            "address": "BeiJing",
            "age": "22"
        }
    ]
}

注意：使用$elemMatch时，只会返回仅仅匹配到的第一个合适的元素，所以对于数组中只有一个返回元素时，我们可以使用该操作符；对于返回多个元素时，则不可以使用。

下面介绍如何返回多个元素

db.my_test.aggregate([{"$unwind":"$user"},
{"$match":{"user.age":"23"}},
{"$project":{"user":1}}])

返回

// 1
{
    "_id": "123",
    "user": {
        "name": "qushuai2",
        "address": "TianJing",
        "age": "23"
    }
}

// 2
{
    "_id": "123",
    "user": {
        "name": "qushuai3",
        "address": "ShangHai",
        "age": "23"
    }
}

// 3
{
    "_id": "123",
    "user": {
        "name": "qushuai4",
        "address": "ShenZhen",
        "age": "23"
    }
}

$unwind：将数组中的每一个元素转为每一条文档

db.my_test.aggregate([{"$unwind":"$user"}])

返回

// 1
{
    "_id": "123",
    "user": {
        "name": "qushuai1",
        "address": "BeiJing",
        "age": "22"
    }
}

// 2
{
    "_id": "123",
    "user": {
        "name": "qushuai2",
        "address": "TianJing",
        "age": "23"
    }
}

// 3
{
    "_id": "123",
    "user": {
        "name": "qushuai3",
        "address": "ShangHai",
        "age": "23"
    }
}

// 4
{
    "_id": "123",
    "user": {
        "name": "qushuai4",
        "address": "ShenZhen",
        "age": "23"
    }
}

$match：简单的过滤文档，条件查询

db.my_test.aggregate([{"$unwind":"$user"},{"$match":{"user.name":"qushuai2","_id":"123"}}])

返回

// 1
{
    "_id": "123",
    "user": {
        "name": "qushuai2",
        "address": "TianJing",
        "age": "23"
    }
}

$project：修改输入文档的结构，也可以控制返回文档中哪些字段显示(1)、哪些字段不显示(0)，默认显示“_id“字段

db.my_test.aggregate([{"$unwind":"$user"},{"$match":{"user.age":"23","_id":"123"}},{"$project":{"user":0}}])

返回

// 1
{
    "_id": "123"
}
// 2
{
    "_id": "123"
}
// 3
{
    "_id": "123"
}

1.5 sort()排序

在 MongoDB 中使用 sort() 方法对数据进行排序，sort() 方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而 -1 是用于降序排列。

db.scheduleInfo.find({},{}).sort({"property":1})

1.6 分页

方法一： 通过skip()、limit()配合使用(当数据量较大时，使用skip()效率会比较低)
不要轻易的使用skip()，因为skip是一条一条的数过来的，数据量比较大时，效率会比较慢

db.scheduleInfo.find({},{}).sort({"property":1}).skip(2*5).limit(5)

方法二： 获取前一页的最后一条记录，查询之后的指定条记录

2. MongoTemplate中的应用

首先了解下Criteria，基本文档的查询操作符

2.1 $in

Query query = new Query(Criteria.where("key").in(List));

2.2 $gt

Query query = new Query(Criteria.where("id").gt(123));

2.3 $addToSet

Query query = new Query(Criteria.where("_id").is(123))
 Document updateDoc = new Document();
 updateDoc.append("$addToSet", new Document().append("listKey", gameId));
 BasicUpdate update = new BasicUpdate(updateDoc);
 // 实现数据存在就更新，不存在就插入数据
 mongoTemplate.upsert(query, update, docName);

2.4 $elemMatch

// 类似结构{"_id":"12345","listKey": [{"property1": "XXX1","property2": "XXX2"},{"property1": "YYY1","property2": "YYY2"}]}
Criteria findModelCriteria = Criteria.where("_id").is("0");
// listKey表示数组的key,property表示listKey下的一个元素中的属性。
Criteria findFuelCriteria = Criteria.where("listKey").elemMatch(Criteria.where("property1").is("XXXX"));
BasicQuery basicQuery = new BasicQuery(findModelCriteria.getCriteriaObject(), findFuelCriteria.getCriteriaObject());
Document document= mongoTemplate.findOne(basicQuery, Document.class, docName);

2.5 排序、分页

此处转载博文： https://blog.csdn.net/liao0801_123/article/details/95311837

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: 分页查询
     * @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;
    }
 
    /*
     * 指定字段 且返回最新的数据
     */
    @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; 
    }
 
}

 

pengjunlee
关注
  • 5
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jQuery教程 $()包装函数来实现数组元素分页效果
10-27
最近一周在做中文站搜索礼品widget的需求，这个需求中有一个分页的功能
MongoDB聚合运算符：$gt
superatom01的博客
03-19 690
摘要：`$gt`聚合运算符用于比较两个值，如果第一个大于第二个，返回`true`；如果第一个小于等于第二个，返回`false`。
MongoDB的比较操作符$in
穷目楼的博客 - 昨日所记，今日所想，明日所学
04-01 5121
$in操作符用于选择某个域的值等于其后指定的数组中的任意值的文档。 { field: { $in: [<value1&gt;, <value2&gt;, ... <valueN&gt; ] } } 域本身可以是数组，此时$in将会选择域数组中有至少任意一值等于其后指定的数组中的任意一个值的文档。 单值域的$in匹配 db.inventory.find( { qty: { $in...
mongoTemplate条件查询，排序，分页，聚合分组查询
最新发布
rwh19951022的博客
05-24 402
mongoTemplate条件查询，排序，分页，聚合分组查询
spring data mongo （Mongotemplate） 的高级常用查询
qq_27886997的博客
11-06 1623
数组字段查询elemMatch 1、查询数组元组 比如 每条记录都有 score:[23,45,20]，想查询score 所有分数都大于多少分数，或者含有等于多少分的 @Test public void testFind3(){ final BasicDBObject test = new BasicDBObject("score", new BasicDBObject("$elemMatch", new BasicDBObject("$gt", 90).append...
vuejs2.0实现分页组件使用$emit进行事件监听数据传递的方法
10-20
主要介绍了vuejs2.0实现分页组件使用$emit进行事件监听数据传递的方法，非常不错，具有参考借鉴价值，,需要的朋友可以参考下
如何在Redis中实现分页排序查询过程解析
08-18
主要介绍了如何在Redis中实现分页排序查询过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
MongoDB之$in的用法
小新正在敲代码
09-12 4万+
$in The $in operator selects the documents where the valueof a field equals any value in the specified array. To specify an$in expression, use the following prototype: For comparison of different
MongoTemplate基础使用
qq_44188658的博客
05-27 2329
一、普通查询操作 1.is查询 Query query = new Query(); // where...is... 相当于 where ? = ? query.addCriteria(Criteria.where("数据库表字段名").is("你的参数")); //分页条件 query.skip(size*(page-1)).limit(size); // findOne 返回的是一个对象 Class代表你的表对应的映射类 mongoTemplate.findOne(query, Class.class
HTML中&gt的含义
热门推荐
奔跑的蜗牛
09-25 12万+
在html里写& g t ; 页面输出 "> "
使用MongoTemplate实现类似MySQL中的IN查询功能
JonTang的博客
07-11 1028
使用MongoTemplate实现类似MySQL中的IN查询功能
《MongoDB入门教程》第08篇 比较运算符
Tony.Dong的专栏
07-24 789
本文将会介绍MongoDB中查找文档时常用的一些比较运算符，包括$eq、$gt、$gte、$lt、$lte、$ne、$in以及$nin。
MongoDB数组更新操作$addToSet和$each修饰符
OceanSky的专栏
12-02 3万+
一、定义$addToSet $addToSet添加值到一个数组中去，如果数组中已经存在该值那么将不会有任何的操作。 $addToSet的操作格式如下： { $addToSet: { : , ... } } 二、考虑一个集合文档test，包含一个数组字段letters { _id: 1, letters: ["a", "b"] } 如下操作添加数组["c", "d"]到字段letters
MongoDB聚合运算符：$in
superatom01的博客
03-21 595
摘要：`$in`聚合运算符返回数组中是否存在指定的值
MongoDB中的常用操作$addToSet、$pop和$rename
一起学习
12-22 1303
本文主要介绍MongoDB的常用操作$addToSet、$pop和$rename。
mongotemplate范围查询_spring data mongo （Mongotemplate） 的高级常用查询
weixin_29706315的博客
12-23 624
数组字段查询elemMatch1、查询数组元组 比如 每条记录都有 score:[23,45,20]，想查询score 所有分数都大于多少分数，或者含有等于多少分的@Testpublic void testFind3(){final BasicDBObject test = new BasicDBObject("score", new BasicDBObject("$elemMatch",...
【MongoDB】万字长文，命令与代码一一对应SpringBoot整合MongoDB之MongoTemplate
qq_61903414的博客
08-08 2159
命令：db.comment.insert({_id:"4",nickname:"ww",content:"这位是谁啊",userId:3,createTime:……命令：db.collectionName.find({ "nickname": "ww" }).sort({ "like": 1 })命令：db.comment.find({ "like": { $gt: 0, $lt: 5 } })命令：db.comment.find({}).skip(2).limit(2)
使用mongotemplate分页查询
06-06
好的，下面是使用MongoTemplate进行分页查询的步骤： 1. 创建一个Query对象，设置查询条件和排序方式。 ```java Query query = new Query(); query.addCriteria(Criteria.where("name").is("张三")); query.with(Sort.by(Sort.Direction.ASC, "age")); ``` 2. 获取总记录数。 ```java long total = mongoTemplate.count(query, User.class); ``` 3. 设置分页参数，执行查询。 ```java PageRequest pageRequest = PageRequest.of(pageNum - 1, pageSize); query.with(pageRequest); List<User&gt; userList = mongoTemplate.find(query, User.class); ``` 4. 将查询结果封装成Page对象，返回给调用方。 ```java Page<User&gt; page = new PageImpl<&gt;(userList, pageRequest, total); return page; ``` 其中，pageNum和pageSize表示当前页码和每页记录数，User.class表示需要查询的实体类。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值