mogotemplate 工具类 mongodb工具类

转载

mob6454cc70cb6b 2024-04-29 13:15:03

文章标签 mogotemplate 工具类 mongodb java 数据库 spring 文章分类 机器学习人工智能

文章目录

Mongodb简介
1.开发环境：
2.引入依赖
3.完整依赖
4.配置文件
5.工具类代码
6.控制类
7.请求调用
8.数据查看

Mongodb简介

百度百科抄的如下：

MongoDB是一个基于分布式文件存储的数据库。
由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。
MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。
它支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。
Mongo最大的特点是它支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。
特点：
高性能、易部署、易使用，存储数据非常方便。
主要功能特性有：
面向集合存储，易存储对象类型的数据。
模式自由。
支持动态查询。
支持完全索引，包含内部对象。
支持查询。
支持复制和故障恢复。
使用高效的二进制数据存储，包括大型对象（如视频等）。
自动处理碎片，以支持云计算层次的扩展性。
支持 Golang，RUBY，PYTHON，JAVA，C++，PHP，C#等多种语言。
文件存储格式为BSON（一种JSON的扩展）。
可通过网络访问。

1.开发环境：

JDK版本：1.8
maven版本：3.9.0
mongodb客户端：Robo 3T - 1.3
开发工具：IDEA社区版ideaIC-2018.3

2.引入依赖

所需依赖

<!--web-->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!--<version>3.0.1</version>-->
            <version>2.7.3</version>
        </dependency>

        <!--mongodb-->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-mongodb -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
            <version>2.7.3</version>
        </dependency>
        
        <!--data注解自动配置getset方法-->
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.26</version>
            <scope>provided</scope>
        </dependency>

        <!--json对象-->
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.26</version>
        </dependency>

3.完整依赖

完整pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.mongodb</groupId>
    <artifactId>mongodb_ctl</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--注：：：：：由于构建spring boot的maven与jdk环境版本不兼容，这里用最新的maven版本与jdk1.8，项目构建报错，spring boot 3.0.0搭配的jdk最低为17
        这里环境是jdk1.8，maven建议使用低一点的版本，用spring boot 2.7.3，可以正常跑项目-->

        <!--spring boot-->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot -->
<!--        <dependency>-->
<!--            <groupId>org.springframework.boot</groupId>-->
<!--            <artifactId>spring-boot</artifactId>-->
<!--            <!–<version>3.0.1</version>–>-->
<!--            <version>2.7.3</version>-->
<!--        </dependency>-->

        <!--启动类 这个启动类正常都会包含在其他spring boot依赖中，所以可以不用，如spring-boot-starter-web也包含了这个starter依赖-->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter -->
<!--        <dependency>-->
<!--            <groupId>org.springframework.boot</groupId>-->
<!--            <artifactId>spring-boot-starter</artifactId>-->
<!--            <!–<version>3.0.1</version>–>-->
<!--            <version>2.7.3</version>-->
<!--        </dependency>-->

        <!--web-->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!--<version>3.0.1</version>-->
            <version>2.7.3</version>
        </dependency>

        <!--测试类注解-->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-test -->
<!--        <dependency>-->
<!--            <groupId>org.springframework.boot</groupId>-->
<!--            <artifactId>spring-boot-starter-test</artifactId>-->
<!--            <!–<version>3.0.1</version>–>-->
<!--            <version>2.7.3</version>-->
<!--            <scope>test</scope>-->
<!--        </dependency>-->

        <!--mongodb-->
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-mongodb -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
            <version>2.7.3</version>
        </dependency>

        <!--mongodb-->
        <!--<dependency>-->
        <!--    <groupId>org.mongodb</groupId>-->
        <!--    <artifactId>mongodb-driver-sync</artifactId>-->
        <!--    <version>3.9.1</version>-->
        <!--</dependency>-->

        <!--data注解自动配置getset方法-->
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.26</version>
            <scope>provided</scope>
        </dependency>

        <!--json对象-->
        <!-- https://mvnrepository.com/artifact/com.alibaba.fastjson2/fastjson2 -->
<!--        <dependency>-->
<!--            <groupId>com.alibaba.fastjson2</groupId>-->
<!--            <artifactId>fastjson2</artifactId>-->
<!--            <version>2.0.25</version>-->
<!--        </dependency>-->

        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.26</version>
        </dependency>
    </dependencies>

</project>

4.配置文件

application.yml

spring:
  profiles:
    active: dev

application-dev.yml

server:
  port: 8090

spring:
  #mysql配置
#  datasource:
#    url: ssss
#    username: sdsdsdsd
#    password: dkdkdkdkd
#    driver_class_name: com.mysql.cj.jdbc.Driver

  data:
    mongodb:
      #-1-无账号密码登录
#      uri: mongodb://174.33.44.99:27017

      #-2-有账号密码登录
#      uri: mongodb://username:password@hostaddress/database?authSource=admin #最后一个参数是开启用户验证
#      uri: mongodb://uuuu:ppppp@uaes@174.33.44.99:27017/demo_test

      #-3-标准分开参数配置
      #指定mongodb服务器地址
      host: 174.33.44.99
      #指定端口号，默认27017
      port: 27017
      #指定使用的数据库
      database: demo_test
      #登录认证的唯一库名，这个库名拥有所有数据库的全选
      authentication-database: admin
      #用户名
      username: root
      #密码
      password: root

5.工具类代码

MongodbEasyUtil.java

package com.mongodb.utils;

import com.alibaba.fastjson.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
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.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.List;
import java.util.Map;

/**
 * @ClassDescription: mongodb工具简单实现
 * @Author：李白
 * @Date：2023/3/23 16:48
 */
@Component
public class MongodbEasyUtil {

    /**    需要注意的点：：：：
     * 0-新增数据的类型可以是任何类型，且内部数据结构可随机，没有固定的格式（比较灵活）
     * 1-新增更新等操作时，如参数中没有集合名称，则会默认将传入的对象名称作为集合名称
     * 2-新增和查询的操作都与对象类型有关，新增什么类型的数据就根据什么类型来查询
     * 3-更新和删除操作与对象类型无关，操作时可以不考虑数据是什么类型
     * 4-由于此处自动注入mongoTemplate对象会报空指针异常，所以这里所有函数都以参数来传递mongoTemplate，在controller请求类中调用时创建对象传入
     * 5-这里的两个注解(@Autowired和@PostConstruct)的使用需要依托与spring boot，才能按正常的初始化顺序调用，
     * 如果是单纯用一个main方法来测试这个工具类会报错，因为main在调用这个类时内部对象的初始化和注入顺序缺失导致被调用的对象报空指针异常
     */
    @Autowired
    private MongoTemplate mongoTemplate;

    private static MongoTemplate mot;

    @PostConstruct
    public void initMongodbTemplate(){
        mot = mongoTemplate;
    }

    //-----------------------------------查询数据（与对象类型有关的操作，这里以JSONObject类型为存储对象）------------------------------------------

    /**
     * 根据数据id字段的值获取数据
     * @param objectIdValue 数据id的值
     * @return
     */
    public static JSONObject getJsonObjInfoById(String objectIdValue){
        JSONObject jsonObjectId = mot.findById(objectIdValue, JSONObject.class);
        return jsonObjectId;
    }

    /**
     * 根据数据id值获取数据(指定集合)
     * @param objectIdValue 数据id的值
     * @return
     */
    public static JSONObject getJsonObjInfoById(String objectIdValue, String collectionName,MongoTemplate mongoTemplate){
        JSONObject jsonObjectId = mongoTemplate.findById(objectIdValue, JSONObject.class,collectionName);
        return jsonObjectId;
    }

    /**
     * 根据条件查询数据（单条件查询）
     * @param queryConditionField 查询条件的字段
     * @param queryConditionFieldValue 查询条件的值
     * @return
     */
    public static JSONObject getJsonObjInfoByCondition(String queryConditionField,String queryConditionFieldValue){
        Query query = Query.query(Criteria.where(queryConditionField).is(queryConditionFieldValue));
        List infoList = mot.find(query, JSONObject.class);
        return JSONObject.parseObject(infoList.toString());
    }

    /**
     * 根据条件查询数据（单条件查询）
     * @param queryConditionField 查询条件的字段
     * @param queryConditionFieldValue 查询条件的值
     * @param collectionName 集合名称
     * @return
     */
    public static JSONObject getJsonObjInfoByCondition(String queryConditionField,String queryConditionFieldValue, String collectionName){
        Query query = Query.query(Criteria.where(queryConditionField).is(queryConditionFieldValue));
        List infoList = mot.find(query, JSONObject.class,collectionName);
        return JSONObject.parseObject(infoList.toString());
    }

    /**
     * 根据条件查询数据（单条件多值查询）
     * @param queryConditionField 查询条件的字段
     * @param queryConditionFieldValues 查询条件的值
     * @return
     */
    public static JSONObject getJsonObjInfoByConditions(String queryConditionField,String... queryConditionFieldValues){
        Query query = Query.query(Criteria.where(queryConditionField).in(queryConditionFieldValues));
        List infoList = mot.find(query, JSONObject.class);
        return JSONObject.parseObject(infoList.toString());
    }

    /**
     * 根据条件查询数据（单条件多值查询）
     * @param queryConditionField 查询条件的字段
     * @param queryConditionFieldValues 查询条件的值
     * @param collectionName 集合名称
     * @return
     */
    public static JSONObject getJsonObjInfoByConditions(String queryConditionField, String collectionName,String... queryConditionFieldValues){
        Query query = Query.query(Criteria.where(queryConditionField).in(queryConditionFieldValues));
        List infoList = mot.find(query, JSONObject.class,collectionName);
        return JSONObject.parseObject(infoList.toString());
    }

    /**
     * 查询全部数据（不指定集合）
     * @return
     */
    public static JSONObject getJsonObjInfoAll(){
        List infoList = mot.findAll(JSONObject.class);
        return JSONObject.parseObject(infoList.toString());
    }

    /**
     * 查询全部数据（指定集合内）
     * @return
     */
    public static JSONObject getJsonObjInfoAll(String collectionName){
        List infoList = mot.findAll(JSONObject.class,collectionName);
        return JSONObject.parseObject(infoList.toString());
    }

    /**
     * 条件检索-分页查询（与对象类型无关的操作）
     * @param collectionName 集合名称
     * @return 分页查询的结果
     */
    public static JSONObject queryInfoPage(int pageSize, String collectionName){
        JSONObject jsonObject = new JSONObject();
        Query query = new Query();
        Criteria criteria = new Criteria();
        query.addCriteria(criteria);
        long count = mot.count(query, collectionName);
        System.out.println(count);
//            long count = mongoTemplate.count(new Query().addCriteria(new Criteria()),collectionName);
//            int pageSize = 2;
        long num = count%pageSize==0 ? count/pageSize : count/pageSize +1;
        int pageNum = 1;
        while(pageNum<=num){
            query.skip((pageNum-1)*pageSize);
            query.limit(pageSize);
            pageNum++;
            List<Map> dataMap = mot.find(query, Map.class, collectionName);
            System.out.println(dataMap);
            System.out.println("---------->");
            JSONObject jsonObject2 = new JSONObject();
            int nuPa = 1;
            for (Map<String,Object> data: dataMap) {
                System.out.println(data);
                jsonObject2.put("data"+nuPa,data);
//                    data.forEach((key, value)->{
//                    System.out.println(key);
//                    System.out.println(value);
//                    });
                nuPa++;
            }
            jsonObject.put("Page"+(pageNum-1),jsonObject2);
//                for (Map<String, Object> da : data){
            //数据处理
//                }
        }

        return jsonObject;
    }

    //-----------------------------------存储数据（对象类型为JSONObject的操作）------------------------------------------

    /**
     * 存文档(没有集合名称默认以数据对象类型为集合名，这里时以JSONObject为集合名)
     * @param document 文档信息
     */
    public static void saveJsonObjInfo(JSONObject document){
        mot.save(document);
    }

    /**
     * 存文档
     * @param document 文档信息
     * @param collectionName 集合名称
     */
    public static void saveJsonObjInfo(JSONObject document, String collectionName){
        mot.save(document, collectionName);
    }

    //insert和save的区别:
    // insert
    // 新增数据的主键已存在时，进行插入数据会报错主键重复（duplicateKeyException）不保存当前数据，插入失败
    // 批量插入时可一次性插入整个列表，无需遍历，效率较高
    // save
    // 新增数据的主键已存在时，进行插入数据会对当前已存在的数据进行修改，可以插入成功
    // 批量插入时需要遍历，一个一个插入，效率较低

    /**
     * 存文档(没有集合名称默认以数据对象类型为集合名，这里时以JSONObject为集合名)
     * @param document 文档信息
     */
    public static void insertJsonObjInfo(JSONObject document){
        mot.insert(document);
    }

    /**
     * 存文档
     * @param document 文档信息
     * @param collectionName 集合名称
     */
    public static void insertJsonObjInfo(JSONObject document, String collectionName){
        mot.insert(document, collectionName);
    }


    //-----------------------------------更新数据（与对象类型无关的操作）------------------------------------------

    /**
     * 数据更新-根据id和字段的值更新第一条数据到指定集合中(更新一条数据中的某个字段信息)
     * @param objectIdValue 数据id的值
     * @param field 字段名称
     * @param fieldValue 字段值
     * @param collectionName 集合名称
     */
    public static void updateOne(String objectIdValue, String field, String fieldValue, String collectionName){
        Query query = Query.query(Criteria.where("_id").is(objectIdValue));
        Update update = Update.update(field,fieldValue);
        mot.updateFirst(query, update, collectionName);
    }

    /**
     * 数据更新-根据条件更改符合条件的每条数据对应的字段 指定集合
     * @param queryConditionField 查询条件的值
     * @param queryConditionFieldValue 查询条件的值
     * @param field 字段名称
     * @param fieldValue 字段值
     * @param collectionName 集合名称
     */
    public static void updateMulti(String queryConditionField, String queryConditionFieldValue,String field, String fieldValue, String collectionName){
        Query query = Query.query(Criteria.where(queryConditionField).is(queryConditionFieldValue));
        Update update = Update.update(field,fieldValue);
        mot.updateMulti(query, update, collectionName);
    }

    /**
     * 数据更新-更新一条数据，数据对应字段更改 指定集合中-如果是数据不存在则新增数据
     * @param queryConditionField 查询条件的值
     * @param queryConditionFieldValue 查询条件的值
     * @param field 字段名称
     * @param fieldValue 字段值
     * @param collectionName 集合名称
     */
    public static void updateUpsert(String queryConditionField, String queryConditionFieldValue, String field, String fieldValue, String collectionName){
        Query query = Query.query(Criteria.where(queryConditionField).is(queryConditionFieldValue));
        Update update = Update.update(field,fieldValue);
        mot.upsert(query, update, collectionName);
    }

    //-----------------------------------删除数据(与对象类型无关的操作)------------------------------------------
    /**
     * 根据数据id删除数据（指定集合）
     * @param objectIdValue 数据id对应的值
     */
    public static void deleteInfoById(String objectIdValue, String collectionName){
        Query query = Query.query(Criteria.where("_id").is(objectIdValue));
        mot.remove(query,collectionName);
    }

    /**
     * 数据删除-根据指定字段对应的值删除数据   指定集合
     * @param queryConditionField 条件字段
     * @param collectionName 集合名称
     * @param queryConditionFieldValue 条件字段值
     */
    public static void deleteInfoByCondition(String queryConditionField, String collectionName, String queryConditionFieldValue){
        Query query = Query.query(Criteria.where(queryConditionField).is(queryConditionFieldValue));
        mot.remove(query, collectionName);
    }

    /**
     * 数据删除-根据指定字段对应的值删除数据   指定集合
     * @param queryConditionField 条件字段
     * @param collectionName 集合名称
     * @param queryConditionFieldValues 条件字段值(可以为多个)
     */
    public static void deleteInfoByConditions(String queryConditionField, String collectionName, String... queryConditionFieldValues){
        Query query = Query.query(Criteria.where(queryConditionField).in(queryConditionFieldValues));
        mot.remove(query, collectionName);
    }
}

注1：这里工具类中使用了两个注解，@Autowired和@PostConstruct，在调用工具类时，调用的工具类使用了MongodbTemplate对象，调用的时候会报空指针异常，这是因为对象未被初始化就被调用，要想解决这个问题就要在对象注入之后初始化一下，这样对象就不会为空了，以上的@PostConstruct注解就是为了解决这个问题，它可以在对象自动注入后执行一次初始化操作，且只会执行一次。

注2：在使用其他工具类中也可以使用@PostConstruct注解解决相同的问题，如redis工具类，restTemplate工具类等。

6.控制类

MongodbEasyController.java

package com.mongodb.controller;

import com.alibaba.fastjson.JSONObject;
import com.mongodb.utils.MongodbEasyUtil;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

/**
 * @ClassDescription: 测试
 * @Author：李白
 * @Date：2023/3/23 13:24
 */
@RestController
@EnableAutoConfiguration
@RequestMapping("mongodb")
public class MongodbEasyController {
    
    @RequestMapping(value = "save", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
    public JSONObject saveData(){
        JSONObject document = new JSONObject();
        document.put("li",12315);
        MongodbEasyUtil.saveJsonObjInfo(document,"datang");
        return document;
    }
}