Springboot MongoDB CRUD（二）

作者: 许俊贤 | 来源:发表于2021-07-21 19:12 被阅读0次

该文章为 MongoTemplate 方式，基于 JPA(Repositories) 可见文章 Springboot MongoDB CRUD（一）

概述

MongoDB 描述等可见其他文章, 本文章主要基于 springboot 项目演示

版本信息：

Java JDK 版本：1.8
SpringBoot 版本：2.4.5.RELEASE
MongoDB 版本：community-4.4

参考地址：

示例项目地址：

SpringBoot 集成 MongoDB 示例项目 Github 地址

前置条件

以下例子需先创建库，故先手动创建好，可通过脚本或者客户端，自行选择。

# 切换到 test
use test

# 创建 est 授权 读&写&管理权限
db.createUser( {user: "test",pwd: "123456",roles: [ { role: "readWrite", db: "test" },{ role: "dbAdmin", db: "test" }]});

项目实战

SpringBoot 操作主要有两种方式，一种基于 JPA(Repositories)、一种基于MongoDB 官方 Java 驱动 MongoTemplate，直接用代码说话吧。（该文章为 MongoTemplate 方式）

项目构建等忽略， gradle 构建，配置文件:

plugins {
    id 'org.springframework.boot' version '2.4.5'
    id 'io.spring.dependency-management' version '1.0.11.RELEASE'
    id 'java'
}

group = 'com.xjxxxc.mongodb.demo'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
}

repositories {
    mavenLocal()
    maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-data-mongodb'
    implementation 'com.google.guava:guava:30.1.1-jre'
    implementation 'org.apache.commons:commons-lang3'
    implementation 'com.alibaba:fastjson:1.2.76'

    compileOnly 'org.projectlombok:lombok'
    developmentOnly 'org.springframework.boot:spring-boot-devtools'
    annotationProcessor 'org.springframework.boot:spring-boot-configuration-processor'
    annotationProcessor 'org.projectlombok:lombok'

    testAnnotationProcessor 'org.projectlombok:lombok:1.18.20'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    implementation 'org.projectlombok:lombok'
}

test {
    useJUnitPlatform()
}

包说明：

├── com
│   └── xjxxxc
│       └── mongodb
│           └── demo
│               ├── MongodbDemoApplication.java # 启动类
│               ├── config # 配置类，如数据源
│               ├── listener # 监听器，如 MongoEvent
│               ├── model # 模型
│               │   └── entity # 实体，JPA 使用
│               ├── repository # JPA repository
│               ├── service # *服务层，提供 MongoDB 特性。
│               └── template # MongoDB 模板类使用 DEMO

项目基本配置

application.properties

server.port=8866
spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=test
spring.data.mongodb.username=test
spring.data.mongodb.password=123456

根据情况修改即可，为了演示方便直接写在 application.properties

MongoDBDataSourceConfig

继承 AbstractMongoClientConfiguration 类，重写 mongoClient() 、getDatabaseName() 、mappingMongoConverter() 方法，并且去除 _class 字段。

@Configuration
@EnableMongoRepositories(basePackages = {"com.xjxxxc.mongodb.demo.*"})
public class MongoDBDataSourceConfig extends AbstractMongoClientConfiguration {
    @Value(value = "${spring.data.mongodb.host:127.0.0.1}")
    private String host;

    @Value(value = "${spring.data.mongodb.port:27017}")
    private Integer port;

    @Value(value = "${spring.data.mongodb.database:test}")
    private String database;

    @Value(value = "${spring.data.mongodb.username:test}")
    private String username;

    @Value(value = "${spring.data.mongodb.password:123456}")
    private String password;

    @Override
    public MongoClient mongoClient() {
        MongoClient mongoClient = MongoClients.create(
                MongoClientSettings.builder()
                        // 集群设置
                        .applyToClusterSettings(builder ->
                                builder.hosts(Arrays.asList(new ServerAddress(host, port))))
                        // 凭据
                        .credential(
                                MongoCredential
                                        .createCredential(username, database, password.toCharArray()))
                        .build());
        return mongoClient;
    }


    /**
     * Return the name of the database to connect to.
     *
     * @return must not be {@literal null}.
     */
    @Override
    protected String getDatabaseName() {
        return database;
    }

    /**
     * 去除 _class
     * @param databaseFactory
     * @param customConversions
     * @param mappingContext
     * @return MappingMongoConverter
     */
    @Override
    public MappingMongoConverter mappingMongoConverter(MongoDatabaseFactory databaseFactory, MongoCustomConversions customConversions, MongoMappingContext mappingContext) {

        DbRefResolver dbRefResolver = new DefaultDbRefResolver(mongoDbFactory());
        MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, mappingContext);
        converter.setCustomConversions(customConversions());
        converter.setCodecRegistryProvider(mongoDbFactory());
        // Don't save _class to mongo
        converter.setTypeMapper(new DefaultMongoTypeMapper(null));

        return converter;
    }


}

MongoTemplate

这里使用 Spring Data MongoDB 封装的 MongoDB 官方 Java 驱动 MongoTemplate 对 MongoDB 进行操作。

MongoTemplateDemo

基于 MongoTemplate, 实现 CURD 外增加了复杂查询、排序、过滤、分页以及查询、创建索引等方法。

public class MongoTemplateDemo {
    public static final String INDEX_PREFIX = "idx_";

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 插入一条数据
     *
     * @param collectionName 集合名称
     * @param document       文档
     */
    public void insertOne(String collectionName, Document document) {
        mongoTemplate.getCollection(collectionName).insertOne(document);
    }

    /**
     * 批量插入数据
     *
     * @param collectionName 集合名称
     * @param documents      文档
     */
    public void insertMany(String collectionName, List<Document> documents) {
        mongoTemplate.getCollection(collectionName).insertMany(documents);
    }

    /**
     * 根据条件分页查询所有符合条件的结果,并指定返回字段
     *
     * @param collectionName 集合名称
     * @param query          过滤条件
     * @param projection     查询字段
     * @param sort           排序条件
     * @param skip           起始值
     * @param limit          限定数量
     * @return FindIterable<Document>
     */
    public FindIterable<Document> find(String collectionName, Document query, Document projection, Bson sort, int skip, int limit) {
        return mongoTemplate.getCollection(collectionName).find(query).projection(projection).sort(sort).skip(skip).limit(limit);
    }

    /**
     * 根据条件查询所有符合条件的结果,并指定返回字段
     *
     * @param collectionName 集合名称
     * @param query          过滤条件
     * @param projection     查询字段
     * @param sort           排序条件
     * @return FindIterable<Document>
     */
    public FindIterable<Document> find(String collectionName, Document query, Document projection, Document sort) {
        return mongoTemplate.getCollection(collectionName).find(query).projection(projection).sort(sort);
    }

    /**
     * 根据条件查询所有符合条件的结果,并指定返回字段
     *
     * @param collectionName 集合名称
     * @param query          过滤条件
     * @param projection     查询字段
     * @return FindIterable<Document>
     */
    public FindIterable<Document> find(String collectionName, Document query, Document projection) {
        return mongoTemplate.getCollection(collectionName).find(query).projection(projection);
    }

    /**
     * 根据条件查询所有符合条件的结果
     *
     * @param collectionName 集合名称
     * @param query          过滤条件
     * @return FindIterable<Document>
     */
    public FindIterable<Document> find(String collectionName, Document query) {
        return this.find(collectionName, query, null);
    }

    /**
     * 查询一个
     *
     * @param collectionName 集合名称
     * @param query          过滤条件
     * @return Document
     */
    public Document findOne(String collectionName, Document query) {
        FindIterable<Document> iterable = this.find(collectionName, query);
        MongoCursor<Document> mongoCursor = iterable.iterator();
        while (mongoCursor.hasNext()) {
            return mongoCursor.next();
        }
        return new Document();
    }


    /**
     * 分页查询
     *
     * @param collectionName 集合名称
     * @param query          过滤条件
     * @param skip           起始值
     * @param limit          限制条数
     * @return FindIterable
     */
    public FindIterable findPage(String collectionName, Document query, int skip, int limit) {
        return mongoTemplate.getCollection(collectionName).find(query).skip(skip).limit(limit);
    }

    /**
     * 查询条数
     *
     * @param collectionName
     * @param query
     * @return long
     */
    public long count(String collectionName, Document query) {
        return mongoTemplate.getCollection(collectionName).countDocuments(query);
    }

    /**
     * 删除一条
     *
     * @param collectionName
     * @param query
     * @return DeleteResult
     */
    public DeleteResult removeOne(String collectionName, Document query) {
        return mongoTemplate.getCollection(collectionName).deleteOne(query);
    }

    /**
     * 删除多条
     *
     * @param collectionName
     * @param query
     * @return DeleteResult
     */
    public DeleteResult removeMany(String collectionName, Document query) {
        return mongoTemplate.getCollection(collectionName).deleteMany(query);
    }


    /**
     * 修改一条
     *
     * @param collectionName
     * @param query
     * @param update
     * @return UpdateResult
     */
    public UpdateResult updateOne(String collectionName, Document query, Document update) {
        return mongoTemplate.getCollection(collectionName).updateOne(query, update);
    }

    /**
     * 修改多条
     *
     * @param collectionName
     * @param query
     * @param update
     * @return UpdateResult
     */
    public UpdateResult updateMany(String collectionName, Document query, Document update) {
        return mongoTemplate.getCollection(collectionName).updateMany(query, update);
    }

    /**
     * 替换 整个文档
     *
     * @param collectionName
     * @param query
     * @param update
     * @return UpdateResult
     */
    public UpdateResult replaceOne(String collectionName, Document query, Document update) {
        return mongoTemplate.getCollection(collectionName).replaceOne(query, update);
    }

    /**
     * 获取当前集合对应的所有索引的名称
     *
     * @param collectionName
     * @return List<String>
     */
    public List<String> getAllIndexes(String collectionName) {
        ListIndexesIterable<Document> list = mongoTemplate.getCollection(collectionName).listIndexes();
        //上面的list不能直接获取size，因此初始化arrayList就不设置初始化大小了
        List<String> indexes = new ArrayList<>();
        for (Document document : list) {
            document.entrySet().forEach((key) -> {
                //提取出索引的名称
                if (key.getKey().equals("name")) {
                    indexes.add(key.getValue().toString());
                }
            });
        }
        return indexes;
    }

    /**
     * 创建索引
     *
     * @param collectionName
     * @param filedName      [默认升序索引]
     * @return String 索引名
     */
    public String createIndex(String collectionName, String filedName) {
        // TODO：检查是否已经有索引 getAllIndexes
        //该参数为索引的属性配置
        IndexOptions indexOptions = new IndexOptions();
        // 后台进行索引的创建
        indexOptions.background(true);
        indexOptions.name(INDEX_PREFIX + filedName);

        return mongoTemplate.getCollection(collectionName).createIndex(Indexes.ascending(filedName), indexOptions);
    }

    /**
     * 创建复合索引
     *
     * @param collectionName
     * @param filedNames     [默认升序索引]
     * @return String 索引名
     */
    public String createIndex(String collectionName, List<String> filedNames) {
        // TODO：检查是否已经有索引 getAllIndexes
        //该参数为索引的属性配置
        IndexOptions indexOptions = new IndexOptions();
        // 后台进行索引的创建
        indexOptions.background(true);
        indexOptions.name(INDEX_PREFIX + filedNames.stream().collect(Collectors.joining("_")));

        return mongoTemplate.getCollection(collectionName).createIndex(Indexes.ascending(filedNames), indexOptions);
    }

}

MongoTemplateDemoTest

单元测试类，用来测试 MongoTemplateDemo 的方法。
大致描述下测试的方法

insertOneTest 插入一条数据

库中可查到数据:

{
    "_id": "1234567890",
    "name": "jason",
    "age": NumberInt("25"),
    "sex": "男"
}

insertManyTest

库中可查到数据:

{
    "_id": "1234567891",
    "name": "jason",
    "age": NumberInt("25"),
    "sex": "男"
}

{
    "_id": "1234567892",
    "name": "花花",
    "age": NumberInt("22"),
    "sex": "女"
}

findTestTest

控制台数据输出 _id = 1234567890 的文档。
Document{{_id=1234567890, name=jason, age=25, sex=男}}

findBySexTestTest

控制台数据输出 sex = 男的文档。
Document{{_id=1234567890, name=jason, age=25, sex=男}}
Document{{_id=1234567891, name=jason, age=25, sex=男}}

findManyWithFieldTest

控制台数据输出 sex = 男的文档。[仅显示 age 字段]
Document{{age=25}}
Document{{age=25}}

findManyWithPageTest

控制台数据输出前 5 条数据[示例只有 3 条]，可结合批量生成测试数据的方法测试。
Document{{_id=1234567890, name=jason, age=25, sex=男}}
Document{{_id=1234567891, name=jason, age=25, sex=男}}
Document{{_id=1234567892, name=花花, age=22, sex=女}}

findManyWithInTest

控制台数据输出 _id in(1234567890, 1234567891,1234567892) 的文档(案例中所有数据)。
Document{{_id=1234567890, name=jason, age=25, sex=男}}
Document{{_id=1234567891, name=jason, age=25, sex=男}}
Document{{_id=1234567892, name=花花, age=22, sex=女}}

findManyWithOrTest

控制台数据输出 sex = 男 or age = 22 的文档(案例中所有数据)。
Document{{_id=1234567890, name=jason, age=25, sex=男}}
Document{{_id=1234567891, name=jason, age=25, sex=男}}
Document{{_id=1234567892, name=花花, age=22, sex=女}}

findManyWithGtTest

控制台数据输出 age > 21 and age < 24 的文档。
Document{{_id=1234567892, name=花花, age=22, sex=女}}

findManyWithPatternTest

控制台数据输出 name like '%花%'' 的文档。
Document{{_id=1234567892, name=花花, age=22, sex=女}}

countTest

控制台数据输出 sex = 男的合计。
输出 2

updateOneTest

修改 _id = 1234567891 的 age = 1
修改前数据：

{
    "_id": "1234567891",
    "name": "jason",
    "age": NumberInt("25"),
    "sex": "男"
}

修改后数据：

{
    "_id": "1234567891",
    "name": "jason",
    "age": NumberInt("1"),
    "sex": "男"
}

updateManyTest

修改 name = jason 的 age = 26
修改前数据：

{
    "_id": "1234567890",
    "name": "jason",
    "age": NumberInt("25"),
    "sex": "男"
}

{
    "_id": "1234567891",
    "name": "jason",
    "age": NumberInt("1"),
    "sex": "男"
}

修改后数据：

{
    "_id": "1234567890",
    "name": "jason",
    "age": NumberInt("26"),
    "sex": "男"
}

{
    "_id": "1234567891",
    "name": "jason",
    "age": NumberInt("26"),
    "sex": "男"
}

updateOneInObjectTest

修改 _id = 1234567892 的数据，$set university 的键值。
修改前数据：

{
    "_id": "1234567892",
    "name": "花花",
    "age": NumberInt("22"),
    "sex": "女"
}

修改后数据：

{
    "_id": "1234567892",
    "name": "花花",
    "age": NumberInt("22"),
    "sex": "女",
    "university": {
        "name": "SZU",
        "address": "SZ"
    }
}

updateOnePushListTest

修改 name = BAT 的数据，插入 workExperience 的文档。
修改前数据：

{
    "_id": "1234567892",
    "name": "花花",
    "age": NumberInt("22"),
    "sex": "女",
    "university": {
        "name": "SZU",
        "address": "SZ"
    }
}

修改后数据：

{
    "_id": "1234567892",
    "name": "花花",
    "age": NumberInt("22"),
    "sex": "女",
    "university": {
        "name": "SZU",
        "address": "SZ"
    },
    "workExperience": [
        {
            "startDate": "2013-09",
            "endDate": "2017-09",
            "address": "SZ",
            "name": "BAT"
        }
    ]
}

updateOneInListTest

修改 workExperience.name = BAT 的 workExperience.$.address = SZ.NS 。[案例只有一条]
修改前数据：

{
    "_id": "1234567892",
    "name": "花花",
    "age": NumberInt("22"),
    "sex": "女",
    "university": {
        "name": "SZU",
        "address": "SZ"
    },
    "workExperience": [
        {
            "startDate": "2013-09",
            "endDate": "2017-09",
            "address": "SZ",
            "name": "BAT"
        }
    ]
}

修改后数据：

{
    "_id": "1234567892",
    "name": "花花",
    "age": NumberInt("22"),
    "sex": "女",
    "university": {
        "name": "SZU",
        "address": "SZ"
    },
    "workExperience": [
        {
            "startDate": "2013-09",
            "endDate": "2017-09",
            "address": "SZ.NS",
            "name": "BAT"
        }
    ]
}

replaceOne

替换 _id = 1234567891 的文档数据。
修改前数据：

{
    "_id": "1234567891",
    "name": "jason",
    "age": NumberInt("26"),
    "sex": "男"
}

修改后数据：

{
    "_id": "1234567891",
    "name": "replace name",
    "age": NumberInt("22"),
    "sex": "女"
}

removeOne

删除 _id = 1234567890 的文档数据。
修改前数据：

{
    "_id": "1234567890",
    "name": "jason",
    "age": NumberInt("26"),
    "sex": "男"
}

修改后数据：

// 空文档
{
}

removeMany

删除 _id in (1234567891,1234567892) 的文档数据。
修改前数据：

{
    "_id": "1234567891",
    "name": "replace name",
    "age": NumberInt("22"),
    "sex": "女"
}

{
    "_id": "1234567892",
    "name": "花花",
    "age": NumberInt("22"),
    "sex": "女",
    "university": {
        "name": "SZU",
        "address": "SZ"
    },
    "workExperience": [
        {
            "startDate": "2013-09",
            "endDate": "2017-09",
            "address": "SZ.NS",
            "name": "BAT"
        }
    ]
}

修改后数据：

// 空文档
{
}

代码

class MongoTemplateDemoTest {

    @Autowired
    private MongoTemplateDemo mongoTemplateDemo;

    // test_template
    private String collectionName = "test_template";

    /**
     * 插入一条数据
     */
    @Test
    void insertOneTest() {
        Document document = new Document();
        document.put("_id", "1234567890");
        document.put("name", "jason");
        document.put("age", 25);
        document.put("sex", "男");
        mongoTemplateDemo.insertOne(collectionName, document);
    }

    /**
     * 插入多条数据
     */
    @Test
    void insertManyTest() {
        Document document = new Document();
        document.put("_id", "1234567891");
        document.put("name", "jason");
        document.put("age", 25);
        document.put("sex", "男");
        Document document2 = new Document();
        document2.put("_id", "1234567892");
        document2.put("name", "花花");
        document2.put("age", 22);
        document2.put("sex", "女");
        List<Document> list = new ArrayList<>();
        list.add(document);
        list.add(document2);
        mongoTemplateDemo.insertMany(collectionName, list);

    }

    /**
     * 查询符合条件的一条数据
     */
    @Test
    void findTest() {
        Document document = new Document();
        document.put("_id", "1234567890");
        //document.put("name","花花");
        FindIterable<Document> iterable = mongoTemplateDemo.find(collectionName, document);
        MongoCursor<Document> mongoCursor = iterable.iterator();
        while (mongoCursor.hasNext()) {
            Document result = mongoCursor.next();
            System.out.println(result);
            //System.out.println(result.toJson());
        }
    }

    /**
     * 查询符合条件的多条数据
     */
    @Test
    void findBySexTest() {

        Document document = new Document();
        document.put("sex", "男");
        FindIterable<Document> iterable = mongoTemplateDemo.find(collectionName, document);
        MongoCursor<Document> mongoCursor = iterable.iterator();
        while (mongoCursor.hasNext()) {
            Document result = mongoCursor.next();
            System.out.println(result);
        }
    }

    /**
     * 查询符合条件的数据，指定返回字段
     */
    @Test
    public void findManyWithFieldTest() {
        Document document = new Document();
        document.put("sex", "男");
        Document fieldDocument = new Document();
        fieldDocument.put("_id", false);
        fieldDocument.put("age", true);
        FindIterable<Document> iterable = mongoTemplateDemo.find(collectionName, document, fieldDocument);
        MongoCursor<Document> mongoCursor = iterable.iterator();
        while (mongoCursor.hasNext()) {
            Document result = mongoCursor.next();
            System.out.println(result);
        }
    }

    /**
     * 查询多条数据，分页
     */
    @Test
    public void findManyWithPageTest() {
        Document document = new Document();
        FindIterable<Document> iterable = mongoTemplateDemo.findPage(collectionName, document, 0, 5);
        MongoCursor<Document> mongoCursor = iterable.iterator();
        while (mongoCursor.hasNext()) {
            Document result = mongoCursor.next();
            System.out.println(result);
        }
    }

    /**
     * $in 查询
     * 反向 $nin
     */
    @Test
    public void findManyWithInIdTest() {
        Document document = new Document();
        document.put("_id", new Document().append("$in", Arrays.asList("1234567890", "1234567891", "1234567892")));
        FindIterable<Document> iterable = mongoTemplateDemo.find(collectionName, document);
        MongoCursor<Document> mongoCursor = iterable.iterator();
        while (mongoCursor.hasNext()) {
            Document result = mongoCursor.next();
            System.out.println(result);
        }
    }

    /**
     * or 查询
     */
    @Test
    public void findManyWithOrTest() {
        Document document1 = new Document();//条件1
        document1.put("sex", "男");
        Document document2 = new Document();//条件2
        document2.put("age", 22);
        Document dbObject = new Document();
        dbObject.put("$or", Arrays.asList(document1, document2));//组合
        FindIterable iterable = mongoTemplateDemo.find(collectionName, dbObject);
        MongoCursor<Document> mongoCursor = iterable.iterator();
        while (mongoCursor.hasNext()) {
            Document result = mongoCursor.next();
            System.out.println(result);
        }
    }

    /**
     * $gt:大于
     * $lt:小于
     * $gte:大于等于
     * $lte:小于等于
     * $ne:不等于
     */
    @Test
    public void findManyWithGtTest() {
        Document document = new Document();
        //document.put("age" , new Document().append("$gt",21));
        document.put("age", new Document().append("$gt", 21).append("$lt", 24));
        FindIterable iterable = mongoTemplateDemo.find(collectionName, document);
        MongoCursor<Document> mongoCursor = iterable.iterator();
        while (mongoCursor.hasNext()) {
            Document result = mongoCursor.next();
            System.out.println(result);
        }
    }


    /**
     * 模糊查询
     * mongodb用的是正则表达式来进行模糊查询的
     * <p>
     * Spring中不区分大小写的模糊查询：
     * //完全匹配
     * Pattern pattern = Pattern.compile("^花$", Pattern.CASE_INSENSITIVE);
     * //右匹配
     * Pattern pattern = Pattern.compile("^.*花$", Pattern.CASE_INSENSITIVE);
     * //左匹配
     * Pattern pattern = Pattern.compile("^花.*$", Pattern.CASE_INSENSITIVE);
     * //模糊匹配
     * Pattern pattern = Pattern.compile("^.*花.*$", Pattern.CASE_INSENSITIVE);
     */
    @Test
    public void findManyWithPatternTest() {
        String name = "花";
        Pattern pattern = Pattern.compile("^.*" + name + ".*$", Pattern.CASE_INSENSITIVE);
        Document document = new Document();
        document.put("name", pattern);
        FindIterable iterable = mongoTemplateDemo.find(collectionName, document);
        MongoCursor<Document> mongoCursor = iterable.iterator();
        while (mongoCursor.hasNext()) {
            Document result = mongoCursor.next();
            System.out.println(result);
        }
    }

    /**
     * 统计条数
     */
    @Test
    void countTest() {
        Document document = new Document();
        document.put("sex", "男");
        long count = mongoTemplateDemo.count(collectionName, document);
        System.out.println(count);
    }

    /**
     * 更新一条数据
     */
    @Test
    void updateOneTest() {
        Document document = new Document();
        document.put("_id", "1234567891");
        Document updateDocument = new Document();
        updateDocument.put("age", 1);
        Document setDocument = new Document();
        setDocument.put("$set", updateDocument);
        mongoTemplateDemo.updateOne(collectionName, document, setDocument);
    }

    /**
     * 更新多条数据
     */
    @Test
    void updateManyTest() {
        Document document = new Document();
        document.put("name", "jason");
        Document updateDocument = new Document();
        updateDocument.put("age", 26);
        Document setDocument = new Document();
        setDocument.put("$set", updateDocument);
        mongoTemplateDemo.updateMany(collectionName, document, setDocument);
    }

    /**
     * 修改一条数据 修改文档中的对象
     */
    @Test
    public void updateOneInObjectTest() {
        Document document = new Document();
        document.put("_id", "1234567892");
        Document updateDocument = new Document();
        updateDocument.put("name", "SZU");
        updateDocument.put("address", "SZ");
        Document setDocument = new Document();
        setDocument.put("$set", new Document().append("university", updateDocument));
        mongoTemplateDemo.updateOne(collectionName, document, setDocument);
    }

    /**
     * 向数组中添加一个对象
     * 也是更新文档的内容 所以算update
     */
    @Test
    public void updateOnePushListTest() {
        Document document = new Document();
        document.put("_id", "1234567892");//查询条件

        Document pushDocument = new Document();//要插入的内容
        pushDocument.put("startDate", "2013-09");
        pushDocument.put("endDate", "2017-09");
        pushDocument.put("address", "SZ");
        pushDocument.put("name", "BAT");

        Document updateDocument = new Document();//要插入哪个list
        updateDocument.put("workExperience", pushDocument);

        Document setDocument = new Document();
        setDocument.put("$push", updateDocument);//操作

        mongoTemplateDemo.updateOne(collectionName, document, setDocument);
    }

    /**
     * 修改一条数据 修改文档数组中的对象
     */
    @Test
    public void updateOneInListTest() {
        Document document = new Document();
        //document.put("_id", "1234567892");

        Document elemMatchDocument = new Document();
        elemMatchDocument.put("name", "BAT");
        document.put("workExperience", new Document().append("$elemMatch", elemMatchDocument));
        //Document result=documentQueryDao.findOne(document); 查询符合条件的数组
        //以上为查询条件
        Document updateDocument = new Document();
        updateDocument.put("workExperience.$.address", "SZ.NS");
        Document setDocument = new Document();
        setDocument.put("$set", updateDocument);
        mongoTemplateDemo.updateOne(collectionName, document, setDocument);
    }


    /**
     * replace 替换：
     * 把符合条件的document换成replaceDocument
     * 不管以前document以前的内容是什么，
     * 替换之后
     * replaceDocument是什么 数据库里面就是什么。
     * 这样理解：就是把符合条件的document删除，插入replaceDocument。
     */
    @Test
    void replaceOne() {
        Document document = new Document();
        document.put("_id", "1234567891");
        Document replaceDocument = new Document();
        replaceDocument.put("name", "replace name");
        replaceDocument.put("age", 22);
        replaceDocument.put("sex", "女");
        mongoTemplateDemo.replaceOne(collectionName, document, replaceDocument);
    }


    /**
     * 删除一条数据
     */
    @Test
    void removeOne() {
        Document document = new Document();
        document.put("_id", "1234567890");
        mongoTemplateDemo.removeOne(collectionName, document);
    }

    /**
     * 删除多条数据
     */
    @Test
    void removeMany() {
        Document document = new Document();
        document.put("_id", new Document().append("$in", Arrays.asList("1234567891", "1234567892")));
        mongoTemplateDemo.removeMany(collectionName, document);
    }
}

下偏文章将继续封装演示一些高级的功能

备注：个人博客同步至简书。

Springboot MongoDB CRUD（二）

概述

前置条件

项目实战

项目基本配置

application.properties

MongoDBDataSourceConfig

MongoTemplate

MongoTemplateDemo

MongoTemplateDemoTest

insertOneTest 插入一条数据

insertManyTest

findTestTest

findBySexTestTest

findManyWithFieldTest

findManyWithPageTest

findManyWithInTest

findManyWithOrTest

findManyWithGtTest

findManyWithPatternTest

countTest

updateOneTest

updateManyTest

updateOneInObjectTest

updateOnePushListTest

updateOneInListTest

replaceOne

removeOne

removeMany

代码

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读