经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 数据库/运维 » MongoDB » 查看文章
SpringBoot集成Mongodb文档数据库
来源：cnblogs　　作者：zhαojh　　时间：2024/7/8 10:19:13　　对本文有异议

添加Maven依赖

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-data-mongodb</artifactId>
  4. </dependency>

配置Mongodb连接信息

  1. spring:
  2.   data:
  3.     mongodb:
  4.       host: 10.30.29.246
  5.       port: 16030
  6.       authenticationDatabase: admin # 登录用户的认证库
  7.       database: nrdt
  8.       username: admin
  9.       password: QAZqaz@123321

通用服务(动态集合数据)

以下代码实现主要针对集合名称和字段都是未知的情况

  1. @Slf4j
  2. @Component
  3. public class MongodbService {
  5.     @Autowired
  6.     private MongoTemplate mongoTemplate;
  8.     /**
  9.      * 新增集合（表）
  10.      *
  11.      * @param collName
  12.      */
  13.     public void addCollection(String collName) {
  14.         Assert.notEmpty(collName, "collName");
  15.         boolean bol = mongoTemplate.collectionExists(collName);
  16.         if (!bol) {
  17.             mongoTemplate.createCollection(collName);
  18.         }
  19.     }
  21.     /**
  22.      * 删除集合（表）
  23.      *
  24.      * @param collName
  25.      */
  26.     public void dropCollection(String collName) {
  27.         Assert.notEmpty(collName, "collName");
  28.         boolean bol = mongoTemplate.collectionExists(collName);
  29.         if (bol) {
  30.             mongoTemplate.dropCollection(collName);
  31.         }
  32.     }
  34.     /**
  35.      * 清空集合数据
  36.      *
  37.      * @param collName
  38.      */
  39.     public void clearCollection(String collName) {
  40.         Assert.notEmpty(collName, "collName");
  41.         boolean bol = mongoTemplate.collectionExists(collName);
  42.         if (bol) {
  43.             mongoTemplate.remove(new Query(), collName);
  44.         }
  45.     }
  47.     /**
  48.      * 修改字段名称
  49.      *
  50.      * @param collName
  51.      * @param oldName
  52.      * @param newName
  53.      * @return
  54.      */
  55.     public boolean editField(String collName, String oldName, String newName) {
  56.         Assert.notEmpty(collName, "collName");
  57.         Assert.notEmpty(oldName, "oldName");
  58.         Assert.notEmpty(newName, "newName");
  59.         Query query = new Query();
  60.         Update update = new Update();
  61.         update.rename(oldName, newName);
  62.         UpdateResult result = mongoTemplate.updateMulti(query, update, collName);
  63.         return result.wasAcknowledged();
  64.     }
  66.     /**
  67.      * 删除指定列
  68.      *
  69.      * @param collName
  70.      * @param field
  71.      */
  72.     public boolean dropField(String collName, String field) {
  73.         Assert.notEmpty(collName, "collName");
  74.         Assert.notEmpty(field, "field");
  75.         Query query = new Query();
  76.         Update update = new Update();
  77.         update.unset(field);
  78.         UpdateResult result = mongoTemplate.updateMulti(query, update, collName);
  79.         return result.wasAcknowledged();
  80.     }
  82.     /**
  83.      * 新增字段
  84.      *
  85.      * @param collName
  86.      * @param field
  87.      * @return
  88.      */
  89.     public boolean addField(String collName, String field) {
  90.         Assert.notEmpty(collName, "collName");
  91.         Assert.notEmpty(field, "field");
  92.         Query query = new Query();
  93.         query.fields().include(field);
  94.         boolean bol = mongoTemplate.exists(query, collName);
  95.         if(!bol){
  96.             Update update = new Update();
  97.             update.set(field, 0.00d);
  98.             UpdateResult result = mongoTemplate.updateMulti(query, update, collName);
  99.             return result.wasAcknowledged();
  100.         }
  101.         return false;
  102.     }
  104.     /**
  105.      * 新增多个字段
  106.      *
  107.      * @param collName
  108.      * @param fields
  109.      * @return
  110.      */
  111.     public boolean addFields(String collName, List<String> fields) {
  112.         Assert.notEmpty(collName, "collName");
  113.         Assert.notNull(fields, "fields");
  114.         Update update = new Update();
  115.         boolean status = false;
  116.         for (String field : fields) {
  117.             Query query = new Query();
  118.             query.fields().include(field);
  119.             boolean bol = mongoTemplate.exists(query, collName);
  120.             if(!bol){
  121.                 update.set(field, 0.00d);
  122.                 status = true;
  123.             }
  124.         }
  125.         if(status){
  126.             UpdateResult result = mongoTemplate.updateMulti(new Query(), update, collName);
  127.             return result.wasAcknowledged();
  128.         } else {
  129.             return false;
  130.         }
  131.     }
  133.     /**
  134.      * 批量新增行数据
  135.      *
  136.      * @param collName
  137.      * @param jsonArray
  138.      */
  139.     public void insert(String collName, JSONArray jsonArray) {
  140.         Assert.notEmpty(collName, "collName");
  141.         Assert.notNull(jsonArray, "jsonArray");
  142.         mongoTemplate.insert(jsonArray, collName);
  143.     }
  145.     /**
  146.      * 批量插入
  147.      * insert: 可以一次性插入一整个列表,不允许插入已存在的主键
  148.      * save:   需要遍历列表,进行一条一条的数据插入,主键存在则是修改
  149.      * @param collName
  150.      * @param list
  151.      */
  152.     public void insert(String collName, List<Document> list) {
  153.         Assert.notEmpty(collName, "collName");
  154.         Assert.notNull(list, "list");
  155.         mongoTemplate.insert(list, collName);
  156.     }
  158.     /**
  159.      * 修改行数据
  160.      *
  161.      * @param collName
  162.      */
  163.     public void edit(String collName, JSONObject jsonObject) {
  164.         Assert.notEmpty(collName, "collName");
  165.         Assert.notNull(jsonObject, "jsonObject");
  166.         mongoTemplate.save(jsonObject, collName);
  167.     }
  169.     /**
  170.      * 删除行数据
  171.      *
  172.      * @param collName
  173.      */
  174.     public boolean remove(String collName, String[] ids) {
  175.         Assert.notEmpty(collName, "collName");
  176.         Assert.notNull(ids, "ids");
  177.         Query query = new Query(Criteria.where(MongoConstants.ID_COLUMN).in(ids));
  178.         DeleteResult result = mongoTemplate.remove(query, collName);
  179.         return result.wasAcknowledged();
  180.     }
  182.     /**
  183.      * 抽样查询
  184.      * @param search
  185.      * @return
  186.      */
  187.     public List<Document> getListSample(SearchVo search){
  188.         List<AggregationOperation> list = new ArrayList<>();
  189.         list.add(Aggregation.sample(search.getSampleSize()));
  190.         if(StrUtil.isNotEmpty(search.getColumns())){
  191.             list.add(Aggregation.project(search.getColumns().split(",")));
  192.         }
  193.         Aggregation aggregation = Aggregation.newAggregation(list);
  194.         return mongoTemplate.aggregate(aggregation, search.getCollName(), Document.class).getMappedResults();
  195.     }
  197.     /**
  198.      * 查询样本时间的上下限
  199.      * @param collName
  200.      * @return
  201.      */
  202.     public Map<String, Object> getTimes(String collName){
  203.         long startTime = System.currentTimeMillis();
  204.         Map<String, Object> map = new HashMap<>();
  205.         Assert.notEmpty(collName, "collName");
  206.         List<AggregationOperation> list = new ArrayList<>();
  207.         list.add(Aggregation.project(MongoConstants.TIME_COLUMN));
  208.         list.add(Aggregation.group().min(MongoConstants.TIME_COLUMN).as("minTime").max(MongoConstants.TIME_COLUMN).as("maxTime"));
  209.         Aggregation aggregation = Aggregation.newAggregation(list);
  210.         Document doc = mongoTemplate.aggregate(aggregation, collName, Document.class).getRawResults();
  211.         if(doc != null){
  212.             if(Convert.toInt(doc.get("ok")) == 1){
  213.                 List<Document> results =  doc.get("results", List.class);
  214.                 if(results != null && results.size() > 0){
  215.                     Document obj = results.get(0);
  216.                     if(obj != null){
  217.                         map.put("minTime", obj.getLong("minTime"));
  218.                         map.put("maxTime", obj.getLong("maxTime"));
  219.                     }
  220.                 }
  221.             }
  222.         }
  223.         if(CollUtil.isEmpty(map)){
  224.             map.put("minTime", null);
  225.             map.put("maxTime", null);
  226.         }
  227.         log.info("查询样本上下限时间,耗时:{}秒", (System.currentTimeMillis() - startTime)/1000);
  228.         return map;
  229.     }
  230.     /**
  231.      * 分页查询表数据
  232.      *
  233.      * @param search
  234.      * @return
  235.      */
  236.     public TableDataInfo getPage(SearchInput search) {
  237.         List<JSONObject> list = new ArrayList<>();
  238.         Query query = getQuery(search);
  239.         long count = mongoTemplate.count(query, search.getCollName());
  240.         if (count > 0L) {
  241.             if (StrUtil.isEmpty(search.getSort())) {
  242.                 // 默认根据时间排序
  243.                 search.setSort(MongoConstants.TIME_COLUMN);
  244.             }
  245.             // 分页：跳过前skip个文档，返回接下来的pageSize个文档
  246.             int skip = (search.getPageNum() - 1) * search.getPageSize();
  247.             query = query.with(Sort.by(search.getSort()).ascending()).skip(skip).limit(search.getPageSize());
  248.             list = mongoTemplate.find(query, JSONObject.class, search.getCollName());
  249.         }
  250.         TableDataInfo rspData = new TableDataInfo();
  251.         rspData.setCode(HttpStatus.SUCCESS);
  252.         rspData.setRows(list);
  253.         rspData.setMsg("查询成功");
  254.         rspData.setTotal(count);
  255.         return rspData;
  256.     }
  258.     /**
  259.      * 根据条件查询数据量
  260.      *
  261.      * @param search
  262.      * @return
  263.      */
  264.     public long getCount(SearchInput search) {
  265.         Query query = getQuery(search);
  266.         return mongoTemplate.count(query, search.getCollName());
  267.     }
  269.     /**
  270.      * 分页查询集合的数据
  271.      *
  272.      * @param search
  273.      * @return
  274.      */
  275.     public List<Document> getListDoc(SearchInput search) {
  276.         Query query = getQuery(search);
  277.         if (StrUtil.isNotEmpty(search.getSort())) {
  278.             query = query.with(Sort.by(search.getSort()).ascending());
  279.         }
  280.         int skip = (search.getPageNum() - 1) * search.getPageSize();
  281.         query = query.skip(skip).limit(search.getPageSize());
  282.         return mongoTemplate.find(query, Document.class , search.getCollName());
  283.     }
  285.     /**
  286.      * 随机查询一条数据
  287.      * @param collName
  288.      * @return
  289.      */
  290.     public JSONObject getOne(String collName){
  291.         Query query = new Query();
  292.         query = query.limit(1);
  293.         return mongoTemplate.findOne(query, JSONObject.class, collName);
  294.     }
  296.     public Query getQuery(SearchInput search) {
  297.         Criteria criteria = new Criteria();
  298.         List<Criteria> criteriaList = new ArrayList<>();
  299.         if (StrUtil.isNotEmpty(search.getBeginTime())) {
  300.             criteriaList.add(Criteria.where(MongoConstants.TIME_COLUMN).gte(Convert.toLong(search.getBeginTime())));
  301.         }
  302.         if (StrUtil.isNotEmpty(search.getEndTime())) {
  303.             criteriaList.add(Criteria.where(MongoConstants.TIME_COLUMN).lte(Convert.toLong(search.getEndTime())));
  304.         }
  305.         if (criteriaList.size() > 0) {
  306.             criteria.andOperator(criteriaList);
  307.         }
  308.         Query query = new Query(criteria);
  309.         if (StrUtil.isNotEmpty(search.getColumns())) {
  310.             query.fields().include(search.getColumns().split(","));
  311.         }
  312.         if(StrUtil.isNotEmpty(search.getExclude())){
  313.             query.fields().exclude(search.getExclude().split(","));
  314.         }
  315.         return query;
  316.     }
  318.     /**
  319.      * 根据条件复制一个新的集合数据
  320.      * @param search
  321.      */
  322.     // @Async("threadPoolTaskExecutor")
  323.     public void copyCollection(SearchCopy search) {
  324.         long startTime = System.currentTimeMillis();
  325.         log.info("开始把集合[{}]结果输出到另一个集合[{}]...", search.getCollName(), search.getNewId());
  326.         clearCollection(search.getNewId());
  327.         List<AggregationOperation> list = new ArrayList<>();
  328.         if(StrUtil.isNotEmpty(search.getColumns())){
  329.             list.add(Aggregation.project(search.getColumns().split(",")));
  330.         }
  331.         if(StrUtil.isNotEmpty(search.getBeginTime())){
  332.             list.add(Aggregation.match(new Criteria(MongoConstants.TIME_COLUMN).gte(Convert.toLong(search.getBeginTime()))));
  333.         }
  334.         if(StrUtil.isNotEmpty(search.getEndTime())){
  335.             list.add(Aggregation.match(new Criteria(MongoConstants.TIME_COLUMN).lte(Convert.toLong(search.getEndTime()))));
  336.         }
  337.         list.add(Aggregation.out(search.getNewId()));
  338.         Aggregation aggregation = Aggregation.newAggregation(list);
  339.         mongoTemplate.aggregateStream(aggregation, search.getCollName(), Document.class);
  340.         log.info("结果输出完成,耗时:{}秒", (System.currentTimeMillis() - startTime)/1000);
  341.     }
  342. }

MongoTemplate增强版

使用手册：https://loser.plus/

使用MyBatisPlus的方式，优雅的操作MongoDB。

这种方式是如同Mysql表结构一样，已知集合名称和字段名称，预先定义好字段类型，自动与Mongodb进行关系映射。

原文链接：https://www.cnblogs.com/zhaojinhui/p/18289404

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

MongoDB热门文章

  • MongoDB 数组查询（$elemMatch）、更新操作(占位符$)详解
  • MongoDB 聚合分组取第一条记录的案例及实现
  • 利用“海底捞算法”在MongoDB中优雅地存储一棵树
  • 瞧一瞧！这儿实现了MongoDB的增量备份与还原（含部署代码）
  • MongoDB 安装
  • MongoDB Python官方驱动 PyMongo 的简单封装
  • 记一次Mongodb数据库查询之包含所有指定元素的数组或者都在指定元素的数组中 - du-blog
  • Java将日期类型Date时间戳转换为MongoDB的时间类型数据
  • MongoDB动态建表方案（官方原生驱动）
  • MongoDB的模糊查询操作(类关系型数据库的 like 和 not like)

    • MongoDB推荐文章

  • SpringBoot集成Mongodb文档数据库
  • 用Python脚本迁移MongoDB数据到金仓-kingbase数据库 - 惟-koko
  • 使用Docker搭建MongoDB 5.0版本副本集集群
  • MongoDB 中的事务
  • 【最佳实践】高可用mongodb集群(1分片+3副本):规划及部署
  • 【最佳实践】MongoDB导出导入数据
  • MongoDB从入门到实战之.NET Core使用MongoDB开发ToDoList系统（8）-Ant Design Blazor前端框架搭建
  • 基于SqlSugar的开发框架循序渐进介绍（27）-- 基于MongoDB的数据库操作整合
  • .NET Core MongoDB数据仓储和工作单元模式实操
  • .NET Core MongoDB数据仓储和工作单元模式封装

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号