Java連接MongoDB數據庫進行增刪改查操作

用於最近項目中用到了Mongodb數據庫，這里簡單記錄下Java對Mongodb進行增刪改查：

項目整體介紹：

采用springboot框架搭建的項目

用redis對每行數據進行排序

前端table展示使用element-ui離線文件

項目結構如下圖：

 

MongodbUtils類：

package com.fengyulv.fyl.common.untils;

import com.fengyulv.fyl.common.config.Result;
import com.mongodb.BasicDBObject;
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.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.*;
import java.util.regex.Pattern;

/**
 * @author fyl
 * @date 2021/06/01
 * mongodb的增刪改查工具類
 */
@Component
public class MongodbUtils {
    public static MongodbUtils mongodbUtils;
    /**
     * 線程池創建
     */
    public static ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 200, 10, TimeUnit.SECONDS, new LinkedBlockingDeque<>(100000), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

    @PostConstruct
    public void init() {
        mongodbUtils = this;
        mongodbUtils.mongoTemplate = this.mongoTemplate;
    }

    @Resource
    private MongoTemplate mongoTemplate;

    /**
     * 查詢出所有結果集 集合為數據對象中@Document 注解所配置的collection
     *
     * @param clazz 泛型
     * @return List
     */
    public static <T> List<T> findAll(Class<T> clazz) {
        List<T> resultList = mongodbUtils.mongoTemplate.findAll(clazz);
        return resultList;
    }

    /**
     * 分頁查找某個子集元素的長度大於等於1，並且不為null
     *
     * @param childName 子集元素的名稱
     * @param clazz     類型
     * @param <T>       泛型
     * @return 數據集合
     */
    public <T> List<T> findChildDocumentGtOne(Integer limit, Integer page, String childName, Class<T> clazz) {
        List<T> resultList = null;
        try {
            resultList = mongodbUtils.mongoTemplate.find(Query.query(Criteria.where(childName + ".0").exists(true).and(childName).exists(true)).limit(limit).skip(limit * (page - 1)), clazz);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resultList;
    }


    /**
     * 分頁查詢 集合為數據對象中@Document 注解所配置的collection
     *
     * @param page  當前頁
     * @param limit 分頁條數
     * @return 數據
     */
    public <T> Map<String, Object> findAllByPage(Class<T> clazz, Integer page, Integer limit) {
        Map<String, Object> map = new HashMap<>();
        page = page - 1;
        Query query = new Query();
        //根據集合中對象的某個字段排序
        query.with(Sort.by(Sort.Order.desc("sort")));
        long count = mongodbUtils.mongoTemplate.count(query, clazz);
        List<T> ts = mongodbUtils.mongoTemplate.find(query.limit(limit).skip(page * limit), clazz);
        map.put("data", ts);
        map.put("count", count);
        return map;
    }

    /**
     * 根據條件查詢出所有結果集
     *
     * @param tClass         泛型
     * @param keys           查詢條件 key
     * @param values         查詢條件 value
     * @param collectionName 集合名字
     * @return 信息
     */
    public <T> List<T> findDataByKeyLimit(Class<T> tClass, String[] keys, String[] values, String collectionName) {
        Criteria criteria = null;
        for (int i = 0; i < keys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(keys[i]).is(values[i]);
            } else {
                criteria.and(keys[i]).is(values[i]);
            }
        }
        Query query = Query.query(criteria);
        //全部結果信息
        return mongodbUtils.mongoTemplate.find(query, tClass, collectionName);
    }

    /**
     * 根據條件查詢出分頁結果集
     *
     * @param clazz  泛型
     * @param page   當前頁
     * @param limit  分頁條數
     * @param keys   查詢條件 key
     * @param values 查詢條件 value
     * @return 信息
     */
    public <T> Map<String, Object> findDataByKey(Class<T> clazz, String[] keys, String[] values, Integer page, Integer limit) {
        Map<String, Object> map = new HashMap<>();
        page = page - 1;
        Query query = new Query();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Criteria criteria = null;
        for (int i = 0; i < keys.length; i++) {
            Pattern pattern = Pattern.compile("^" + values[i] + "", Pattern.CASE_INSENSITIVE);
            if (i == 0) {
                criteria = Criteria.where(keys[i]).regex(pattern);
            } else {
                criteria.and(keys[i]).regex(pattern);
            }
        }
        query.addCriteria(criteria);

        //總量
        CompletableFuture<Long> future1 = CompletableFuture.supplyAsync(() -> {
            long count = this.mongoTemplate.count(query, clazz);
            return count;
        }, executor);

        Integer finalPage = page;
        CompletableFuture<List<T>> future2 = CompletableFuture.supplyAsync(() -> {
            //根據集合中對象的某個字段排序
            query.with(Sort.by(Sort.Order.desc("sort")));
            List<T> resultList = new ArrayList<>();
            resultList = mongodbUtils.mongoTemplate.find(query.limit(limit).skip(limit * finalPage), clazz);
            return resultList;
        }, executor);

        CompletableFuture<Map<String, Object>> all = future1.thenCombineAsync(future2, (f1, f2) -> {
            Map<String, Object> maps = new HashMap<>();
            maps.put("count", f1);
            maps.put("data", f2);
            return maps;
        }, executor);

        try {
            map = all.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        return map;
    }

    /**
     * 修改子集的刪除字段為1，表示刪除
     *
     * @param documentId 文檔的id
     */
    public void updateDataIsDel(String documentId, Class<?> clazz) {
        Query query = new Query();
        query.addCriteria(Criteria.where("_id").is(documentId));
        mongodbUtils.mongoTemplate.remove(query, clazz);
    }

    public void updateDataPLIsDel(String[] documentId, Class<?> clazz) {
        Query query = new Query();
        query.addCriteria(Criteria.where("_id").in(documentId));
        mongodbUtils.mongoTemplate.remove(query, clazz);
    }


    /**
     * 根據集合對象中的id刪除數據
     *
     * @param id     對象id
     * @param tClass 映射的集合
     */
    public void removeById(String id, Class<?> tClass) {
        try {
            mongodbUtils.mongoTemplate.remove(new Query(Criteria.where("_id").is(id)), tClass);
        } catch (Exception e) {
            throw e;
        }
    }

    /**
     * 刪除子集文檔的數據
     *
     * @param documentId  父級文檔的id
     * @param childIdName 子集文檔的唯一字段名稱
     * @param childId     子集文檔的唯一字段名稱的值
     * @param childName   子集文檔的名字
     * @param tClass      泛型
     * @return Result
     */
    public Result removeChildDocument(String documentId, String childIdName, String childId, String childName, Class<?> tClass) {
        try {
            Query query = Query.query(Criteria.where("_id").is(documentId));
            BasicDBObject s = new BasicDBObject();
            s.put(childIdName, childId);
            Update update = new Update();
            update.pull(childName, s);
            mongodbUtils.mongoTemplate.updateFirst(query, update, tClass);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error(500, "刪除失敗");
        }
        return Result.ok();
    }


    /**
     * 根據key，value到指定集合刪除數據
     *
     * @param key            鍵
     * @param value          值
     * @param collectionName 集合名
     */
    public Result removeByKeyValue(String key, Object value, String collectionName) {
        Criteria criteria = Criteria.where(key).is(value);
        criteria.and(key).is(value);
        Query query = Query.query(criteria);
        try {
            mongodbUtils.mongoTemplate.remove(query, collectionName);
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error(500, "刪除失敗");
        }
        return Result.ok();
    }

    /**
     * 修改子集文檔數組中內嵌文檔指定一個元素的值
     *
     * @param documentId       父級文檔的id
     * @param childIdName      子集文檔的唯一字段名稱
     * @param childId          子集文檔的唯一字段名稱的值
     * @param childName        子集文檔的名字
     * @param updateChildName  要跟新的字段
     * @param updateChildValue 要跟新的值
     * @param tClass           泛型
     * @return Result
     */
    public Result updateChildDocument(String documentId, String childIdName, String childId, String childName, String updateChildName, String updateChildValue, Class<?> tClass) {
        try {
            Query query = Query.query(Criteria.where("_id").is(documentId)
                    .and(childName + "." + childIdName).is(childId));
            Update update = new Update();
            update.set(childName + ".$." + updateChildName, updateChildValue);
            mongoTemplate.updateFirst(query, update, tClass);
        } catch (Exception e) {
            return Result.error(500, "修改失敗");
        }
        return Result.ok();
    }

    /**
     * 向子集文檔添加一個數據
     *
     * @param query       條件
     * @param childIdName 子集文檔名字
     * @param o           元素對象
     * @param tClass      泛型
     * @return 結果
     */
    public void saveOneFieldChildDocument(Query query, String childIdName, Object o, Class<?> tClass) {
        try {
            Update update = new Update();
            update.addToSet(childIdName, o);
            mongodbUtils.mongoTemplate.upsert(query, update, tClass);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 保存數據對象，集合為數據對象中@Document 注解所配置的collection
     *
     * @param obj
     */
    public void saveData(Object obj) {
        try {
            mongodbUtils.mongoTemplate.save(obj);
        } catch (Exception e) {
            throw e;
        }
    }

    /**
     * 指定集合保存數據對象
     *
     * @param obj            數據對象
     * @param collectionName 集合名
     */
    public void saveData(Object obj, String collectionName) {
        try {
            mongodbUtils.mongoTemplate.save(obj, collectionName);
        } catch (Exception e) {
            throw e;
        }
    }


    /**
     * 指定集合 修改數據，且僅修改找到的第一條數據
     *
     * @param accordingKey   修改條件 key
     * @param accordingValue 修改條件 value
     * @param updateKeys     修改內容 key數組
     * @param updateValues   修改內容 value數組
     * @param collectionName 集合名
     */
    public void updateFirst(String accordingKey, Object accordingValue, String[] updateKeys, Object[] updateValues, String collectionName) {
        Criteria criteria = Criteria.where(accordingKey).is(accordingValue);
        Query query = Query.query(criteria);
        Update update = new Update();
        for (int i = 0; i < updateKeys.length; i++) {
            update.set(updateKeys[i], updateValues[i]);
        }
        mongodbUtils.mongoTemplate.updateFirst(query, update, collectionName);
    }

    /**
     * 指定集合 修改數據，且修改所找到的所有數據
     *
     * @param accordingKey   修改條件 key
     * @param accordingValue 修改條件 value
     * @param updateKeys     修改內容 key數組
     * @param updateValues   修改內容 value數組
     * @param collectionName 集合名
     */
    public static void updateMulti(String accordingKey, Object accordingValue, String[] updateKeys, Object[] updateValues, String collectionName) {
        Criteria criteria = Criteria.where(accordingKey).is(accordingValue);
        Query query = Query.query(criteria);
        Update update = new Update();
        for (int i = 0; i < updateKeys.length; i++) {
            update.set(updateKeys[i], updateValues[i]);
        }
        mongodbUtils.mongoTemplate.updateMulti(query, update, collectionName);
    }
}

部分代碼這里就不展示了，感興趣的可以下載項目！
項目運行截圖：

Gitee地址：

https://gitee.com/lifu1234/mongodb/