Java和Python访问MongoDB + 增删改查操作全详细教程附jar包和程序代码

最新推荐文章于 2024-06-02 20:47:57 发布

进击的墨菲特

最新推荐文章于 2024-06-02 20:47:57 发布

阅读量1.2k

点赞数 19

文章标签： java python mongodb jar

本文链接：https://blog.csdn.net/x_8efengfan/article/details/136719061

版权

文章目录

前言
一、安装MongoDB驱动
二、通过Java访问MongoDB
三、通过Python访问MongoDB
四、完整代码

前言

善始者繁多，克终者盖寡。

本文介绍使用Java和Python访问MongoDB的方法，并演示在eclipse、IDEA、PyCharm、jupyter四种主流IDE中的操作过程，实现对本地MongoDB数据库的增删改查操作，推荐在命令行配合查看数据操作的结果，以验证相应操作是否成功。

一、安装MongoDB驱动

现在大家在网络上应该可以找到两种类型的MongoDB的Java驱动，因为MongoDB官方在2023年进行了调整，不过所有的资源都可以通过jar包Maven依赖查询与下载获得。文中使用的是图中第二个官方不再维护和更新的版本，版本号为3.12.14。

在这里插入图片描述

Python对于MongoDB驱动的管理方便的多，只需要通过pip命令下载对应包即可。

1.1 IDEA环境—使用Maven依赖

在pom.xml添加如下依赖，依赖中包含MongoDB数据库依赖以及JUnit5依赖：

    <dependencies>
        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver</artifactId>
            <version>3.12.14</version>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

1.2 eclipse环境—使用jar包

MongoDB驱动jar包和 JUnit 的jar包已上传，可以在文章顶部下载使用，当然其他版本也可通过jar包Maven依赖查询与下载获得。

1.3 Pycharm环境—pip指令

在软件内部控制台输入如下指令即可：

pip install pymongo

在这里插入图片描述

1.4 Jupyter环境—pip或conda指令

分两种情况：使用Anconda、未使用Anconda：

未使用Anconda，在命令行输入“pip install pymongo”，正常启动jupyter notebook即可
使用Anconda，此种情况需要先切换至Anconda环境，执行“conda install pymongo”命令，再正常启动jupyter notebook

二、通过Java访问MongoDB

通过Java访问MongoDB数据库的流程是：

获取数据库连接，对应MongoClient 对象
连接指定数据库，对应MongoDatabase 对象
操作指定集合，对应MongoCollection对象
Java中使用Document类表示文档，在集合中执行文档的增删改查操作

2.1 连接MongoDB数据库

2.1.1 不需要验证

使用当前版本的驱动访问MongoDB数据库有三种方式，默认情况下访问MongoDB的地址为“localhost”，端口号为“27017”，可以使用代参数的方法以适合自己的配置。

    //编写getConnection方法获取MongoDB连接对象
    public static MongoClient getConnection() {
//        MongoClient mongoClient = new MongoClient();
//        MongoClient mongoClient = new MongoClient("localhost");
        MongoClient mongoClient = new MongoClient("localhost", 27017);
        return mongoClient;
    }

使用JUnit5创建测试类，测试方法是否可行：

    @Test
    void getConnection() {
        System.out.println(MongoDBUtil.getConnection());
    }

2.1.2 需要验证

类似于通过JDBC连接mysql数据库，在MongoDB中有时候也需要输入用户密码才能够访问，此方法与2.1.1中的“不需要验证”方法并无很大区别，只是除地址、端口信息外，还需要添加用户名、访问数据库名、密码等信息。

    //编写getConnection_cre方法获取通过验证连接MongoDB
    public static MongoClient getConnection_cre(){
        List<ServerAddress> serverAddresses = new ArrayList<>();
        serverAddresses.add(new ServerAddress("localhost", 27017));

        List<MongoCredential> mongoCredentials = new ArrayList<>();
        mongoCredentials.add(MongoCredential.createCredential("root", "test", "123456".toCharArray()));

        MongoClient mongoClient = new MongoClient(serverAddresses, mongoCredentials);
        return mongoClient;
    }

2.2 添加文档

2.2.1 添加单个文档

使用insertOne方法向指定集合中插入一条记录，该方法调用了MongoCollection 类的insertOne方法，不返回任何信息。

    //编写insertOne方法向数据库添加一个文档
    public static void insertOne(MongoCollection mongoCollection, Document document){
        mongoCollection.insertOne(document);
    }

测试程序：

    @Test
    void insertOne() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        Document mydocument = new Document("name", "赛文")
                                            .append("age","1024")
                                            .append("weight","6500");
        MongoDBUtil.insertOne(collection, mydocument);
    }

验证结果：

在这里插入图片描述

2.2.2 添加多个文档

向指定集合中添加多个文档，拟添加的文档存放在集合中，该方法调用了MongoCollection 类的insertMany方法。

    //编写insertMany方法向数据库添加多个文档
    public static void insertMany(MongoCollection mongoCollection, List<Document> documents){
        mongoCollection.insertMany(documents);
    }

测试程序：

    @Test
    void insertMany() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        List<Document> documents = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            Document temp = new Document("number", i)
                                .append("age", i * 10);
            documents.add(temp);
        }
        MongoDBUtil.insertMany(collection, documents);
    }

测试结果：
在具体操作时本人执行了两次insertOne操作，所以会有两条一样的记录。

在这里插入图片描述

2.3 删除文档

2.3.1 删除单个文档

删除指定集合中的指定文档，此时参数documents表示删除的条件，该方法调用了MongoCollection 的deleteOne方法。

    //编写deleteOne方法删除单个文档
    public static void deleteOne(MongoCollection mongoCollection, Document documents){
        mongoCollection.deleteOne(documents);
    }

测试程序：

删除“number”值为3的文档，请注意在java中“3”和3表示的含义并不相同，“3”表示字符3,而3表示数字3，如果在执行删除或更新操作时除以意外情况，请检查删除条件的数据类型是否对应。

    @Test
    void deleteOne() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        //删除条件，即document，有数据类型要求
        Document document = new Document("number", 3);
        MongoDBUtil.deleteOne(collection, document);
    }

测试结果：
在这里插入图片描述

2.3.2 删除多个文档

删除指定集合中的多个文档，此时的document表示删除的条件，该方法调用了MongoCollection 的deleteMany方法。

    //编写deleteMany方法删除匹配条件的多个文档
    public static void deleteMany(MongoCollection mongoCollection, Document document){
        mongoCollection.deleteMany(document);
    }

测试程序：

    @Test
    void deleteMany() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        Document document = new Document("name", "赛文");
        MongoDBUtil.deleteMany(collection, document);
    }

测试结果：
在这里插入图片描述

2.4 修改文档

2.4.1 修改单个文档

更新指定集合中的文档，使用该方法时需要告知两个条件，一是查找到对应记录的条件condition，二是拟更新的数据，该方法调用了MongoCollection 的updateOne方法。

    //编写updateOne方法更新一个文档
    public static void updateOne(MongoCollection mongoCollection, Document conditon, Document document){
        mongoCollection.updateOne(conditon, document);
    }

测试程序：
在MongoDB数据库中，所有数据都以文档形式存储，使用“键值对”方式表示，测试程序中“$set”是MongoDB数据库的更新指令，其后接拟更新的数据，这些数据同样使用“键值对”表示，具体到Java中，就使用Document对象来表示。

    @Test
    void updateOne() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        //查询条件
        Document condition = new Document("number", 1);
        //拟更新数据
        Document document = new Document("$set", new Document("number", 0));
        MongoDBUtil.updateOne(collection, condition, document);

测试结果：

在这里插入图片描述

2.4.2 修改多个文档

更新指定集合中的多个文档，该方法调用了MongoCollection 的updateMany方法。

    //编写updateMany方法更新多个文档
    public static void updateMany(MongoCollection mongoCollection, Document condition, Document document){
        mongoCollection.updateMany(condition, document);
    }

测试程序：

    @Test
    void updateMany() {
        MongoClient  connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        //查询条件
        Document condition = new Document("number", 0);
        //拟更新数据
        Document document = new Document("$set", new Document("number", 2));
        MongoDBUtil.updateMany(collection, condition, document);
    }

测试结果：

在这里插入图片描述

2.5 查询文档

2.5.1 查询单个文档

查询指定结合中满足条件的文档，document表示查询条件，MongoCollection 的find方法会返回一个FindIterable对象，它是一个迭代器，所有使用first方法获取其第一个元素并转换为Document 对象。

    //编写findOne方法查询单个文档
    public static Document findOne(MongoCollection mongoCollection, Document document){
        return (Document) mongoCollection.find(document).first();
    }

#测试程序

    @Test
    void findOne() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        //查询条件
        Document document = new Document("number", 2);
        System.out.println(MongoDBUtil.findOne(collection, document));
    }

2.5.2 查询多个文档

查询指定集合中满足条件的多个文档，通过循环以此获取findIterable 中的元素并将其转换为Document对象存储起来。

    //编写findAll方法查询所有满足条件文档
    public static List<Document> findAllCondition(MongoCollection mongoCollection, Document document){
        List<Document> documents = new ArrayList<>();
        FindIterable findIterable = mongoCollection.find(document);
        for (Object  temp: findIterable) {
            documents.add((Document) temp);
        }
        return documents;
    }

测试程序：

    @Test
    void findAllCondition() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        //查询条件
        Document document = new Document("number", 2);
        //获取查询结果列表
        List<Document> documentList = MongoDBUtil.findAllCondition(collection, document);
        System.out.println(documentList);
    }

2.5.3 查询全部文档

查询指定集合中的全部文档，该方法无查询条件，直接返回集合中的所有文档。

    //编写findAll方法直接查询所有文档
    public static List<Document> findAll(MongoCollection mongoCollection){
        List<Document> documents = new ArrayList<>();
        FindIterable findIterable = mongoCollection.find();
        for (Object temp: findIterable) {
            documents.add((Document) temp);
        }
        return documents;
    }

测试程序：

    @Test
    void findAll() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        List<Document> documentList = MongoDBUtil.findAll(collection);
        System.out.println(documentList);
    }

三、通过Python访问MongoDB

相较于使用Java访问MongoDB，使用Python访问MongoDB使用的指令更加接近命令行的方式，给人的视觉效果更加直观。通过Python访问MongoDB数据库的流程是：

获取数据库连接，即创建MongoClient 对象connection
连接指定数据库，connection.数据库名称
操作指定集合，connection.数据库名称.集合名称
Python中使用字典的形式表示文档，相较于Java中Document的表示方法，字典更加直观形象

3.1 连接MongoDB数据库

#获取MongoDB连接
def  getConnection():
    # client = MongoClient()
    # client = MongoClient('localhost')
    client = MongoClient('localhost', 27017)
    return client

3.2 添加文档

3.2.1 添加单个文档

#创建inserOne方法，向数据库中添加一个文档
def  insertOne(collection:Collection, data):
    collection.insert_one(data)

测试程序：

    #测试insertOne方法
    def test_insertOne(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        data = {
            "name":"张三",
            "age":18,
            "height":170
        }
        MongoDBUtil.insertOne(collection,data)

测试结果：
在这里插入图片描述

3.2.2 添加多个文档

#创建insertMany方法，向数据库中添加多个文档
def  insertMany(collection:Collection, data):
    collection.insert_many(data)

测试程序：

    #测试insertMany方法
    def test_insertMany(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        data = [
            {
                "name":"李四",
                "age":20,
                "height":180
            },
            {
                "name":"王五",
                "age":22,
                "height":190
            }
        ]
        MongoDBUtil.insertMany(collection, data)

测试结果：
在这里插入图片描述

3.3 删除文档

3.3.1 删除单个文档

#创建deleteOne方法，删除数据库中满足条件的单个文档
def  deleteOne(collection:Collection, condition):
    collection.delete_one(condition)

测试程序：

    #测试试deleteOne方法
    def test_deleteOne(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        condition = {
            "name":"李四"
        }
        MongoDBUtil.deleteOne(collection, condition)

测试结果：

在这里插入图片描述

3.3.2 删除多个文档

#创建deleteMany方法，删除数据库中满足条件的多个文档
def  deleteMany(collection:Collection, condition):
    collection.delete_many(condition)

测试程序：

    #测试deleteMany方法
    def test_deleteMany(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        condition = {
            "name":"王五"
        }
        MongoDBUtil.deleteMany(collection, condition)

测试结果：

由于此时person集合中仅包含“张三”、“王五”两条记录，无法执行删除多个文档的操作，所以在删除操作前再执行一次“插入多个文档”的操作。

在这里插入图片描述

3.4 修改文档

3.4.1 修改单个文档

#创建updateOne方法，更新数据库中满足条件的单个文档
def  updateOne(collection:Collection, condition, data):
    collection.update_one(condition, data)

测试程序：

将“张三”的年龄改为20，身高改为199，“$set”是MongoDB中修改操作的标识符，类似于mysql中的“SET”。

    #测试updateOne方法
    def test_updateOne(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        condition = {
            "name":"张三"
        }
        data = {
            "$set":
                {
                "age":20,
                "height":199
                }
        }
        MongoDBUtil.updateOne(collection, condition, data)

测试结果：

在这里插入图片描述

3.4.2 更新多个文档

#创建updateMany方法，更新数据库中满足条件的多个文档
def  updateMany(collection:Collection, condition, data):
    collection.update_many(condition, data)

测试程序：

将年龄为20的人身高都改为5000。

    #测试updateMany方法
    def test_updateMany(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        condition = {
            "age":20
        }
        data = {
            "$set":
                {
                "height":5000
                }
        }
        MongoDBUtil.updateMany(collection, condition, data)

测试结果：
在这里插入图片描述

3.5 查询文档

3.5.1 查询单个文档

查询满足条件的单个文档

#创建findOne方法，查询数据库中满足条件的单个文档
def  findOne(collection:Collection, condition):
    return collection.find_one(condition)

测试程序：

    #测试findOne方法
    def test_findOne(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        condition = {
            "height":5000
        }
        result = MongoDBUtil.findOne(collection, condition)
        print(result)

3.5.2 查询多个文档

查询满足条件的多个文档

#创建findAllCondition方法，查询数据库中满足条件的多个文档
def  findAllCondition(collection:Collection, condition):
    return collection.find(condition)

测试程序：

    #测试findAllCondition方法
    def test_findAllCondition(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        condition = {
            "height":5000
        }
        result = MongoDBUtil.findAllCondition(collection, condition)
        for item in result:
            print(item)

3.5.3 查询所有文档

#创建findAll方法，查询数据库中所有文档
def  findAll(collection:Collection):
    return collection.find()

测试程序：

    #测试findAll方法
    def test_findAll(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        result = MongoDBUtil.findAll(collection)
        for item in result:
            print(item)

四、完整代码

4.1 Java

4.1.1 MongoDBUtil.java

import com.mongodb.MongoClient;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import org.bson.Document;

import java.util.ArrayList;
import java.util.List;

public class MongoDBUtil {
    public static void main(String[] args) {

    }

    //编写getConnection方法获取MongoDB连接对象
    public static MongoClient getConnection() {
//        MongoClient mongoClient = new MongoClient();
//        MongoClient mongoClient = new MongoClient("localhost");
        MongoClient mongoClient = new MongoClient("localhost", 27017);
        return mongoClient;
    }

    //编写getConnection_cre方法获取通过验证连接MongoDB
    public static MongoClient getConnection_cre(){
        List<ServerAddress> serverAddresses = new ArrayList<>();
        serverAddresses.add(new ServerAddress("localhost", 27017));

        List<MongoCredential> mongoCredentials = new ArrayList<>();
        mongoCredentials.add(MongoCredential.createCredential("root", "test", "123456".toCharArray()));

        MongoClient mongoClient = new MongoClient(serverAddresses, mongoCredentials);
        return mongoClient;
    }

    //编写insertOne方法向数据库添加一个文档
    public static void insertOne(MongoCollection mongoCollection, Document document){
        mongoCollection.insertOne(document);
    }

    //编写insertMany方法向数据库添加多个文档
    public static void insertMany(MongoCollection mongoCollection, List<Document> documents){
        mongoCollection.insertMany(documents);
    }

    //编写deleteOne方法删除单个文档
    public static void deleteOne(MongoCollection mongoCollection, Document documents){
        mongoCollection.deleteOne(documents);
    }

    //编写deleteMany方法删除匹配条件的多个文档
    public static void deleteMany(MongoCollection mongoCollection, Document document){
        mongoCollection.deleteMany(document);
    }

    //编写updateOne方法更新一个文档
    public static void updateOne(MongoCollection mongoCollection, Document conditon, Document document){
        mongoCollection.updateOne(conditon, document);
    }

    //编写updateMany方法更新多个文档
    public static void updateMany(MongoCollection mongoCollection, Document condition, Document document){
        mongoCollection.updateMany(condition, document);
    }

    //编写findOne方法查询单个文档
    public static Document findOne(MongoCollection mongoCollection, Document document){
        return (Document) mongoCollection.find(document).first();
    }

    //编写findAll方法查询所有满足条件文档
    public static List<Document> findAllCondition(MongoCollection mongoCollection, Document document){
        List<Document> documents = new ArrayList<>();
        FindIterable findIterable = mongoCollection.find(document);
        for (Object  temp: findIterable) {
            documents.add((Document) temp);
        }
        return documents;
    }

    //编写findAll方法直接查询所有文档
    public static List<Document> findAll(MongoCollection mongoCollection){
        List<Document> documents = new ArrayList<>();
        FindIterable findIterable = mongoCollection.find();
        for (Object temp: findIterable) {
            documents.add((Document) temp);
        }
        return documents;
    }
}

4.1.2 MongoDBUtilTest.java

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.List;

class MongoDBUtilTest {

    @Test
    void getConnection() {
        System.out.println(MongoDBUtil.getConnection());
    }

    @Test
    void insertOne() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        Document mydocument = new Document("name", "赛文")
                                            .append("age","1024")
                                            .append("weight","6500");
        MongoDBUtil.insertOne(collection, mydocument);
    }

    @Test
    void insertMany() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        List<Document> documents = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            Document temp = new Document("number", i)
                                .append("age", i * 10);
            documents.add(temp);
        }
        MongoDBUtil.insertMany(collection, documents);
    }

    @Test
    void deleteOne() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        //删除条件，即document，有数据类型要求
        Document document = new Document("number", 3);
        MongoDBUtil.deleteOne(collection, document);
    }

    @Test
    void deleteMany() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        Document document = new Document("name", "赛文");
        MongoDBUtil.deleteMany(collection, document);
    }

    @Test
    void updateOne() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        //查询条件
        Document condition = new Document("number", 1);
        //拟更新数据
        Document document = new Document("$set", new Document("number", 0));
        MongoDBUtil.updateOne(collection, condition, document);
    }

    @Test
    void updateMany() {
        MongoClient  connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        //查询条件
        Document condition = new Document("number", 0);
        //拟更新数据
        Document document = new Document("$set", new Document("number", 2));
        MongoDBUtil.updateMany(collection, condition, document);
    }

    @Test
    void findOne() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        //查询条件
        Document document = new Document("number", 2);
        System.out.println(MongoDBUtil.findOne(collection, document));
    }

    @Test
    void findAllCondition() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        //查询条件
        Document document = new Document("number", 2);
        //获取查询结果列表
        List<Document> documentList = MongoDBUtil.findAllCondition(collection, document);
        System.out.println(documentList);
    }

    @Test
    void findAll() {
        MongoClient connection = MongoDBUtil.getConnection();
        MongoDatabase database = connection.getDatabase("test");
        MongoCollection<Document> collection = database.getCollection("student");
        List<Document> documentList = MongoDBUtil.findAll(collection);
        System.out.println(documentList);
    }
}

4.2 Python

4.2.1 MongoDBUtil.py

from pymongo import MongoClient
from pymongo.collection import Collection

#获取MongoDB连接
def  getConnection():
    # client = MongoClient()
    # client = MongoClient('localhost')
    client = MongoClient('localhost', 27017)
    return client

#创建inserOne方法，向数据库中添加一个文档
def  insertOne(collection:Collection, data):
    collection.insert_one(data)

#创建insertMany方法，向数据库中添加多个文档
def  insertMany(collection:Collection, data):
    collection.insert_many(data)

#创建deleteOne方法，删除数据库中满足条件的单个文档
def  deleteOne(collection:Collection, condition):
    collection.delete_one(condition)

#创建deleteMany方法，删除数据库中满足条件的多个文档
def  deleteMany(collection:Collection, condition):
    collection.delete_many(condition)

#创建updateOne方法，更新数据库中满足条件的单个文档
def  updateOne(collection:Collection, condition, data):
    collection.update_one(condition, data)

#创建updateMany方法，更新数据库中满足条件的多个文档
def  updateMany(collection:Collection, condition, data):
    collection.update_many(condition, data)

#创建findOne方法，查询数据库中满足条件的单个文档
def  findOne(collection:Collection, condition):
    return collection.find_one(condition)

#创建findAllCondition方法，查询数据库中满足条件的多个文档
def  findAllCondition(collection:Collection, condition):
    return collection.find(condition)

#创建findAll方法，查询数据库中所有文档
def  findAll(collection:Collection):
    return collection.find()

if __name__ == '__main__':
    pass

4.2.2 MongoDBUtilTest.py

import unittest
import MongoDBUtil


class MyTestCase(unittest.TestCase):
    def test_getConnection(self):
        connection = MongoDBUtil.getConnection()
        print(connection)

    #测试insertOne方法
    def test_insertOne(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        data = {
            "name":"张三",
            "age":18,
            "height":170
        }
        MongoDBUtil.insertOne(collection,data)

    #测试insertMany方法
    def test_insertMany(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        data = [
            {
                "name":"李四",
                "age":20,
                "height":180
            },
            {
                "name":"王五",
                "age":22,
                "height":190
            }
        ]
        MongoDBUtil.insertMany(collection, data)

    #测试试deleteOne方法
    def test_deleteOne(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        condition = {
            "name":"李四"
        }
        MongoDBUtil.deleteOne(collection, condition)

    #测试deleteMany方法
    def test_deleteMany(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        condition = {
            "name":"王五"
        }
        MongoDBUtil.deleteMany(collection, condition)

    #测试updateOne方法
    def test_updateOne(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        condition = {
            "name":"张三"
        }
        data = {
            "$set":
                {
                "age":20,
                "height":199
                }
        }
        MongoDBUtil.updateOne(collection, condition, data)

    #测试updateMany方法
    def test_updateMany(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        condition = {
            "age":20
        }
        data = {
            "$set":
                {
                "height":5000
                }
        }
        MongoDBUtil.updateMany(collection, condition, data)

    #测试findOne方法
    def test_findOne(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        condition = {
            "height":5000
        }
        result = MongoDBUtil.findOne(collection, condition)
        print(result)

    #测试findAllCondition方法
    def test_findAllCondition(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        condition = {
            "height":5000
        }
        result = MongoDBUtil.findAllCondition(collection, condition)
        for item in result:
            print(item)

    #测试findAll方法
    def test_findAll(self):
        connection = MongoDBUtil.getConnection()
        database = connection.test
        collection = database.person
        result = MongoDBUtil.findAll(collection)
        for item in result:
            print(item)

if __name__ == '__main__':
    unittest.main()

进击的墨菲特

关注

19
点赞
踩
25

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java和Python访问MongoDB + 增删改查操作全详细教程附jar包和程序代码

本文介绍使用Java和Python访问MongoDB的方法，并演示在eclipse、IDEA、PyCharm、jupyter四种主流IDE中的操作过程，实现对本地MongoDB数据库的增删改查操作，推荐在命令行配合查看数据操作的结果，以验证相应操作是否成功。
复制链接

扫一扫

Java和Python访问MongoDB + 增删改查操作 全详细教程 附jar包和程序代码

文章目录

前言

一、安装MongoDB驱动

1.1 IDEA环境—使用Maven依赖

1.2 eclipse环境—使用jar包

1.3 Pycharm环境—pip指令

1.4 Jupyter环境—pip或conda指令

二、通过Java访问MongoDB

2.1 连接MongoDB数据库

2.1.1 不需要验证

2.1.2 需要验证

2.2 添加文档

2.2.1 添加单个文档

2.2.2 添加多个文档

2.3 删除文档

2.3.1 删除单个文档

2.3.2 删除多个文档

2.4 修改文档

2.4.1 修改单个文档

2.4.2 修改多个文档

2.5 查询文档

2.5.1 查询单个文档

2.5.2 查询多个文档

2.5.3 查询全部文档

三、通过Python访问MongoDB

3.1 连接MongoDB数据库

3.2 添加文档

3.2.1 添加单个文档

3.2.2 添加多个文档

3.3 删除文档

3.3.1 删除单个文档

3.3.2 删除多个文档

3.4 修改文档

3.4.1 修改单个文档

3.4.2 更新多个文档

3.5 查询文档

3.5.1 查询单个文档

3.5.2 查询多个文档

3.5.3 查询所有文档

四、完整代码

4.1 Java

4.1.1 MongoDBUtil.java

4.1.2 MongoDBUtilTest.java

4.2 Python

4.2.1 MongoDBUtil.py

4.2.2 MongoDBUtilTest.py

Java和Python访问MongoDB + 增删改查操作全详细教程附jar包和程序代码