mongodb工具类

最新推荐文章于 2024-07-24 09:04:04 发布
最新推荐文章于 2024-07-24 09:04:04 发布
阅读量733 收藏 5
点赞数 2
分类专栏： java 文章标签： mongodb工具类 mongodb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31275085/article/details/86480119
版权

MongodbUtils .java工具类 

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
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;

/**
 * mongodb curd 工具类
 *
 * @author ttan
 *
 */
@Component
public class MongodbUtils {


    public static MongodbUtils mongodbUtils;

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

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 保存数据对象，集合为数据对象中@Document 注解所配置的collection
     *
     * @param obj
     *            数据对象
     */
    public static void save(Object obj) {

        mongodbUtils.mongoTemplate.save(obj);
    }

    /**
     * 指定集合保存数据对象
     *
     * @param obj
     *            数据对象
     * @param collectionName
     *            集合名
     */
    public static void save(Object obj, String collectionName) {

        mongodbUtils.mongoTemplate.save(obj, collectionName);
    }

    /**
     * 根据数据对象中的id删除数据，集合为数据对象中@Document 注解所配置的collection
     *
     * @param obj
     *            数据对象
     */
    public static void remove(Object obj) {

        mongodbUtils.mongoTemplate.remove(obj);
    }

    /**
     * 指定集合 根据数据对象中的id删除数据
     *
     * @param obj
     *            数据对象
     * @param collectionName
     *            集合名
     */
    public static void remove(Object obj, String collectionName) {

        mongodbUtils.mongoTemplate.remove(obj, collectionName);
    }

    /**
     * 根据key，value到指定集合删除数据
     *
     * @param key
     *            键
     * @param value
     *            值
     * @param collectionName
     *            集合名
     */
    public static void removeById(String key, Object value, String collectionName) {

        Criteria criteria = Criteria.where(key).is(value);
        criteria.and(key).is(value);
        Query query = Query.query(criteria);
        mongodbUtils.mongoTemplate.remove(query, collectionName);
    }

    /**
     * 指定集合 修改数据，且仅修改找到的第一条数据
     *
     * @param accordingKey
     *            修改条件 key
     * @param accordingValue
     *            修改条件 value
     * @param updateKeys
     *            修改内容 key数组
     * @param updateValues
     *            修改内容 value数组
     * @param collectionName
     *            集合名
     */
    public static 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);
    }

    /**
     * 根据条件查询出所有结果集 集合为数据对象中@Document 注解所配置的collection
     *
     * @param obj
     *            数据对象
     * @param findKeys
     *            查询条件 key
     * @param findValues
     *            查询条件 value
     * @return
     */
    public static List<? extends Object> find(Object obj, String[] findKeys, Object[] findValues) {

        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeys[i]).is(findValues[i]);
            } else {
                criteria.and(findKeys[i]).is(findValues[i]);
            }
        }
        Query query = Query.query(criteria);
        List<? extends Object> resultList = mongodbUtils.mongoTemplate.find(query, obj.getClass());
        return resultList;
    }

    /**
     * 指定集合 根据条件查询出所有结果集
     *
     * @param obj
     *            数据对象
     * @param findKeys
     *            查询条件 key
     * @param findValues
     *            查询条件 value
     * @param collectionName
     *            集合名
     * @return
     */
    public static List<? extends Object> find(Object obj, String[] findKeys, Object[] findValues, String collectionName) {

        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeys[i]).is(findValues[i]);
            } else {
                criteria.and(findKeys[i]).is(findValues[i]);
            }
        }
        Query query = Query.query(criteria);
        List<? extends Object> resultList = mongodbUtils.mongoTemplate.find(query, obj.getClass(), collectionName);
        return resultList;
    }

    /**
     * 指定集合 根据条件查询出所有结果集 并排倒序
     *
     * @param obj
     *            数据对象
     * @param findKeys
     *            查询条件 key
     * @param findValues
     *            查询条件 value
     * @param collectionName
     *            集合名
     * @param sort
     *            排序字段
     * @return
     */
    public static List<? extends Object> find(Object obj, String[] findKeys, Object[] findValues, String collectionName ,String sort) {

        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeys[i]).is(findValues[i]);
            } else {
                criteria.and(findKeys[i]).is(findValues[i]);
            }
        }
        Query query = Query.query(criteria);
        query.with(new Sort(Direction.DESC, sort));
        List<? extends Object> resultList = mongodbUtils.mongoTemplate.find(query, obj.getClass(), collectionName);
        return resultList;
    }

    /**
     * 根据条件查询出符合的第一条数据 集合为数据对象中 @Document 注解所配置的collection
     *
     * @param obj
     *            数据对象
     * @param findKeys
     *            查询条件 key
     * @param findValues
     *            查询条件 value
     * @return
     */
    public static Object findOne(Object obj, String[] findKeys, Object[] findValues) {

        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeys[i]).is(findValues[i]);
            } else {
                criteria.and(findKeys[i]).is(findValues[i]);
            }
        }
        Query query = Query.query(criteria);
        Object resultObj = mongodbUtils.mongoTemplate.findOne(query, obj.getClass());
        return resultObj;
    }

    /**
     * 指定集合 根据条件查询出符合的第一条数据
     *
     * @param obj
     *            数据对象
     * @param findKeys
     *            查询条件 key
     * @param findValues
     *            查询条件 value
     * @param collectionName
     *            集合名
     * @return
     */
    public static Object findOne(Object obj, String[] findKeys, Object[] findValues, String collectionName) {

        Criteria criteria = null;
        for (int i = 0; i < findKeys.length; i++) {
            if (i == 0) {
                criteria = Criteria.where(findKeys[i]).is(findValues[i]);
            } else {
                criteria.and(findKeys[i]).is(findValues[i]);
            }
        }
        Query query = Query.query(criteria);
        Object resultObj = mongodbUtils.mongoTemplate.findOne(query, obj.getClass(), collectionName);
        return resultObj;
    }

    /**
     * 查询出所有结果集 集合为数据对象中 @Document 注解所配置的collection
     *
     * @param obj
     *            数据对象
     * @return
     */
    public static List<? extends Object> findAll(Object obj) {

        List<? extends Object> resultList = mongodbUtils.mongoTemplate.findAll(obj.getClass());
        return resultList;
    }

    /**
     * 指定集合 查询出所有结果集
     *
     * @param obj
     *            数据对象
     * @param collectionName
     *            集合名
     * @return
     */
    public static List<? extends Object> findAll(Object obj, String collectionName) {

        List<? extends Object> resultList = mongodbUtils.mongoTemplate.findAll(obj.getClass(), collectionName);
        return resultList;
    }
}

测试类MoTestController.java

import com.jugan.dao.Api;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.UUID;

@RestController
public class MoTestController {
    @PostMapping(value="/mo101")
    public void saveTest101() throws Exception {
        MongodbTestModel mo = new MongodbTestModel();
        mo.setMid("1");
        mo.setName("MongodbTestModel1");
        mo.setAge("111");
        MongodbUtils.save(mo);
    }
    @PostMapping(value="/mo102")
    public void saveTest102() throws Exception {
        MongodbTestModel mo = new MongodbTestModel();
        mo.setMid("2");
        mo.setName("MongodbTestModel2");
        mo.setAge("222");
        MongodbUtils.save(mo);
    }
    @PostMapping(value="/mo103")
    public void saveTest103() throws Exception {
        MongodbTestModel mo = new MongodbTestModel();
        mo.setMid("3");
        mo.setName("MongodbTestModel3");
        mo.setAge("333");
        MongodbUtils.save(mo);
    }
    @PostMapping(value="/mo104")
    public void saveTest104() throws Exception {
        MongodbTestModel mo = new MongodbTestModel();
        mo.setMid("4");
        mo.setName("MongodbTestModel3");
        mo.setAge("333");
        MongodbUtils.save(mo);
    }

    @PostMapping(value="/qmo101")
    public void qsaveTest101() throws Exception {
        MongodbTestModel mo = new MongodbTestModel();
        mo.setMid("3");
        mo.setName("MongodbTestModel3");
        mo.setAge("333");
        String[] findKeys = { "mid", "name" };
        String[] findValues = { "3", "MongodbTestModel3" };
        List<MongodbTestModel> t = (List<MongodbTestModel>) MongodbUtils.find(mo,findKeys,findValues);
        System.out.println("========"+ Api.entitysToJson(t));
    }
    @PostMapping(value="/qmo102")
    public void qsaveTest102() throws Exception {
        MongodbTestModel mo = new MongodbTestModel();
        mo.setMid("3");
        mo.setName("MongodbTestModel3");
        mo.setAge("333");
        String[] findKeys = {"name" };
        String[] findValues = {"MongodbTestModel3" };
        List<MongodbTestModel> t = (List<MongodbTestModel>) MongodbUtils.find(mo,findKeys,findValues);
        System.out.println("========"+ Api.entitysToJson(t));
    }
    @PostMapping(value="/qmo103")
    public void qsaveTest103() throws Exception {
        MongodbTestModel mo = new MongodbTestModel();
        mo.setMid("3");
        mo.setName("MongodbTestModel3");
        mo.setAge("333");
        String[] findKeys = {"name" };
        String[] findValues = {"MongodbTestModel4" };
        List<MongodbTestModel> t = (List<MongodbTestModel>) MongodbUtils.find(mo,findKeys,findValues);
        if (t.size()==0){
            System.out.println("========0000"+ Api.entitysToJson(t));
        }
        System.out.println("========"+ Api.entitysToJson(t));
    }


    @PostMapping(value="/mo2")
    public void saveTest2() throws Exception {
        MongodbTestModel mo = new MongodbTestModel();
        mo.setMid(UUID.randomUUID().toString());
        mo.setName("MongodbTestModel");
        mo.setAge("22");
        MongodbUtils.save(mo, "test23");
    }
    @PostMapping(value="/mo3")
        public void testRemove1() {
        MongodbTestModel mo = new MongodbTestModel();
        mo.setMid("123");
        mo.setName("MongodbTestMode");
        mo.setAge("22");
        MongodbUtils.remove(mo);
    }

    @PostMapping(value="/mo4")
    public void testRemove2() {
        MongodbTestModel mo = new MongodbTestModel();
        mo.setMid("628fdbc8-1155-497e-9c6a-1264050f9fef");
        mo.setName("MongodbTestModel");
        mo.setAge("22");
        MongodbUtils.remove(mo, "test23");
    }

    @PostMapping(value="/mo5")
    public void testRemove3() {
        MongodbUtils.removeById("_id", "123", "mongodbTestModel");
    }

    @PostMapping(value="/mo6")
    public void testUpdate1() {
        String accordingKey = "_id";
        String accordingValue = "e933f48a-cc68-4993-9069-820ff3adab34";
        String[] updateKeys = { "name", "age" };
        Object[] updateValues = { "tat", "22222" };
        String collectionName = "test23";
        MongodbUtils.updateFirst(accordingKey, accordingValue, updateKeys, updateValues, collectionName);
    }

    @PostMapping(value="/mo7")
    public void testUpdate2() {
        String accordingKey = "name";
        String accordingValue = "tat";
        String[] updateKeys = { "age" };
        Object[] updateValues = { "000000" };
        String collectionName = "test23";
        MongodbUtils.updateMulti(accordingKey, accordingValue, updateKeys, updateValues, collectionName);
    }

    @PostMapping(value="/mo8")
    public void testFind1() {
        MongodbTestModel obj = new MongodbTestModel();
        String[] findKeys = { "age", "name" };
        String[] findValues = { "22", "MongodbTestModel" };
        List<? extends Object> find = MongodbUtils.find(obj, findKeys, findValues);
        System.out.println(find);
    }

    @PostMapping(value="/mo9")
    public void testFind2() {
        MongodbTestModel obj = new MongodbTestModel();
        String[] findKeys = { "name" };
        String[] findValues = { "tat" };
        String collectionName = "test23";
        List<? extends Object> find = MongodbUtils.find(obj, findKeys, findValues, collectionName);
        System.out.println(find);
    }

    @PostMapping(value="/mo10")
    public void testFind3() {
        MongodbTestModel obj = new MongodbTestModel();
        String[] findKeys = { "name" };
        String[] findValues = { "tat" };
        String collectionName = "test23";
        Object findOne = MongodbUtils.findOne(obj, findKeys, findValues, collectionName);
        System.out.println(findOne);
    }

   @PostMapping(value="/mo11")
    public void testFind4() {
        List<? extends Object> findAll = MongodbUtils.findAll(new MongodbTestModel());
        System.out.println(findAll);
    }

    @PostMapping(value="/mo12")
    public void testFind5() {
        List<? extends Object> findAll = MongodbUtils.findAll(new MongodbTestModel(),"test23");
        System.out.println(findAll);
    }

}

相关实体类

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

//@Document(collection="mongodbTestModel") //collection:集合名 类似于关系型数据里面的 tableName
@Document(collection="mongodbTestModel")
public class MongodbTestModel {

    @Id
    private String mid;
    private String name;
    private String age;

    public String getMid() {
        return mid;
    }
    public void setMid(String mid) {
        this.mid = mid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "MongodbTestModel [mid=" + mid + ", name=" + name + ", age=" + age + "]";
    }
}

 

浮_雲
关注
专栏目录
mongoDB工具介绍与常用命令整理
CDY_yuan的博客
06-04 630
前言： 平时的测试工作中接触的数据库并不只有sql，许多公司为了更好的处理数据，特别是对数据要求较高的业务通常会采取更合适的处理方案与工具，所以测试工作中对于其他类型的数据库也要有适当的了解与使用，常用的mongoDB、Redis等；不同的工具也会有不同的查询方法，当然对于测试而言仅仅掌握常用的增删查改就够了；本篇介绍的就是我在工作中接触比较多的mongoDB，并整理了一些简单的语句，仅供参考；...
MongoDB操作之java工具类
ronnie_rocket的博客
05-21 1075
package com.siwill.controller; /** * Created by panweifu on 2019/5/21. */ public class MongoDbUtil { private final static ThreadLocal<Mongo> mongos = new ThreadLocal<Mongo>(); ...
MongoDB 监控命令与内置工具
最新发布
My_wife_QBL的博客
07-24 648
MongoDB作为一个流行的NoSQL数据库，提供了一系列监控工具和命令，帮助开发者和运维人员实时监控数据库的性能、资源使用情况以及潜在的瓶颈。MongoDB提供了一系列强大的监控命令和工具，帮助开发者和运维人员实时监控数据库的性能和状态。随着业务的不断发展，持续监控和优化MongoDB的性能将是确保应用程序高效和可靠的关键。MongoDB提供了一些内置的监控工具和命令，可以帮助用户实时监控数据库的性能和状态。根据监控数据和业务需求，定期评估系统资源的需求，及时进行扩展，确保系统的可用性和稳定性。
mongo-db-utils:mongo-db-utils - 使备份和复制数据库更容易
07-08
MongoDbUtils ！当前版本 0.1.2 处于 Beta 版 - 更安全的版本使用 0.0.9 一个简化备份和复制 mongo dbs 的小宝石。 您可以作为脚本运行（例如用于 cron 作业，或在交互模式下）： 它会保存您的数据库网址，因此只需点击几下即可完成任何任务。 在本地备份数据库 备份数据库并将其部署到 Amazon S3 将数据库从一台服务器复制到另一台服务器（同时在本地备份目标数据库（如果存在） 安装 您需要在路径上安装mongodump和mongorestore 。 gem install 'mongo-db-utils' 然后执行： $ mongo-db-utils console 限制 Ruby >= 1.9.3 用法 启动控制台后，它会为您提供一组选项 - 不言自明。 当它进行备份时，它会将它们存储在~/.mongo-db-utils/bac
14.MongoDBUtils工具类
weixin_33766168的博客
01-23 585
1. 1 public class DbUtils { 2 3 public static MongoCollection&lt;Document&gt; getMongoCollection(String localhost, int port) { 4 MongoClient mongoClient = new MongoClient(localhost, ...
MongodbUtil
weixin_34119545的博客
03-18 112
import com.mongodb.MongoClient; import com.mongodb.MongoClientOptions; import com.mongodb.MongoClientURI; import com.mongodb.MongoCredential; import com.mongodb.MongoOptions; import com.mongodb.Serve...
MongoDBUtil
willow的博客
04-20 1061
package com.bootdo.common.utils; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; import org....
JAVA单例MongoDB工具类
12-22
经常对MongoDB进行一些常用操作，为了方便起见将这些常用操作合并到一个工具类中，方便自己开发使用。 　没用Spring Data、Morphia等框架是为了减少学习、维护成本，另外自己直接JDBC方式的话可以更方便的控制操作...
连接mongodb工具类及配置文件
06-20
在Kotlin中，创建一个MongoDB连接工具类可能包括以下步骤： 1. 引入MongoDB Java驱动程序或KMongo库。 2. 初始化MongoClient实例，指定服务器地址和端口。 3. 选择要操作的数据库。 4. 提供用于操作集合的方法，如...
MongoDBUtil.java
06-03
Mongo操作工具类,里面有增删改查的方法,很方便的操作,希望能帮助大家
mongoUtil类
11-15
实现mongodb增、删、改、查等方法并获取连接，关闭连接等功能。初学者适用
鹅：一些mongodb和mysql数据库utils
02-15
鹅 甲golang结构标记（模式）风格蒙戈包超接口上基mongo-driver ，通过Node.js的包启发 例子 您可以检查/examples/文件夹。 cd ./examples && go run ./simple.go 文档 数据库 一旦在主要功能中连接了数据库，就可以在任何地方建立模型。 通过.env文件连接到Mongo func main () { err := godotenv . Load () if err != nil { t . Error ( err ) } db , err := goose . NewMongoDatabase ( & goose. DatabaseOptions { UsingEnv : true , }) if err != nil { t . Fatal ( err ) } def
java操作mongodb的工具类
05-16
java操作mongodb的工具类,增删查改方法
java的MongoUtil
11-17
java操作mongodb的util工具类，其中主要包括了增删改查
java 连接 MongoDB 工具类示例
10-13
Java连接MongoDB工具类示例主要展示了如何在Java应用程序中与MongoDB数据库进行交互，MongoDB是一个NoSQL数据库，以其非关系型、分布式、高性能和灵活性而受到开发者的青睐。在Java中，我们通常使用MongoDB Java驱动...
mongoDB使用工具类
wt5264的博客
07-14 353
【代码】mongoDB使用工具类。
mongoDB 学习笔记（十）MongoDBUtil
huangpf_vcx
06-02 1571
import java.util.ArrayList; import java.util.List; import com.mongodb.MongoClient; import com.mongodb.MongoCredential; import com.mongodb.ServerAddress; import com.mongodb.client.MongoDatabase; pu...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值