Spring boot整合mongodb

1.下载及说明

下载地址：Try MongoDB Atlas Products | MongoDB

下载之后在mongodb的文件夹中配置data文件用来存放数据。

传统的关系数据库一般由数据库（database）、表（table）、记录（record）三个层次概念组成，MongoDB是由数据库（database）、集合（collection）、文档对象（document）三个层次组成。MongoDB对于关系型数据库里的表，但是集合中没有列、行和关系概念，这体现了模式自由的特点。

2.启动

服务端启动

mongod --dbpath=../data/db

客户端启动

mongo --host=127.0.0.1 --port=27017

可以使用robo3t工具连接mongodb进行操作。

3.配置

spring:
  data:
    mongodb:
      uri: mongodb://localhost/it123

4.使用

package com.example.demo.mongo;

import com.example.demo.domain.Student;
import com.example.demo.domain.Student1;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.apache.poi.ss.formula.functions.T;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.ExecutableRemoveOperation;
import org.springframework.data.mongodb.core.ExecutableUpdateOperation;
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.Service;

import java.util.List;

/**
 * @Author linaibo
 * @Date 2023/2/16 12:48
 * @PackageName:com.example.demo.mongo
 * @ClassName: Mongo
 * @Version 1.0
 */
@Service
public class MongoService {
    @Autowired
    private MongoTemplate mongoTemplate;

    public void insert() {
        Student1 student = new Student1();
        student.setId(1);
        student.setStudentNo("001");
        student.setStudentName("小天");
        student.setSex("男");
        Student1 insert = mongoTemplate.insert(student);

    }

    public void save() {
        Student1 student = new Student1();
        student.setId(2);
        student.setStudentNo("002");
        student.setStudentName("小天2");
        student.setSex("男");
        Student1 insert = mongoTemplate.save(student);
    }

    public void select() {
        List<Student1> all = mongoTemplate.findAll(Student1.class);
        System.out.println(all);
        Student1 byId = mongoTemplate.findById(1, Student1.class);
        System.out.println(byId);
    }

    public void update() {
        Query query = new Query(Criteria.where("id").is(1));
        Update update1 = new Update();
        update1.set("studentNo", "999");
        UpdateResult upsert = mongoTemplate.upsert(query, update1, Student1.class);
        System.out.println(upsert);


    }

    public void remove() {
        Student1 student = new Student1();
        student.setId(2);
        student.setStudentNo("002");
        student.setStudentName("小天2");
        student.setSex("男");
        Query query = new Query(Criteria.where("id").is(student.getId()).and("studentNo").is(student.getStudentNo()));
        DeleteResult remove = mongoTemplate.remove(query, Student1.class);
        System.out.println(remove);
    }

}

注入MongoTemplate对象，通过此对象完成对文档的增删改查。

5.说明

(1)常用方法

查询Student文档的全部数据

mongoTemplate.findAll(Student.class)
查询Student文档id为id的数据

mongoTemplate.findById(id, Student.class)
根据query内的查询条件查询

mongoTemplate.find(query, Student.class);
修改

mongoTemplate.upsert(query, update, Student.class)
删除

mongoTemplate.remove(query, Student.class)
新增

mongoTemplate.insert(student)

mongoTemplate.save(student)

(2)Query对象的使用
1 创建一个query对象（用来封装所有条件对象)，再创建一个criteria对象（用来构建条件）

2 精准条件：criteria.and(“key”).is(“条件”)

3 模糊条件：criteria.and(“key”).regex(“条件”)

4 封装条件：query.addCriteria(criteria)

5 大于（创建新的criteria）：Criteria gt = Criteria.where(“key”).gt（“条件”）

6 小于（创建新的criteria）：Criteria lt = Criteria.where(“key”).lt（“条件”）

7 Query.addCriteria(new Criteria().andOperator(gt,lt));

8 一个query中只能有一个andOperator()。其参数也可以是Criteria数组。

9 排序：query.with（new Sort(Sort.Direction.ASC, "age"). and(newSort(Sort.Direction.DESC, "date")))

(3)update的说明

针对更新项目需要传入update对象来设置的项目及更新的值，通过update的set方法设置更新的项目和值。

6.优化

完成以上配置，我们springBoot集成MongoDB环境基本已经搭建好了。
但是在使用中会发现一个问题，假如要对数据库操作多个对象，那岂不是每一个对象Service都需要写一套增删查改的方法。

可以通过创建一个dao层的抽象类，封装一些常用的操作方法。每个具体对象的dao只需要继承这个抽象类即可。

public abstract class MongoDbDao<T> {
 
    protected Logger logger = LoggerFactory.getLogger(MongoDbDao.class);
 
    /**
     * 反射获取泛型类型
     *
     * @return
     */
    protected abstract Class<T> getEntityClass();
 
    @Autowired
    private MongoTemplate mongoTemplate;
 
    /***
     * 保存一个对象
     * @param t
     */
    public void save(T t) {
        logger.info("-------------->MongoDB save start");
        this.mongoTemplate.save(t);
    }
 
    /***
     * 根据id从几何中查询对象
     * @param id
     * @return
     */
    public T queryById(Integer id) {
        Query query = new Query(Criteria.where("_id").is(id));
        logger.info("-------------->MongoDB find start");
        return this.mongoTemplate.findOne(query, this.getEntityClass());
    }
 
    /**
     * 根据条件查询集合
     *
     * @param object
     * @return
     */
    public List<T> queryList(T object) {
        Query query = getQueryByObject(object);
        logger.info("-------------->MongoDB find start");
        return mongoTemplate.find(query, this.getEntityClass());
    }
 
    /**
     * 根据条件查询只返回一个文档
     *
     * @param object
     * @return
     */
    public T queryOne(T object) {
        Query query = getQueryByObject(object);
        logger.info("-------------->MongoDB find start");
        return mongoTemplate.findOne(query, this.getEntityClass());
    }
 
    /***
     * 根据条件分页查询
     * @param object
     * @param start 查询起始值
     * @param size  查询大小
     * @return
     */
    public List<T> getPage(T object, int start, int size) {
        Query query = getQueryByObject(object);
        query.skip(start);
        query.limit(size);
        logger.info("-------------->MongoDB queryPage start");
        return this.mongoTemplate.find(query, this.getEntityClass());
    }
 
    /***
     * 根据条件查询库中符合条件的记录数量
     * @param object
     * @return
     */
    public Long getCount(T object) {
        Query query = getQueryByObject(object);
        logger.info("-------------->MongoDB Count start");
        return this.mongoTemplate.count(query, this.getEntityClass());
    }
 
    /***
     * 删除对象
     * @param t
     * @return
     */
    public int delete(T t) {
        logger.info("-------------->MongoDB delete start");
        return (int) this.mongoTemplate.remove(t).getDeletedCount();
    }
 
    /**
     * 根据id删除
     *
     * @param id
     */
    public void deleteById(Integer id) {
        Criteria criteria = Criteria.where("_id").is(id);
        if (null != criteria) {
            Query query = new Query(criteria);
            T obj = this.mongoTemplate.findOne(query, this.getEntityClass());
            logger.info("-------------->MongoDB deleteById start");
            if (obj != null) {
                this.delete(obj);
            }
        }
    }
 
    /*MongoDB中更新操作分为三种
    * 1：updateFirst     修改第一条
    * 2：updateMulti     修改所有匹配的记录
    * 3：upsert  修改时如果不存在则进行添加操作
    * */
    /**
     * 修改匹配到的第一条记录
     * @param srcObj
     * @param targetObj
     */
    public void updateFirst(T srcObj, T targetObj){
        Query query = getQueryByObject(srcObj);
        Update update = getUpdateByObject(targetObj);
        logger.info("-------------->MongoDB updateFirst start");
        this.mongoTemplate.updateFirst(query,update,this.getEntityClass());
    }
 
    /***
     * 修改匹配到的所有记录
     * @param srcObj
     * @param targetObj
     */
    public void updateMulti(T srcObj, T targetObj){
        Query query = getQueryByObject(srcObj);
        Update update = getUpdateByObject(targetObj);
        logger.info("-------------->MongoDB updateFirst start");
        this.mongoTemplate.updateMulti(query,update,this.getEntityClass());
    }
 
    /***
     * 修改匹配到的记录，若不存在该记录则进行添加
     * @param srcObj
     * @param targetObj
     */
    public void updateInsert(T srcObj, T targetObj){
        Query query = getQueryByObject(srcObj);
        Update update = getUpdateByObject(targetObj);
        logger.info("-------------->MongoDB updateInsert start");
        this.mongoTemplate.upsert(query,update,this.getEntityClass());
    }
 
    /**
     * 将查询条件对象转换为query
     *
     * @param object
     * @return
     * @author Jason
     */
    private Query getQueryByObject(T object) {
        Query query = new Query();
        String[] fileds = getFiledName(object);
        Criteria criteria = new Criteria();
        for (int i = 0; i < fileds.length; i++) {
            String filedName = (String) fileds[i];
            Object filedValue = getFieldValueByName(filedName, object);
            if (filedValue != null) {
                criteria.and(filedName).is(filedValue);
            }
        }
        query.addCriteria(criteria);
        return query;
    }
 
    /**
     * 将查询条件对象转换为update
     *
     * @param object
     * @return
     * @author Jason
     */
    private Update getUpdateByObject(T object) {
        Update update = new Update();
        String[] fileds = getFiledName(object);
        for (int i = 0; i < fileds.length; i++) {
            String filedName = (String) fileds[i];
            Object filedValue =getFieldValueByName(filedName, object);
            if (filedValue != null) {
                update.set(filedName, filedValue);
            }
        }
        return update;
    }
 
    /***
     * 获取对象属性返回字符串数组
     * @param o
     * @return
     */
    private static String[] getFiledName(Object o) {
        Field[] fields = o.getClass().getDeclaredFields();
        String[] fieldNames = new String[fields.length];
 
        for (int i = 0; i < fields.length; ++i) {
            fieldNames[i] = fields[i].getName();
        }
 
        return fieldNames;
    }
 
    /***
     * 根据属性获取对象属性值
     * @param fieldName
     * @param o
     * @return
     */
    private static Object getFieldValueByName(String fieldName, Object o) {
        try {
            String e = fieldName.substring(0, 1).toUpperCase();
            String getter = "get" + e + fieldName.substring(1);
            Method method = o.getClass().getMethod(getter, new Class[0]);
            return method.invoke(o, new Object[0]);
        } catch (Exception var6) {
            return null;
        }
    }
}

我们将mongoDB常用的CURD操作封装为通用的父类，然后在不同的业务场景下继承该类，通过泛型和反射获取到正在操作的实体类。
比如我们可以将之前的Book实体类的CURD类进行改造
创建BookMongoDbDao类继承MongoDbDao

@Repository
public class BookMongoDbDao extends MongoDbDao<Book> {
    @Override
    protected Class<Book> getEntityClass() {
        return Book.class;
    }
}

之前可能需要在service层中直接使用mongoTemplate方法操作数据，现在可以直接在service层中注入dao层，dao层继承这个抽象类，然后直接使用抽象类中的方法，也可以扩展自己的方法。

@Service
public class BookMongoDbService {
    private static final Logger logger = LoggerFactory.getLogger(BookMongoDbService.class);
 
    //注入新的CURD操作类
    @Autowired
    private BookMongoDbDao bookMongoDbDao;
 
    /**
     * 保存对象
     *
     * @param book
     * @return
     */
    public String saveObj2(Book book) {
        book.setCreateTime(new Date());
        book.setUpdateTime(new Date()); 
        //调用bookMongoDbDao父类中的添加方法
        bookMongoDbDao.save(book);
        return "添加成功";
    }
}

参照链接：https://blog.csdn.net/loliDapao/article/details/124388834