MongoDB - 集合和文档的增删改查操作

文章目录

    • [1. MongoDB 运行命令](#1. MongoDB 运行命令)
    • [2. MongoDB CRUD操作](#2. MongoDB CRUD操作)
      • [1. 新增文档](#1. 新增文档)
        • [1. 新增单个文档 insertOne](#1. 新增单个文档 insertOne)
        • [2. 批量新增文档 insertMany](#2. 批量新增文档 insertMany)
      • [2. 查询文档](#2. 查询文档)
        • [1. 查询所有文档](#1. 查询所有文档)
        • [2. 指定相等条件](#2. 指定相等条件)
        • [3. 使用查询操作符指定条件](#3. 使用查询操作符指定条件)
        • [4. 指定逻辑操作符 (`AND` / `OR`)](#4. 指定逻辑操作符 (AND / OR))
      • [3. 更新文档](#3. 更新文档)
        • [1. 更新操作符语法](#1. 更新操作符语法)
        • [2. 更新单个文档 updateOne](#2. 更新单个文档 updateOne)
        • [3. 批量更新文档 updateMany](#3. 批量更新文档 updateMany)
      • [4. 删除文档](#4. 删除文档)
        • [1. 删除单个文档 deleteOne](#1. 删除单个文档 deleteOne)
        • [2. 删除符合条件的所有文档 deleteMany](#2. 删除符合条件的所有文档 deleteMany)
        • [3. 删除所有文档 deleteMany](#3. 删除所有文档 deleteMany)

1. MongoDB 运行命令

① 列出用户可用的数据库:

mysql 复制代码
> show dbs
admin      0.000GB
config     0.000GB
knowledge  0.000GB
local      0.002GB
test       0.000GB

② 切换数据库:

> use test
switched to db test

③ 显示正在使用的数据库:

> db
test

④ 查看当前数据库下的所有集合:

> show collections
A
B

⑤ 创建集合:

> db.createCollection("t_incident")
{ "ok" : 1 }

如果集合不存在,MongoDB 会在您首次存储该集合的数据时创建该集合。

> db.myCollection.insertOne( { x: 1 } );
{
        "acknowledged" : true,
        "insertedId" : ObjectId("668bb336021f261e315be637")
}

2. MongoDB CRUD操作

SpringBoot集成MongoDB需要在项目中添加MongoDB的依赖。在pom.xml文件中添加以下依赖:

xml 复制代码
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

创建一个实体类来映射MongoDB中的文档:

java 复制代码
@AllArgsConstructor
@NoArgsConstructor
@Data
@Document(collection = "user")
public class User {
    @Id
    private String id;
    private String name;
    private Integer age;
    private String email;

    public User(String name,Integer age,String email){
        this.name = name;
        this.age = age;
        this.email = email;
    }
}

1. 新增文档

1. 新增单个文档 insertOne

insertOne 命令用于新增单个文档,语法如下:

db.collection.insertOne({ key1: value1, key2: value2, ... });

其中,db.collection 是要新增文档的集合名称,key1、key2等是文档中的字段名称,而value1、value2等是对应字段的值。如果文档未指定 _id 字段,MongoDB 会将具有 ObjectId 值的 _id 字段添加到新文档中。

mysql 复制代码
db.user.insertOne({ name: "Alice", age: 25, email: "alice@example.com" })

在代码中使用MongoTemplate来插入一条文档:

java 复制代码
@SpringBootTest
@RunWith(SpringRunner.class)
public class BeanLoadServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Test
    public void insertUser() {
        User user = new User();
        user.setName("Alice");
        user.setAge(25);
        user.setEmail("alice@example.com");
        // mongoTemplate.insertAll(users);
        mongoTemplate.insert(user);
    }
}
2. 批量新增文档 insertMany

insertMany 用于插入多个文档:

db.collection.insertMany([
  { key1: value1, key2: value2, ... },
  { key1: value3, key2: value4, ... },
  ...
]);

其中,db.collection是你要插入文档的集合名称。key1、key2等是文档中的字段名称,而value1、value2等是对应字段的值。

mysql 复制代码
db.user.insertMany([
  { name: "John", age: 30, email: "11@qq.com" },
  { name: "Jane", age: 25, email: "22@qq.com" },
  { name: "Mike", age: 35, email: "33@qq.com" }
]);
java 复制代码
@SpringBootTest
@RunWith(SpringRunner.class)
public class BeanLoadServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;
    
    @Test
    public void insertUser() {
        List<User> users = Arrays.asList(
                new User("John", 30, "11@qq.com"),
                new User("Jane", 25, "22@qq.com"),
                new User("Mike", 35, "33@qq.com")
        );
        mongoTemplate.insert(users,"user");
        // mongoTemplate.insertAll(users);
    }
}

2. 查询文档

查询筛选器文档指定条件,确定选择哪些记录进行读取、更新和删除操作。

可以使用 : 表达式指定相等条件和查询运算符表达式。

{
  <field1>: <value1>,
  <field2>: { <operator>: <value> },
  ...
}
1. 查询所有文档

要查询 MongoDB 集合中的所有文档,可以使用 find() 方法。

db.collectionName.find()

其中,collectionName 是你要查询的集合的名称。执行这个命令后,MongoDB 将返回集合中的所有文档。

如果你想要以更可读的方式显示结果,可以使用 pretty() 方法:

db.collectionName.find().pretty()

查询user集合中的所有文档:

mysql 复制代码
db.user.find()
java 复制代码
@Test
public void findUser() {
    Query query = new Query();
    List<User> users = mongoTemplate.find(query, User.class);
    // List<User> users = mongoTemplate.findAll(User.class,"user");
    users.forEach(System.out::println);
}
2. 指定相等条件

要选择匹配相等条件的文档,请在<field>:<value>中将条件指定为查询过滤器文档。

查询user集合中为"John"的所有文档:

db.user.find( { name: "John" } )
java 复制代码
@Test
public void findUser() {
    // 创建查询条件
    Criteria criteria = Criteria.where("name").is("John");
    // 创建查询对象
    Query query = new Query(criteria);
    // 执行查询
    List<User> users = mongoTemplate.find(query, User.class);
    users.forEach(System.out::println);
}

此操作对应于以下 SQL 语句:

SELECT * FROM user WHERE name = "John"

查询user集合中匹配查询条件name为"John"的第一个文档:

db.user.findOne( { "name": "John" } )
java 复制代码
@Test
public void findUser() {
    // 创建查询条件
    Criteria criteria = Criteria.where("name").is("John");
    // 创建查询对象
    Query query = new Query(criteria);
    // 执行查询
    User user = mongoTemplate.findOne(query, User.class);
    System.out.println(user);
}
3. 使用查询操作符指定条件

在查询过滤器文档中使用查询操作符来执行更复杂的比较和评估。

查询user集合中name为 "John"或者 "Alice" 的所有文档:

db.user.find( { name: { $in: [ "John", "Alice" ] } } )

注意,尽管您可以使用 $or 操作符来表示此查询,但在对同一字段执行相等检查时,请使用 $in 操作符而不是 $or 操作符。

此操作对应于以下 SQL 语句:

SELECT * FROM user WHERE name in ("John", "Alice" )
java 复制代码
@Test
public void findUser() {
    // 创建查询条件
    Criteria criteria = Criteria.where("name").in("John", "Alice");
    // 创建查询对象
    Query query = new Query(criteria);
    // 执行查询
    List<User> users = mongoTemplate.find(query, User.class, "user");
    users.forEach(System.out::println);
}

查询user集合中匹配查询条件name为 "John"或者 "Alice" 的第一个文档

db.user.findOne( { name: { $in: [ "John", "Alice" ] } } )
java 复制代码
@Test
public void findUser() {
    // 创建查询条件
    Criteria criteria = Criteria.where("name").in("John", "Alice");
    // 创建查询对象
    Query query = new Query(criteria);
    // 执行查询
    User user = mongoTemplate.findOne(query, User.class);
}
4. 指定逻辑操作符 (AND / OR)

复合查询可以为集合文档中的多个字段指定条件。

① 逻辑 AND 连接词隐式地连接复合查询的子句,以便该查询选择集合中与所有条件匹配的文档。

查询user集合中name为Alice且age>20的文档:

mysql 复制代码
db.user.find( { name: "Alice", "age": { $gte: 20 } } )
java 复制代码
@Test
public void findUser() {
    // 创建查询条件
    Criteria criteria = new Criteria();
    criteria.and("name").is("Alice");
    criteria.and("age").gte(20);
    // 创建查询对象
    Query query = new Query(criteria);
    // 执行查询
    List<User> users = mongoTemplate.find(query, User.class, "user");
}

② 使用 $or 操作符指定复合查询,该复合查询使用逻辑 OR 结合使用每个子句,以便查询选择集合中至少匹配一个条件的文档。

查询user集合中email为 "11@qq.com"且age>20或者name为"John"的文档:

mysql 复制代码
db.user.find( {
     email: "11@qq.com",
     $or: [ { "age": { $gte: 20 } }, { name: "John" } ]
} )
java 复制代码
@Test
public void findUser() {
    Query query = new Query();
    query.addCriteria(Criteria.where("email").is("11@qq.com")
            .orOperator(Criteria.where("age").gte(20), Criteria.where("name").is("John")));

    List<User> users = mongoTemplate.find(query, User.class);
    users.forEach(System.out::println);
}

3. 更新文档

1. 更新操作符语法

要更新文档,MongoDB 提供了更新操作符(例如$set )来修改字段值。要使用更新操作符,请向更新方法传递以下形式的更新文档:

mysql 复制代码
{
  <update operator>: { <field1>: <value1>, ... },
  <update operator>: { <field2>: <value2>, ... },
  ...
}

某些更新操作符(例如 $set)会在字段不存在的情况下创建字段。

2. 更新单个文档 updateOne

① 更新字段的值:更新user集合中与指定筛选器匹配的第一个文档,将name为"John"的age更新为22

mysql 复制代码
db.user.updateOne( 
    { name: "John" },
    {
      $set: {age: 22}
    }
)
java 复制代码
 @Test
public void updateUser(){
    // 查询对象
    Query query = new Query(Criteria.where("name").is("John"));
    // 更新对象
    Update update = new Update().set("age", 22);
    mongoTemplate.updateFirst(query, update, User.class);
}

② 新增字段:

mysql 复制代码
db.user.updateOne( 
    { name: "John" },
    {
      $set: {city: "ShangHai"}
    }
)
java 复制代码
@Test
public void updateUser(){
    // 查询对象
    Query query = new Query(Criteria.where("name").is("John"));
    // 更新对象
    Update update = new Update().set("city", "ShangHai");
    mongoTemplate.updateFirst(query, update, User.class);
}

③ 删除字段:

mysql 复制代码
db.user.updateOne( 
    { name: "John" },
    {
      $unset: {city: ""}
    }
)
java 复制代码
@Test
public void updateUser(){
    // 查询对象
    Query query = new Query(Criteria.where("name").is("John"));
    // 更新对象
    Update update = new Update().unset("city");
    mongoTemplate.updateFirst(query, update, User.class);
}
3. 批量更新文档 updateMany

updateMany 更新与指定过滤器匹配的所有文档。

更新user集合中 age小于等于25的所有文档,将email设置为"hh@qq.com",将age设置为28。

mysql 复制代码
db.user.updateMany(
  { age: { $lt: 25 } },
  {
    $set: { email: "hh.qq.com",age:28 }
  }
)
java 复制代码
@Test
public void updateUser(){
    // 构建查询条件
    Criteria criteria = Criteria.where("age").gte(25);
    Query query = Query.query(criteria);

    // 构建更新操作
    Update update = new Update();
    update.set("email", "hh.qq.com");
    update.set("age", 28);

    // 执行更新操作
    mongoTemplate.updateMulti(query, update, "user");
}

4. 删除文档

1. 删除单个文档 deleteOne

deleteOne 用于删除与指定过滤器匹配的单个文档。删除user集合中匹配name为"Alice"的第一个文档:

mysql 复制代码
db.user.deleteOne( { name: "Alice" } )
java 复制代码
@Test
public void deleteUser(){
    Query query = new Query();
    query.addCriteria(Criteria.where("name").is("Alice"));
    mongoTemplate.remove(query,User.class);
}
2. 删除符合条件的所有文档 deleteMany

您可以指定条件或过滤器来标识要删除的文档。过滤器使用与读取操作相同的语法。删除user集合age=28的所有文档:

db.user.deleteMany( { age:28 } )
3. 删除所有文档 deleteMany

要删除集合中的所有文档,将空的过滤器文档 {} 传递到 db.collection.deleteMany() 方法。

mysql 复制代码
db.user.deleteMany({})
相关推荐
tatasix14 分钟前
MySQL UPDATE语句执行链路解析
数据库·mysql
南城花随雪。27 分钟前
硬盘(HDD)与固态硬盘(SSD)详细解读
数据库
儿时可乖了28 分钟前
使用 Java 操作 SQLite 数据库
java·数据库·sqlite
懒是一种态度30 分钟前
Golang 调用 mongodb 的函数
数据库·mongodb·golang
天海华兮32 分钟前
mysql 去重 补全 取出重复 变量 函数 和存储过程
数据库·mysql
gma9991 小时前
Etcd 框架
数据库·etcd
爱吃青椒不爱吃西红柿‍️1 小时前
华为ASP与CSP是什么?
服务器·前端·数据库
Yz98762 小时前
hive的存储格式
大数据·数据库·数据仓库·hive·hadoop·数据库开发
苏-言2 小时前
Spring IOC实战指南:从零到一的构建过程
java·数据库·spring
Ljw...2 小时前
索引(MySQL)
数据库·mysql·索引