MongoDB常用方法

package com.anji.allways.business.document.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.anji.allways.base.aop.LoggerManage;
import com.anji.allways.base.entity.BaseRequestModel;
import com.anji.allways.base.entity.BaseResponseModel;
import com.anji.allways.business.document.entity.DocumentEntity;
import com.anji.allways.business.document.entity.FileEntity;
import com.anji.allways.common.enumeration.DeleteStatusE;
import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;
import com.mongodb.WriteResult;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.bson.types.ObjectId;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.regex.Pattern;

/**
 * 文档处理
 */
@RestController
@RequestMapping(value = "/archives/document/mongodb")
public class TestMongoDB {

    private Logger logger = LogManager.getLogger(TestMongoDB.class);

    @Autowired
    private MongoTemplate mongoTemplate;

    private static final String DOC_COLLECTION_NAME = "anji_doc_test";

    private static final String FILE_COLLECTION_NAME = "anji_file_test";

    @RequestMapping("insert")
    @LoggerManage(description = "新增")
    public BaseResponseModel insert(@RequestBody BaseRequestModel baseRequestModel) {
        BaseResponseModel baseResponseModel = new BaseResponseModel();

        //获取文档入参JSON
        DocumentEntity documentEntity = JSON.parseObject(baseRequestModel.getReqData().toString(), DocumentEntity.class);

        //获取文件JSON
        String fileJson = baseRequestModel.getReqData().get("fileMap").toString();

        //获取json方式
        //方式1 getJSONObject
        JSONObject jsonObject = baseRequestModel.getReqData();
        JSONObject jsonObject1 = jsonObject.getJSONObject("fileMap");

        //方式2，get("key")
        JSONObject oaMsg = JSONObject.parseObject(baseRequestModel.getReqData().toString());
        JSONObject oaMsg1 = (JSONObject) oaMsg.get("fileMap");

        //错误方式
        //JSONObject jsonObject2 = baseRequestModel.getReqData();
        //JSONObject jsonObject3 = (JSONObject) jsonObject2.get("fileMap");

        //方式3
        String fileJsonTwo = JSON.toJSONString(baseRequestModel.getReqData().get("fileMap"));
        FileEntity fileEntity = JSON.parseObject(fileJsonTwo, FileEntity.class);

        // 新增文档
        documentEntity.setCreateUser("maidi");
        documentEntity.setCreateTime(new Date());
        documentEntity.setUpdateUser("maidi");
        documentEntity.setUpdateTime(new Date());
        documentEntity.setIsDel(DeleteStatusE.USEFUL.getValue());
        //mongoTemplate.insert(documentEntity, DOC_COLLECTION_NAME);
        mongoTemplate.save(documentEntity, DOC_COLLECTION_NAME);

        // 新增文件
        fileEntity.setCreateUser("rose");
        fileEntity.setCreateTime(new Date());
        fileEntity.setUpdateUser("rose");
        fileEntity.setUpdateTime(new Date());
        fileEntity.setIsDel(DeleteStatusE.USEFUL.getValue());
        //mongoTemplate.insert(fileEntity, FILE_COLLECTION_NAME);
        mongoTemplate.save(fileEntity, FILE_COLLECTION_NAME);

        baseResponseModel.setRepCode("0000");
        baseResponseModel.setRepMsg("新增成功");
        return baseResponseModel;
    }

    @RequestMapping("update")
    @LoggerManage(description = "新增")
    public BaseResponseModel update(@RequestBody BaseRequestModel baseRequestModel) {
        BaseResponseModel baseResponseModel = new BaseResponseModel();

        //获取文档入参JSON
        DocumentEntity documentEntity = JSON.parseObject(baseRequestModel.getReqData().toString(), DocumentEntity.class);

        String fileJsonTwo = JSON.toJSONString(baseRequestModel.getReqData().get("fileMap"));
        FileEntity fileEntity = JSON.parseObject(fileJsonTwo, FileEntity.class);

        documentEntity.setUpdateUser("maidiUp");
        documentEntity.setUpdateTime(new Date());
        Query query = new Query();
        /*《指定更新条件》*/
        //方式1
        query.addCriteria(Criteria.where("_id").is(documentEntity.getId()).and("type").is(documentEntity.getType()));
        //方式2
        //Query query2 = new Query(Criteria.where("_id").is(documentEntity.getId()).and("type").is(documentEntity.getType()));

        /*《封装多个更新字段》*/
        //方式1
        Update update1 = Update.update("name", "第9527号档案update11").set("serialNum", "0000000000011");
        //方式2
        Update update2 = new Update();
        update2.set("name", "第9527号档案update11").set("serialNum", "0000000000011");
        //方式3
        DBObject dbDoc = new BasicDBObject();
        mongoTemplate.getConverter().write(documentEntity, dbDoc);
        Update update = new Update();
        for (String key : dbDoc.keySet()) {
            update.set(key, dbDoc.get(key));
        }

        /*《更新方法》*/
        //入参是实体，没指定表名的，应该是在实体中指定了表名，更新失败
        /*WriteResult writeResultDoc = mongoTemplate.updateFirst(query, update, DocumentEntity.class);
        int m = writeResultDoc.getN();*/

        //1，更新符合条件的第一条数据
        //方式1
        WriteResult writeResult = mongoTemplate.updateFirst(query, update, DOC_COLLECTION_NAME);
        //方式2，多个参数区别？
        //mongoTemplate.updateFirst(query, update, DocumentEntity.class, DOC_COLLECTION_NAME);
        //2，更新符合条件的所有数据
        //mongoTemplate.updateMulti(query, update, DOC_COLLECTION_NAME);
        int n = writeResult.getN();
        logger.info("成功更新数据条数：" + n);

        baseResponseModel.setRepCode("0000");
        baseResponseModel.setRepMsg("修改成功");
        return baseResponseModel;
    }

    @RequestMapping("query")
    @LoggerManage(description = "查询")
    public BaseResponseModel query(@RequestBody BaseRequestModel baseRequestModel) {
        BaseResponseModel baseResponseModel = new BaseResponseModel();
        int page = Integer.parseInt(baseRequestModel.getReqData().get("page").toString());
        int size = Integer.parseInt(baseRequestModel.getReqData().get("size").toString());

        //获取文档入参JSON
        DocumentEntity documentEntity = JSON.parseObject(baseRequestModel.getReqData().toString(), DocumentEntity.class);

        //多条件查询
        //方式1
        Query query = new Query();
        query.addCriteria(Criteria.where("type").is(3).and("status").is("0"));
        //方式2
        Query query01 = new Query();
        query01.addCriteria(Criteria.where("type").is(3));
        query01.addCriteria(Criteria.where("status").is(0));
        //方式3
        Query query02 = new Query(Criteria.where("type").is(3).and("status").is(0));

        //方式4
        Criteria criteria = new Criteria();
        criteria.and("type").is(0);
        criteria.and("status").is(0);
        Query query03 = new Query(criteria);

        List<DocumentEntity> documentEntityList = mongoTemplate.find(query, DocumentEntity.class, DOC_COLLECTION_NAME);
        logger.info("根据条件查询所有：" + documentEntityList.size());

        //ID查询
        DocumentEntity documentEntity1 = mongoTemplate.findById(documentEntity.getId(), DocumentEntity.class, DOC_COLLECTION_NAME);
        logger.info("根据ID查询：" + documentEntity1);
        DocumentEntity documentEntity1Id = mongoTemplate.findById(new ObjectId(documentEntity.getId()), DocumentEntity.class, DOC_COLLECTION_NAME);
        logger.info("根据ID查询2：" + documentEntity1Id);

        //第一条查询
        DocumentEntity documentEntity2 = mongoTemplate.findOne(query, DocumentEntity.class, DOC_COLLECTION_NAME);
        logger.info("查询符合条件第一条：" + documentEntity2);

        //查询总量
        long count = mongoTemplate.count(query, DOC_COLLECTION_NAME);
        long count1 = mongoTemplate.count(query, DocumentEntity.class, DOC_COLLECTION_NAME);
        logger.info("查询符合条件总量：" + count + ";" + count1);

        //in
        List<String> strings = Arrays.asList("0", "1");
        Query query1 = new Query(Criteria.where("status").in(strings));
        List<DocumentEntity> documentEntityIn = mongoTemplate.find(query1, DocumentEntity.class, DOC_COLLECTION_NAME);
        logger.info("查询in条件总量：" + documentEntityIn.size());

        //范围查询
        Query query2 = new Query(Criteria.where("status").gte(0).lte(2));
        List<DocumentEntity> documentEntityFanwei = mongoTemplate.find(query2, DocumentEntity.class, DOC_COLLECTION_NAME);
        logger.info("范围查询条件总量：" + documentEntityFanwei.size());

        //模糊查询
        Query query3 = new Query(Criteria.where("name").regex("9527"));
        List<DocumentEntity> documentEntityMohu = mongoTemplate.find(query3, DocumentEntity.class, DOC_COLLECTION_NAME);

        Pattern pattern = Pattern.compile("^.*" + "9521" + ".*$", Pattern.CASE_INSENSITIVE);
        Query query4 = new Query(Criteria.where("name").regex(pattern));
        List<DocumentEntity> documentEntityPattern = mongoTemplate.find(query4, DocumentEntity.class, DOC_COLLECTION_NAME);
        logger.info("模糊查询总量：" + documentEntityMohu.size());
        logger.info("模糊查询总量：" + documentEntityPattern.size());


        //完全匹配
        Pattern pattern1 = Pattern.compile("^9527$", Pattern.CASE_INSENSITIVE);
        //右匹配
        Pattern pattern2 = Pattern.compile("^.*9527$", Pattern.CASE_INSENSITIVE);
        //左匹配
        Pattern pattern3 = Pattern.compile("^9527.*$", Pattern.CASE_INSENSITIVE);
        //模糊匹配
        Pattern pattern4 = Pattern.compile("^.*9527.*$", Pattern.CASE_INSENSITIVE);
        Query query5 = new Query(Criteria.where("name").regex(pattern));
        List<DocumentEntity> documentEntityP = mongoTemplate.find(query4, DocumentEntity.class, DOC_COLLECTION_NAME);

        //or查询
        Query query6 = new Query();
        Criteria criteria1 = new Criteria();
        criteria1.orOperator(Criteria.where("type").is(0));
        //criteria1.orOperator(Criteria.where("status").is(0));
        query6.addCriteria(criteria1);
        List<DocumentEntity> documentOr = mongoTemplate.find(query6, DocumentEntity.class, DOC_COLLECTION_NAME);

        Query query7 = new Query();
        Criteria criteria2 = new Criteria();
        criteria2.orOperator(Criteria.where("type").is(0), Criteria.where("status").is(0));
        query7.addCriteria(criteria2);
        List<DocumentEntity> documentOr2 = mongoTemplate.find(query7, DocumentEntity.class, DOC_COLLECTION_NAME);

        /*《分页及排序》*/
        /**
         * skip limit 与 Pageable 区别
         * 1，第一个参数：前者是起始索引，后者是起始页；
         *    且注意 数据起始索引为0，起始页也为0，skip(1).limit(2) 从第二个数开始，包含他本身共两条数据（[1][2]）;PageRequest(1, 2),查询第二页的两条数据
         * 2，查询数 count为，符合条件总条数
         * 3，与mysql分页插件区别，PageRequest(1, 2)代表第一页，两条数据
         */
        //分页及排序
        Query query8 = new Query(Criteria.where("companyId").is(10000));
        query8.with(new Sort(new Sort.Order(Sort.Direction.DESC, "type"), new Sort.Order(Sort.Direction.DESC, "status"))).skip(page).limit(size);
        List<DocumentEntity> documentFenye8 = mongoTemplate.find(query8, DocumentEntity.class, DOC_COLLECTION_NAME);
        long n = mongoTemplate.count(query8, DocumentEntity.class, DOC_COLLECTION_NAME);


        Query query9 = Query.query(Criteria.where("companyId").is(10000)).with(new Sort(Sort.Direction.DESC, "status")).skip(page).limit(size);
        List<DocumentEntity> documentFenye9 = mongoTemplate.find(query9, DocumentEntity.class, DOC_COLLECTION_NAME);
        long l = mongoTemplate.count(query8, DocumentEntity.class, DOC_COLLECTION_NAME);

        //分页插件
        Query query11 = new Query();
        Pageable pageable = new PageRequest(page, size);
        query11.with(pageable).with(new Sort(Sort.Direction.DESC, "status"));
        List<DocumentEntity> document11 = mongoTemplate.find(query11, DocumentEntity.class, DOC_COLLECTION_NAME);
        long m = mongoTemplate.count(query11, DocumentEntity.class, DOC_COLLECTION_NAME);


        baseResponseModel.setRepCode("0000");
        baseResponseModel.setRepMsg("查询成功");
        return baseResponseModel;
    }

}

分页查询

起始页：0

页面：前端入参-1

if(p.getPageNum() == null || p.getPageNum() <=0){
    p.setPageNum(0);
} else {
    p.setPageNum(p.getPageNum()-1);
}
Pageable pageable=new PageRequest(p.getPageNum(),p.getPageRows());
//查询出一共的条数
Long count =  mongoTemplate.count(query, TableNameUtils.getTableName(request.getCompanyId(), p));
//查询
List<T> list = mongoTemplate.find(query.with(pageable), tClass, TableNameUtils.getTableName(request.getCompanyId(), p));

排序-多条件

List<Order> orders = new ArrayList<>();

if(CollectionUtils.isEmpty(list)){
    orders.add(new Order(Sort.Direction.DESC, "serialNum"));
    Sort sort = new Sort(orders);
    query.with(sort);
    return ;
}

查询对象中包含对象信息，如下图，查询accountUser

 查询条件这样拼装

documentMap.accountUser
Criteria criteria = new Criteria();
criteria.and("documentMap.accountUser").is("");