SpringBoot 整合 MongoDB

baihb1024

已于 2025-03-08 13:21:51 修改

阅读量2k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： SpringBoot 文章标签： mongodb spring boot 数据库

于 2023-06-29 08:53:26 首次发布

本文链接：https://blog.csdn.net/baihaibo1024/article/details/131402602

SpringBoot 专栏收录该内容

21 篇文章

订阅专栏

本文介绍如何在SpringBoot项目中整合MongoDB，并提供详细的代码示例，包括依赖配置、分页工具类、MongoDB API接口及其实现，最后通过一个测试类展示具体操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、整合 MongoDB

项目目录

在这里插入图片描述

1. pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.7.0</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
    <version>2.7.0</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</dependency>

2. application.yml

spring:
  data:
    mongodb:
      database: demo
      host: 127.0.0.1
      port: 27017
      username: root
      password: 123456
      maxPoolSize: 100
      minPoolSize: 10
      maxConnectionIdleTime: 60000

3. 创建分页工具类

PageHelper

package com.cnbai.utils;

import lombok.Data;

import java.io.Serializable;
import java.util.List;

/**
 * 分页工具类
 */
@Data
public class PageHelper<T> implements Serializable {
    
    // 当前页数
    private long currentPage;
    // 总记录数
    private long total;
    // 页大小
    private long pageSize;
    // 总页数
    private int totalPage;
    // 数据列表
    private List<T> list;
    
    public PageHelper(long pageNum, long pageSize, long total, List<T> list) {
        this.currentPage = pageNum;
        this.pageSize = pageSize;
        this.total = total;
        this.list = list;
        this.totalPage = (int) Math.ceil((double) total / pageSize);
    }
    
    public PageHelper(long pageNum, long pageSize, List<T> list) {
        this.currentPage = pageNum;
        this.pageSize = pageSize;
        this.list = list;
    }
}

MongoPage

package com.cnbai.utils;

import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * MongoDB 分页工具类
 */
@Component
public class MongoPage<T> {

    private Integer pageSize;
    private Integer currentPage;

    public void initPage(Integer currentPage, Integer pageSize, Query query) {
        pageSize = pageSize == 0 ? 20 : pageSize;
        query.limit(pageSize);
        query.skip((currentPage - 1) * pageSize);
        this.pageSize = pageSize;
        this.currentPage = currentPage;
    }

    public PageHelper<T> pageHelper(long total, List<T> list) {
        return new PageHelper<>(this.currentPage, total, this.pageSize, list);
    }

    public PageHelper<T> pageHelper(List<T> list) {
        return new PageHelper<>(this.currentPage, this.pageSize, list);
    }

    public PageHelper<T> pageHelper(long currentPage, long total, long pageSize, List<T> list) {
        return new PageHelper<>(currentPage, total, pageSize, list);
    }

    public PageHelper<T> pageHelper(long currentPage, long pageSize, List<T> list) {
        return new PageHelper<>(currentPage, pageSize, list);
    }
}

4. 创建 MongoDB API

MongoDBDao

package com.cnbai.dao;

import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Update;

import java.util.List;
import java.util.Map;

/**
 * MongoDB API
 */
public interface MongoDBDao {

    /**
     * 创建集合
     *
     * @param collectionName 集合名
     */
    boolean createCollection(String collectionName);

    /**
     * 删除集合
     *
     * @param collectionName 集合名
     */
    boolean dropCollection(String collectionName);

    /**
     * 插入一条记录，如已存在则抛出异常
     *
     * @param o 记录
     * @param collectionName 集合名
     */
    boolean insert(Object o, String collectionName);

    /**
     * 插入一条记录，如已存在则抛出异常
     *
     * @param o 记录
     */
    boolean insert(Object o);
    
    /**
     * 插入多条记录，如已存在则抛出异常
     *
     * @param o 记录
     * @param collectionName 集合名
     */
    boolean insertAll(List o, String collectionName);

    /**
     * 插入多条记录，如已存在则抛出异常
     *
     * @param o 记录
     * @param c 插入的类型
     */
    boolean insertAll(List o, Class c);

    /**
     * 插入一条记录，如已存在则更新
     *
     * @param o 记录
     * @param collectionName 集合名
     */
    void save(Object o, String collectionName);

    /**
     * 查询集合中全部记录
     *
     * @param c 返回的类型
     * @param collectionName 集合名
     */
    Object findAll(Class c, String collectionName);

    /**
     * 根据 id 查询
     *
     * @param id 记录 id
     * @param c 返回的类型
     */
    Object findById(String id, Class c);

    /**
     * 根据 ids 查询
     *
     * @param idName 主键字段名
     * @param ids id 集合
     * @param c 返回的类型
     */
    Object findByIds(String idName, List<String> ids, Class c);

    /**
     * 根据条件查询一条记录
     *
     * @param criteria 条件拼接，如：Criteria.where("name").is("bai")
     * @param c 返回的类型
     * @param collectionName 集合名
     */
    Object findOne(Criteria criteria, Class c, String collectionName);

    /**
     * 根据条件查询记录列表
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param sorts 需要排序的字段集合
     */
    Object findByCondition(Criteria criteria, Class c, List<Sort> sorts);

    /**
     * 根据条件查询记录列表
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param collectionName 集合名
     */
    Object findByCondition(Criteria criteria, Class c, String collectionName);

    /**
     * 根据条件查询记录列表
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param collectionName 集合名
     * @param limit 数量
     */
    Object findByCondition(Criteria criteria, Class c, int limit, String collectionName);

    /**
     * 根据条件查询记录列表
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param collectionName 集合名
     * @param limit 数量
     * @param sort 排序
     */
    Object findByCondition(Criteria criteria, Class c, int limit, Sort sort, String collectionName);

    /**
     * 根据条件查询记录列表
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param pageNum 当前页
     * @param pageSize 页大小
     * @param sorts 需要排序的字段集合
     */
    Object findByCondition(Criteria criteria, Class c, Integer pageNum, Integer pageSize, List<Sort> sorts);

    /**
     * 根据条件查询记录列表
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param collectionName 集合名
     * @param pageNum 当前页
     * @param pageSize 页大小
     * @param sorts 需要排序的字段集合
     */
    Object findByCondition(Criteria criteria, Class c, String collectionName, Integer pageNum, Integer pageSize, List<Sort> sorts);

    /**
     * 分组查询
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param fields 需要分组的字段
     * @param collectionName 集合名
     * @param pageNum 当前页数
     * @param pageSize 页大小
     */
    Object group(Criteria criteria, Class c, String[] fields, String collectionName, long pageNum, long pageSize);

    /**
     * 分组查询
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param fields 需要分组的字段
     * @param collectionName 集合名
     */
    Object group(Criteria criteria, Class c, String[] fields, String collectionName);

    /**
     * 返回指定字段
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     * @param collectionName 集合名
     */
    Object findPropertyByCondition(Criteria criteria, Class c, String collectionName, String[] includes);

    /**
     * 返回满足条件的文档数量
     *
     * @param criteria 条件拼接
     * @param collectionName 集合名
     */
    long count(Criteria criteria, String collectionName);

    /**
     * 返回满足条件的文档数量
     *
     * @param criteria 条件拼接
     * @param c 返回的类型
     */
    long count(Criteria criteria, Class c);

    /**
     * 更新满足条件的第一条文档
     *
     * @param criteria 条件拼接
     * @param update new Update().set("age",20).set("name","bai");
     * @param collectionName 集合名
     */
    Object updateOne(Criteria criteria, Update update, String collectionName);

    /**
     * 更新满足条件的第一条文档
     *
     * @param criteria 条件拼接
     * @param update new Update().set("age",20).set("name","bai");
     * @param c 修改的类型
     */
    Object updateOne(Criteria criteria, Update update, Class c);

    /**
     * 更新所有满足条件的文档
     *
     * @param criteria 条件拼接
     * @param update new Update().set("age",20).set("name","bai");
     * @param collectionName 集合名
     */
    Object updateMany(Criteria criteria, Update update, String collectionName);

    /**
     * 更新所有满足条件的文档
     *
     * @param criteria 条件拼接
     * @param update new Update().set("age",20).set("name","bai");
     * @param c 修改的类型
     */
    Object updateMany(Criteria criteria, Update update, Class c);

    /**
     * 删除满足条件的信息
     *
     * @param criteria 条件拼接
     * @param collectionName 集合名
     */
    Object delete(Criteria criteria, String collectionName);

    /**
     * 删除满足条件的信息
     *
     * @param criteria 条件拼接
     * @param c 删除的类型
     */
    Object delete(Criteria criteria, Class c);

    /**
     * 获取拼接条件
     *
     * @param map 查询参数
     */
    Criteria getCriteria(Map<String, Object> map);

    /**
     * 获取拼接条件
     *
     * @param map 查询参数
     * @param skipFields 过滤掉的字段
     */
    Criteria getCriteria(Map<String, Object> map, List<String> skipFields);

    /**
     * 获取拼接条件
     *
     * @param map 查询参数
     * @param skipFields 过滤掉的字段
     * @param likeFields 模糊查询的字段
     */
    Criteria getCriteria(Map<String, Object> map, List<String> skipFields, List<String> likeFields);

    /**
     * 获取拼接条件
     *
     * @param map 查询字段
     * @param skipFields 过滤掉的字段
     * @param likeFields 模糊查询的字段
     * @param inFields 使用 in 的查询字段
     */
    Criteria getCriteria(Map<String, Object> map, List<String> skipFields, List<String> likeFields, List<String> inFields);
}

MongoDBDaoImpl

package com.cnbai.dao;

import com.mongodb.client.MongoClient;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoClientDatabaseFactory;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
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.Repository;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * MongoDB 处理类
 */
@Repository
public class MongoDBDaoImpl implements MongoDBDao {

    @Resource
    private MongoTemplate mongoTemplate;

    @Resource
    private MongoPage mongoPage;
    
    @Resource
    private MongoClient mongoClient;

    @Override
    public boolean createCollection(String collectionName) {
        if (mongoTemplate.collectionExists(collectionName)) {
            return true;
        }
        mongoTemplate.createCollection(collectionName);
        return mongoTemplate.collectionExists(collectionName);
    }

    @Override
    public boolean dropCollection(String collectionName) {
        if (!mongoTemplate.collectionExists(collectionName)) {
            return true;
        }
        mongoTemplate.getCollection(collectionName).drop();
        return !mongoTemplate.collectionExists(collectionName);
    }

    @Override
    public boolean insert(Object o, String collectionName) {
        try {
            mongoTemplate.insert(o, collectionName);
            return true;
        } catch (Exception e) {
        	e.printStackTrace();
            return false;
        }
    }

    @Override
    public boolean insert(Object o) {
        try {
            mongoTemplate.insert(o);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    @Override
    public boolean insertAll(List o, String collectionName) {
        try {
            mongoTemplate.insert(o, collectionName);
            return true;
        } catch (Exception e) {
        	e.printStackTrace();
            return false;
        }
    }

    @Override
    public boolean insertAll(List o, Class c) {
        try {
            mongoTemplate.insert(o, c);
            return true;
        } catch (Exception e) {
        	e.printStackTrace();
            return false;
        }
    }

    @Override
    public void save(Object o, String collectionName) {
        mongoTemplate.save(o, collectionName);
    }

    @Override
    public Object findAll(Class c, String collectionName) {
        return mongoTemplate.findAll(c, collectionName);
    }

    @Override
    public Object findById(String id, Class c) {
        return mongoTemplate.findById(id, c);
    }

    @Override
    public Object findByIds(String idName, List<String> ids, Class c) {
        Criteria in = Criteria.where(idName).in(ids);
        Query query = new Query(in);
        return mongoTemplate.find(query, c);
    }

    @Override
    public Object findOne(Criteria criteria, Class c, String collectionName) {
        Query query = new Query(criteria);
        return mongoTemplate.findOne(query, c, collectionName);
    }

    @Override
    public Object findByCondition(Criteria criteria, Class c, List<Sort> sorts) {
        Query query = new Query(criteria);
        if (sorts != null && sorts.size() > 0) {
            for (Sort sort : sorts) {
                query = query.with(sort);
            }
        }
        return mongoTemplate.find(query, c);
    }

    @Override
    public Object findByCondition(Criteria criteria, Class c, String collectionName) {
        return findByCondition(criteria, c, 0, collectionName);
    }

    @Override
    public Object findByCondition(Criteria criteria, Class c, int limit, String collectionName) {
        return findByCondition(criteria, c, limit, null, collectionName);
    }

    @Override
    public Object findByCondition(Criteria criteria, Class c, int limit, Sort sort, String collectionName) {
        Query query = new Query(criteria);
        if (sort != null) {
            query = query.with(sort);
        }
        if (limit > 0) {
            query.limit(limit);
        }
        return mongoTemplate.find(query, c, collectionName);
    }

    @Override
    public Object findByCondition(Criteria criteria, Class c, Integer pageNum, Integer pageSize, List<Sort> sorts) {
        return findByCondition(criteria, c, null, pageNum, pageSize, sorts);
    }

    @Override
    public Object findByCondition(Criteria criteria, Class c, String collectionName, Integer pageNum, Integer pageSize, List<Sort> sorts) {
        Query query = new Query(criteria);
        if (sorts != null && sorts.size() > 0) {
            for (Sort sort : sorts) {
                query = query.with(sort);
            }
        }

        long count = 0;
        if (StringUtils.hasText(collectionName)) {
            count = mongoTemplate.count(query, c);
        } else {
            count = mongoTemplate.count(query, collectionName);
        }

        mongoPage.initPage(pageNum, pageSize, query);
        List list = new ArrayList<>();
        if (StringUtils.hasText(collectionName)) {
            list = mongoTemplate.find(query, c);
        } else {
            list = mongoTemplate.find(query, c, collectionName);
        }
        return mongoPage.pageHelper(count, list);
    }

    @Override
    public long count(Criteria criteria, String collectionName) {
        Query query = new Query(criteria);
        return mongoTemplate.count(query, collectionName);
    }

    @Override
    public Object updateOne(Criteria criteria, Update update, String collectionName) {
        Query query = new Query(criteria);
        return mongoTemplate.updateFirst(query, update, collectionName);
    }

    @Override
    public Object updateMany(Criteria criteria, Update update, String collectionName) {
        Query query = new Query(criteria);
        return mongoTemplate.updateMulti(query, update, collectionName);
    }

    @Override
    public Object delete(Criteria criteria, String collectionName) {
        Query query = new Query(criteria);
        return mongoTemplate.remove(query, collectionName);
    }

    @Override
    public long count(Criteria criteria, Class c) {
        Query query = new Query(criteria);
        return mongoTemplate.count(query, c);
    }

    @Override
    public Object updateOne(Criteria criteria, Update update, Class c) {
        Query query = new Query(criteria);
        return mongoTemplate.updateFirst(query, update, c);
    }

    @Override
    public Object updateMany(Criteria criteria, Update update, Class c) {
        Query query = new Query(criteria);
        return mongoTemplate.updateMulti(query, update, c);
    }

    @Override
    public Object delete(Criteria criteria, Class c) {
        Query query = new Query(criteria);
        return mongoTemplate.remove(query, c);
    }

    @Override
    public Object group(Criteria criteria, Class c, String[] fields, String collectionName, long currentPage, long pageSize) {
        pageSize = pageSize == 0 ? 20 : pageSize;
        currentPage = currentPage == 0 ? 1 : currentPage;

        Aggregation aggregation = Aggregation.newAggregation(Aggregation.match(criteria),
                Aggregation.group(fields).count().as("sum"),
                Aggregation.sort(Sort.by(Sort.Direction.DESC, "sum")),
                Aggregation.skip((currentPage - 1) * pageSize),
                Aggregation.limit(pageSize));

        AggregationResults aggregate = mongoTemplate.aggregate(aggregation, collectionName, c);
        return mongoPage.pageHelper(currentPage, pageSize, aggregate.getMappedResults());
    }

    @Override
    public Object group(Criteria criteria, Class c, String[] fields, String collectionName) {
        Aggregation aggregation = Aggregation.newAggregation(Aggregation.match(criteria),
                Aggregation.group(fields).count().as("sum"),
                Aggregation.sort(Sort.by(Sort.Direction.DESC, "sum")));

        AggregationResults aggregate = mongoTemplate.aggregate(aggregation, collectionName, c);
        return aggregate.getMappedResults();
    }

    @Override
    public Object findPropertyByCondition(Criteria criteria, Class c, String collectionName, String[] includes) {
        Query query = new Query(criteria);
        query.fields().exclude("_id");
        if (!StringUtils.hasText(Arrays.toString(includes))) {
            for (String result : includes) {
                query.fields().include(result);
            }
        }
        return mongoTemplate.find(query, c, collectionName);
    }

    @Override
    public Criteria getCriteria(Map<String, Object> map) {
        return getCriteria(map, null, null, null);
    }

    @Override
    public Criteria getCriteria(Map<String, Object> map, List<String> skipFields) {
        return getCriteria(map, skipFields, null, null);
    }

    @Override
    public Criteria getCriteria(Map<String, Object> map, List<String> skipFields, List<String> likeFields) {
        return getCriteria(map, skipFields, likeFields, null);
    }

    @Override
    public Criteria getCriteria(Map<String, Object> map, List<String> skipFields, List<String> likeFields, List<String> inFields) {
        Criteria criteria = Criteria.where("1").is(1);
        for (String key : map.keySet()) {

            // 过滤掉的字段
            if (skipFields != null && skipFields.contains(key)) {
                continue;
            }

            // 模糊查询的字段
            if (likeFields != null && likeFields.contains(key)) {
                criteria.and(key).regex(".*" + map.get(key) + ".*");
                continue;
            }

            // 使用 in 的查询字段
            if (inFields != null && inFields.contains(key)) {
                criteria.and(key).in(map.get(key));
                continue;
            }

            // TODO: 日期范围查询模板
            if ("startTime".equals(key)) {
                criteria.andOperator(Criteria.where("createTime").gte(formatTime((LocalDateTime) map.get("startTime"))),
                        Criteria.where("createTime").lte(formatTime((LocalDateTime) map.get("endTime"))));
                continue;
            }

            // 其他正常查询字段
            criteria.and(key).is(map.get(key));
        }
        return criteria;
    }

    /**
     * 格式化时间
     */
    private String formatTime(LocalDateTime time) {
        return time.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }
}

5. 创建实体类

package com.cnbai.domain;

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

import java.util.Date;

/**
 * Comment 实体类
 * 如果实体类的字段名称与 MongoDB 文档中的字段名称相同，那么不需要使用 @Field 注解
 */
@Data
@Document(collection = "user")
public class User {

    @Id
    private String id;

    private String name;

    @Field("create_time")
    private Date createTime;
}

6. 创建测试类

package com.cnbai.service;

import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import com.cnbai.domain.User;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Update;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 测试类
 */
public class MongoService {

    @Resource
    private MongoDBDao mongoDBDao;

    /**
     * 查询列表
     */
    public PageHelper<User> queryList(Map<String, Object> map) {
        List<String> likeFields = new ArrayList<>();
        likeFields.add("name");
        Criteria criteria = mongoDBDao.getCriteria(map, likeFields);

        List<Sort> sortList = new ArrayList<>();
        sortList.add(Sort.by(Sort.Order.desc("createTime")));
        return (PageHelper<User>) mongoDBDao.findByCondition(criteria, User.class,
                Integer.parseInt((String) map.get("pageNum")),
                Integer.parseInt((String) map.get("pageSize")), sortList);
    }


    /**
     * 插入一条数据
     */
    public boolean insert(User user) {
        user.setName("bai");
        user.setCreateTime(LocalDateTime.now());
        return mongoDBDao.insert(user);
    }


    /**
     * 批量插入数据
     */
    public boolean patchInsert(List<User> list) {
        for (User user : list) {
            user.setName("bai");
            user.setCreateTime(LocalDateTime.now());
        }
        return mongoDBDao.insertAll(list, User.class);
    }


    /**
     * 更新数据
     */
    public UpdateResult update(Map<String, Object> map) {
        Criteria criteria = Criteria.where("id").is(map.get("id"));
        Update update = new Update();
        for (String key : map.keySet()) {
            if ("id".equals(key)) {
                continue;
            }
            update = update.set(key, map.get(key));
        }
        return (UpdateResult) mongoDBDao.updateOne(criteria, update, User.class);
    }


    /**
     * 根据 Id 查询数据
     */
    public User findById(String id) {
        return (User) mongoDBDao.findById(id, User.class);
    }


    /**
     * 批量删除
     */
    public Long patchDelete(List<String> ids, String field) {
        Criteria criteria = Criteria.where(field).in(ids);
        DeleteResult deleteCount = (DeleteResult) mongoDBDao.delete(criteria, User.class);
        return deleteCount.getDeletedCount();
    }


    /**
     * 查询数量
     */
    public long count(Map<String, Object> map) {
        Criteria criteria = mongoDBDao.getCriteria(map);
        return mongoDBDao.count(criteria, User.class);
    }
}

7. 创建启动类

package com.cnbai;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

二、自定义 MongoTemplate

MongoDBDao

package com.cnbai.dao;

import java.util.List;

/**
 * MongoDB API
 */
public interface MongoDBDao {

    /**
     * 创建自定义 mongoTempalte -> 创建集合
     *
     * @param collectionName 集合名
     * @param dbName 数据库名
     */
    boolean createCollection(String collectionName, String dbName);

    /**
     * 创建自定义 mongoTempalte -> 批量插入数据
     *
     * @param o 记录
     * @param collectionName 集合名
     * @param dbName 数据库名
     */
    boolean insertAll(List o, String collectionName, String dbName);
}

MongoDBDaoImpl

package com.cnbai.dao;

import com.mongodb.client.MongoClient;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.SimpleMongoClientDatabaseFactory;
import org.springframework.stereotype.Repository;

import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * MongoDB 处理类
 */
@Repository
public class MongoDBDaoImpl implements MongoDBDao {
    
    @Resource
    private MongoClient mongoClient;

    // 创建缓存
    private final ConcurrentHashMap<String, MongoTemplate> templateCache = new ConcurrentHashMap<>();

    @Override
    public boolean createCollection(String collectionName, String dbName) {
        MongoTemplate mongoTemplate = getMongoTemplate(dbName);
        if (mongoTemplate.collectionExists(collectionName)) {
            return true;
        }
        mongoTemplate.createCollection(collectionName);
        return mongoTemplate.collectionExists(collectionName);
    }

    @Override
    public boolean insertAll(List o, String collectionName, String dbName) {
        try {
            MongoTemplate mongoTemplate = getMongoTemplate(dbName);
            mongoTemplate.insert(o, collectionName);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

	// 创建 mongoTemlate 对象
    private MongoTemplate getMongoTemplate(String dbName) {
        return templateCache.computeIfAbsent(dbName, k ->
                new MongoTemplate(new SimpleMongoClientDatabaseFactory(mongoClient, k))
        );
    }

	// 销毁对象
    @PreDestroy
    public void destroy() {
        if (mongoClient != null) {
            mongoClient.close();
        }
        templateCache.clear();
    }
}