SpringBoot 整合 MongoDB 实战解说

2023年6月9日下午9:10 • Java • 阅读 92

在前面的文章中，我们详细的介绍了 MongoDB 的配置和使用，如果你对 MongoDB 还不是很了解，也没关系，在 MongoDB 中有三个比较重要的名词： 数据库、集合、文档！

数据库（Database）：和关系型数据库一样，每个数据库中有自己的用户权限，不同的项目组可以使用不同的数据库
集合（Collection）：集合指的是文档组（类似于 Mysql 中的表的概念），里面可以存储许多文档
文档（Document）：文档是 MongoDB 中最基本的数据单元，由键值对组成，类似于 JSON 格式，可以存储不同字段，字段的值可以包括其他文档、数组和文档数组

搞懂这三个名词，基本就可以上手了，今天我们以 Java 语言为例，详细的介绍 Java 客户端改如何操作 MongoDB ！

话不多说，直接开撸！

Java 连接 MongoDB 服务器，与我们常用的连接关系型数据库方式类似！

标准 URI 连接语法：

mongodb://username:password@host1:port1,host2:port2,...,hostN:portN/database?options

参数说明：

mongodb://：这是固定的格式，必须要指定
username:password@：可选项，如果设置，在连接数据库服务器之后，驱动都会尝试登录这个数据库
host1:port1：主机IP和端口号，必须指定至少一个host。如果要连接复制集，请指定多个主机地址
/database：如果指定了 username:password@，连接时会验证并登录指定数据库。若不指定，默认打开 test 数据库
?options：连接可选项，例如 connectTimeoutMS=5000ms，表示连接等待时间最长 5 秒

例如，无密码连接 MongoDB

mongodb://127.0.0.1:27017

使用用户名 test，密码 test登录 MongoDB 的 test_db数据库

mongodb://test:test@127.0.0.1:27017/test_db

无密码连接指定三台服务器 (端口 27017, 27018, 和27019)

mongodb://127.0.0.1:27017,127.0.0.1:27018,127.0.0.1:27019

和关系型数据库操作一样，在 Java 程序中如果要使用 MongoDB，先要添加对应的 MongoDB JDBC 驱动器，然后才能继续操作！


    org.mongodb
    mongo-java-driver
    3.12.7

连接数据库的 Java 代码如下：

private static MongoClient mongoClient;

static {
    try {
        //连接到MongoDB服务 如果是远程连接可以替换"localhost"为服务器所在IP地址
        mongoClient = MongoClients.create("mongodb://test:test@127.0.0.1:27017/test_db");
        System.out.println("Connect to database successfully");
    } catch (Exception e) {
        System.err.println( e.getClass().getName() + ": " + e.getMessage() );
    }
}

上文中采用的是用户名和密码方式登录数据库，因为数据库已经开启了权限验证，因此需要通过用户名和密码才能登录。

com.mongodb.client包里面都帮我们集成好了大部分常用的 api，我们可以通过 MongoDatabase类中的 createCollection()方法来创建集合。

创建一个 tb_role集合，代码片段如下：

/**
 * &#x521B;&#x5EFA;&#x96C6;&#x5408;
 * @param args
 */
public static void main(String[] args) {
    // &#x8FDE;&#x63A5;&#x5230;&#x6570;&#x636E;&#x5E93;
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    mongoDatabase.createCollection("tb_role");
    System.out.println("&#x96C6;&#x5408;&#x521B;&#x5EFA;&#x6210;&#x529F;");
}

如果想删除集合，操作也很简单！

/**
 * &#x5220;&#x9664;&#x96C6;&#x5408;
 * @param args
 */
public static void main(String[] args) {
    // &#x8FDE;&#x63A5;&#x5230;&#x6570;&#x636E;&#x5E93;
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    mongoDatabase.getCollection("tb_role").drop();
    System.out.println("&#x96C6;&#x5408; tb_role &#x5220;&#x9664;&#x6210;&#x529F;");
}

我们可以通过 MongoCollection类中的 insertMany()方法来插入一个文档。

向 tb_role集合中插入文档，代码片段如下：

/**
 * 插入文档
 * @param args
 */
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    //获取集合
    MongoCollection collection = mongoDatabase.getCollection("tb_role");

    //向集合中插入文档
    Document document = new Document("name", "管理员").

            append("code", "manager").

            append("sort", 100);
    List documents = new ArrayList<>();
    documents.add(document);
    collection.insertMany(documents);
    System.out.println("文档插入成功");
}

我们可以通过 MongoCollection类中的 updateMany()方法来更新集合中的文档。

更新 tb_role集合中的指定文档信息，代码片段如下：

/**
 * 更新文档
 * @param args
 */
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    //获取集合
    MongoCollection collection = mongoDatabase.getCollection("tb_role");

    //更新文档
    collection.updateMany(Filters.eq("code", "manager"), new Document("$set",new Document("name","经理")));

    //遍历所有文档
    FindIterable findIterable = collection.find();
    MongoCursor mongoCursor = findIterable.iterator();
    while(mongoCursor.hasNext()){
        System.out.println(mongoCursor.next());
    }
}

上文操作类似于 SQL语句中的 update tb_role set name = '经理' where code = 'manager'！

我们可以通过 MongoCollection类中的 deleteOne()或者 deleteMany方法来删除集合中的文档。

删除 tb_role集合中的指定文档信息，代码片段如下：

/**
 * 删除文档
 * @param args
 */
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    //获取集合
    MongoCollection collection = mongoDatabase.getCollection("tb_role");

    //删除符合条件的第一个文档
    collection.deleteOne(Filters.eq("code", "manager"));
    //删除所有符合条件的文档
    collection.deleteMany (Filters.eq("code", "manager"));

    //遍历所有文档
    FindIterable findIterable = collection.find();
    MongoCursor mongoCursor = findIterable.iterator();
    while(mongoCursor.hasNext()){
        System.out.println(mongoCursor.next());
    }
}

在这里需要注意一下，在删除的时候，官方推荐尽可能先查询一下这个数据是否存在，如果存在，然后在执行删除操作，可以调用 findOneAndDelete()方法进行删除！

MongoCollection类中提供了非常丰富的检索文档的方法，例如，我们可以通过 find()方法来获取集合中的所有文档。

检索 tb_role集合中的文档信息，代码片段如下：

/**
 * 查询文档
 * @param args
 */
public static void main(String[] args) {
    // 连接到数据库
    MongoDatabase mongoDatabase = mongoClient.getDatabase("test_db");
    System.out.println("Connect to database successfully");
    //获取集合
    MongoCollection collection = mongoDatabase.getCollection("tb_role");

    //遍历所有文档
    FindIterable findIterable = collection.find();
    MongoCursor mongoCursor = findIterable.iterator();
    while(mongoCursor.hasNext()){
        System.out.println(mongoCursor.next());
    }

    //查询当前集合所有文档数量
    long count = collection.countDocuments();
    System.out.println("当前文档数量:" + count);

    //带条件遍历文档
    FindIterable documentFindIterable = collection.find(Filters.eq("code", "manager"));
    MongoCursor documentMongoCursor = documentFindIterable.iterator();
    while(documentMongoCursor.hasNext()){
        System.out.println(documentMongoCursor.next());
    }
}

采用 SpringBoot 来对接 MongoDB，可以说极其简单，下面就以常用的几个操作为例来介绍，过程如下！

<!-- 引入springboot -->
<parent>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-parent</artifactid>
    <version>2.1.0.RELEASE</version>
</parent>

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-data-mongodb</artifactid>
</dependency>

在 application.properties文件中添加 mongodb配置

#&#x914D;&#x7F6E;&#x6570;&#x636E;&#x5E93;&#x8FDE;&#x63A5;&#x5730;&#x5740;
spring.data.mongodb.uri=mongodb://test123:test123@127.0.0.1:27017/test_db

创建用于示例中测试的实体类 Person。

其中注解 @Document(collection="persons")用于指定当前文档属于集合 persons。

注解 @Id表示当前 id字段属于主键类型。

/**
 * 使用@Document注解指定集合名称
 */
@Document(collection="persons")
public class Person implements Serializable {
    private static final long serialVersionUID = -3258839839160856613L;

    /**
     * 使用@Id注解指定MongoDB中的 _id 主键
     */
    @Id
    private Long id;

    private String userName;

    private String passWord;

    private Integer age;

    private Date createTime;

    //...get/set

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", passWord='" + passWord + '\'' +
                ", age=" + age +
                ", createTime=" + createTime +
                '}';
    }
}

Springboot 操作 MongoDB 有两种方式。

第一种方式是采用 Springboot 官方推荐的 JPA 方式，这种操作方式，使用简单但是灵活性比较差。
第二种方式是采用 Spring Data MongoDB 封装的 MongoDB 官方 Java 驱动 MongoTemplate 对 MongoDB 进行操作，这种方式非常灵活，能满足绝大部分需求。

本文将采用第二种方式进行介绍！

MongoTemplate提供了 insert()方法，用于插入文档，示例代码如下：

用于插入文档

没指定集合名称时，会取 @Document注解中的集合名称

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 插入文档
     * @throws Exception
     */
    @Test
    public void insert() throws Exception {
        Person person =new Person();
        person.setId(1l);
        person.setUserName("张三");
        person.setPassWord("123456");
        person.setCreateTime(new Date());
        mongoTemplate.insert(person);
    }
}

自定义集合名称，插入文档

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 自定义集合，插入文档
     * @throws Exception
     */
    @Test
    public void insertCustomCollection() throws Exception {
        Person person =new Person();
        person.setId(1l);
        person.setUserName("张三");
        person.setPassWord("123456");
        person.setCreateTime(new Date());
        mongoTemplate.insert(person, "custom_person");
    }
}

自定义集合，批量插入文档

如果采用批量插入文档，必须指定集合名称

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 自定义集合，批量插入文档
     * @throws Exception
     */
    @Test
    public void insertBatch() throws Exception {
        List personList = new ArrayList<>();
        Person person1 =new Person();
        person1.setId(10l);
        person1.setUserName("张三");
        person1.setPassWord("123456");
        person1.setCreateTime(new Date());
        personList.add(person1);

        Person person2 =new Person();
        person2.setId(11l);
        person2.setUserName("李四");
        person2.setPassWord("123456");
        person2.setCreateTime(new Date());
        personList.add(person2);

        mongoTemplate.insert(personList, "custom_person");
    }
}

MongoTemplate提供了 save()方法，用于存储文档。

在存储文档的时候会通过主键ID进行判断，如果存在就更新，否则就插入，示例代码如下：

存储文档，如果没有插入，否则通过 主键ID更新

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 存储文档，如果没有插入，否则更新
     * @throws Exception
     */
    @Test
    public void save() throws Exception {
        Person person =new Person();
        person.setId(13l);
        person.setUserName("八八");
        person.setPassWord("123456");
        person.setAge(40);
        person.setCreateTime(new Date());
        mongoTemplate.save(person);
    }
}

自定义集合，存储文档

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 自定义集合，存储文档
     * @throws Exception
     */
    @Test
    public void saveCustomCollection() throws Exception {
        Person person =new Person();
        person.setId(1l);
        person.setUserName("张三");
        person.setPassWord("123456");
        person.setCreateTime(new Date());
        mongoTemplate.save(person, "custom_person");
    }
}

MongoTemplate提供了 updateFirst()和 updateMulti()方法，用于更新文档，示例代码如下：

更新文档，匹配查询到的文档数据中的第一条数据

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 更新文档，匹配查询到的文档数据中的第一条数据
     * @throws Exception
     */
    @Test
    public void updateFirst() throws Exception {
        //更新对象
        Person person =new Person();
        person.setId(1l);
        person.setUserName("张三123");
        person.setPassWord("123456");
        person.setCreateTime(new Date());

        //更新条件
        Query query= new Query(Criteria.where("id").is(person.getId()));

        //更新值
        Update update= new Update().set("userName", person.getUserName()).set("passWord", person.getPassWord());
        //更新查询满足条件的文档数据（第一条）
        UpdateResult result =mongoTemplate.updateFirst(query,update, Person.class);
        if(result!=null){
            System.out.println("更新条数：" + result.getMatchedCount());
        }
    }
}

更新文档，匹配查询到的文档数据中的所有数据

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 更新文档，匹配查询到的文档数据中的所有数据
     * @throws Exception
     */
    @Test
    public void updateMany() throws Exception {
        //更新对象
        Person person =new Person();
        person.setId(1l);
        person.setUserName("张三");
        person.setPassWord("123456");
        person.setCreateTime(new Date());

        //更新条件
        Query query= new Query(Criteria.where("id").is(person.getId()));

        //更新值
        Update update= new Update().set("userName", person.getUserName()).set("passWord", person.getPassWord());
        //更新查询满足条件的文档数据（全部）
        UpdateResult result = mongoTemplate.updateMulti(query, update, Person.class);
        if(result!=null){
            System.out.println("更新条数：" + result.getMatchedCount());
        }
    }
}

MongoTemplate提供了 remove()、 findAndRemove()和 findAllAndRemove()方法，用于删除文档，示例代码如下：

删除符合条件的所有文档

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 删除符合条件的所有文档
     * @throws Exception
     */
    @Test
    public void remove() throws Exception {
        Person person =new Person();
        person.setId(1l);
        person.setUserName("张三");
        person.setPassWord("123456");
        person.setCreateTime(new Date());

        Query query = new Query(Criteria.where("userName").is(person.getUserName()));
        DeleteResult result = mongoTemplate.remove(query, Person.class);
        System.out.println("删除条数：" + result.getDeletedCount());
    }
}

删除符合条件的单个文档，并返回删除的文档

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 删除符合条件的单个文档，并返回删除的文档
     * @throws Exception
     */
    @Test
    public void findAndRemove() throws Exception {
        Person person =new Person();
        person.setId(1l);
        person.setUserName("张三");
        person.setPassWord("123456");
        person.setCreateTime(new Date());

        Query query = new Query(Criteria.where("id").is(person.getId()));
        Person result = mongoTemplate.findAndRemove(query, Person.class);
        System.out.println("删除的文档数据：" + result.toString());
    }
}

删除符合条件的所有文档，并返回删除的文档

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 删除符合条件的所有文档，并返回删除的文档
     * @throws Exception
     */
    @Test
    public void findAllAndRemove() throws Exception {
        Person person =new Person();
        person.setId(1l);
        person.setUserName("张三");
        person.setPassWord("123456");
        person.setCreateTime(new Date());

        Query query = new Query(Criteria.where("id").is(person.getId()));
        List result = mongoTemplate.findAllAndRemove(query, Person.class);
        System.out.println("删除的文档数据：" + result.toString());
    }
}

MongoTemplate提供了非常多的文档查询方法，日常开发中用的最多的就是 find()方法，示例代码如下：

查询集合中的全部文档数据

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 查询集合中的全部文档数据
     * @throws Exception
     */
    @Test
    public void findAll() throws Exception {
        List result = mongoTemplate.findAll(Person.class);
        System.out.println("查询结果：" + result.toString());
    }
}

查询集合中指定的ID文档数据

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 查询集合中指定的ID文档数据
     * @throws Exception
     */
    @Test
    public void findById() {
        long id = 1l;
        Person result = mongoTemplate.findById(id, Person.class);
        System.out.println("查询结果：" + result.toString());
    }
}

根据条件查询集合中符合条件的文档，返回第一条数据

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 根据条件查询集合中符合条件的文档，返回第一条数据
     */
    @Test
    public void findOne() {
        String userName = "张三";
        Query query = new Query(Criteria.where("userName").is(userName));
        Person result = mongoTemplate.findOne(query, Person.class);
        System.out.println("查询结果：" + result.toString());
    }
}

根据条件查询集合中符合条件的文档

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 根据条件查询集合中符合条件的文档
     */
    @Test
    public void findByCondition() {
        String userName = "张三";
        Query query = new Query(Criteria.where("userName").is(userName));
        List result = mongoTemplate.find(query, Person.class);
        System.out.println("查询结果：" + result.toString());
    }
}

根据【AND】关联多个查询条件，查询集合中的文档数据

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 根据【AND】关联多个查询条件，查询集合中的文档数据
     */
    @Test
    public void findByAndCondition() {
        // 创建条件
        Criteria criteriaUserName = Criteria.where("userName").is("张三");
        Criteria criteriaPassWord = Criteria.where("passWord").is("123456");
        // 创建条件对象，将上面条件进行 AND 关联
        Criteria criteria = new Criteria().andOperator(criteriaUserName, criteriaPassWord);
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        List result = mongoTemplate.find(query, Person.class);
        System.out.println("查询结果：" + result.toString());
    }
}

根据【OR】关联多个查询条件，查询集合中的文档数据

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 根据【OR】关联多个查询条件，查询集合中的文档数据
     */
    @Test
    public void findByOrCondition() {
        // 创建条件
        Criteria criteriaUserName = Criteria.where("userName").is("张三");
        Criteria criteriaPassWord = Criteria.where("passWord").is("123456");
        // 创建条件对象，将上面条件进行 OR 关联
        Criteria criteria = new Criteria().orOperator(criteriaUserName, criteriaPassWord);
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        List result = mongoTemplate.find(query, Person.class);
        System.out.println("查询结果：" + result.toString());
    }
}

根据【IN】关联多个查询条件，查询集合中的文档数据

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 根据【IN】关联多个查询条件，查询集合中的文档数据
     */
    @Test
    public void findByInCondition() {
        // 设置查询条件参数
        List ids = Arrays.asList(1l, 10l, 11l);
        // 创建条件
        Criteria criteria = Criteria.where("id").in(ids);
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        List result = mongoTemplate.find(query, Person.class);
        System.out.println("查询结果：" + result.toString());
    }
}

根据【逻辑运算符】查询集合中的文档数据

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 根据【逻辑运算符】查询集合中的文档数据
     */
    @Test
    public void findByOperator() {
        // 设置查询条件参数
        int min = 20;
        int max = 35;
        Criteria criteria = Criteria.where("age").gt(min).lte(max);
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        List result = mongoTemplate.find(query, Person.class);
        System.out.println("查询结果：" + result.toString());
    }
}

根据【正则表达式】查询集合中的文档数据

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 根据【正则表达式】查询集合中的文档数据
     */
    @Test
    public void findByRegex() {
        // 设置查询条件参数
        String regex = "^张*";
        Criteria criteria = Criteria.where("userName").regex(regex);
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        List result = mongoTemplate.find(query, Person.class);
        System.out.println("查询结果：" + result.toString());
    }
}

根据条件查询集合中符合条件的文档，获取其文档列表并排序

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 根据条件查询集合中符合条件的文档，获取其文档列表并排序
     */
    @Test
    public void findByConditionAndSort() {
        String userName = "张三";
        Query query = new Query(Criteria.where("userName").is(userName)).with(Sort.by("age"));
        List result = mongoTemplate.find(query, Person.class);
        System.out.println("查询结果：" + result.toString());
    }
}

根据单个条件查询集合中的文档数据，并按指定字段进行排序与限制指定数目

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

   /**
     * 根据单个条件查询集合中的文档数据，并按指定字段进行排序与限制指定数目
     */
    @Test
    public void findByConditionAndSortLimit() {
        String userName = "张三";
        //从第一行开始，查询2条数据返回
        Query query = new Query(Criteria.where("userName").is(userName)).with(Sort.by("createTime")).limit(2).skip(1);
        List result = mongoTemplate.find(query, Person.class);
        System.out.println("查询结果：" + result.toString());
    }
}

统计集合中符合【查询条件】的文档【数量】

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

   /**
     * 统计集合中符合【查询条件】的文档【数量】
     */
    @Test
    public void countNumber() {
        // 设置查询条件参数
        String regex = "^张*";
        Criteria criteria = Criteria.where("userName").regex(regex);
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        long count = mongoTemplate.count(query, Person.class);
        System.out.println("统计结果：" + count);
    }
}

索引在所有的数据库中，暂居的位置非常重要，例如当你检索一张上百万的数据表的时候，如果没走索引，查询效率会极其缓慢，对于 MongoDB 来说，同样如此。

示例如下：

创建升序索引

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 创建升序索引
     */
    @Test
    public void createAscendingIndex() {
        // 设置字段名称
        String field = "userName";
        // 创建索引
        mongoTemplate.getCollection("persons").createIndex(Indexes.ascending(field));
    }
}

移除索引

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

   /**
     * 根据索引名称移除索引
     */
    @Test
    public void removeIndex() {
        // 设置字段名称
        String field = "userName";
        // 删除索引
        mongoTemplate.getCollection("persons").dropIndex(field);
    }
}

查询集合中所有的索引

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {

    @Autowired
    private MongoTemplate mongoTemplate;

   /**
     * 查询集合中所有的索引
     */
    @Test
    public void getIndexAll() {
        // 获取集合中所有列表
        ListIndexesIterable indexList = mongoTemplate.getCollection("persons").listIndexes();
        // 获取集合中全部索引信息
        for (Document document : indexList) {
            System.out.println("索引列表：" + document);
        }
    }
}

我们还可以通过在实体类上加注解方式来创建索引

/**
 * 使用@Document注解指定集合名称
 */
@Document(collection="persons")
public class Person implements Serializable {
    private static final long serialVersionUID = -3258839839160856613L;

    /**
     * 使用@Id注解指定MongoDB中的 _id 主键
     */
    @Id
    private Long id;

    private String userName;

    private String passWord;

    private Integer age;

    /**
     * 创建一个5秒之后文档自动删除的索引
     */
    @Indexed(expireAfterSeconds=5)
    private Date createTime;

    //...get/set

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", passWord='" + passWord + '\'' +
                ", age=" + age +
                ", createTime=" + createTime +
                '}';
    }
}

单节点 mongodb 不支持事务，需要搭建 MongoDB 复制集。

/**
 * 配置事务管理器
 *
 */
@Configuration
public class TransactionConfig {

    @Bean
    MongoTransactionManager transactionManager(MongoDatabaseFactory dbFactory) {
        return new MongoTransactionManager(dbFactory);
    }

}

事务服务测试！

@Service
public class TransactionExample {

    @Autowired
    private MongoTemplate mongoTemplate;

    @Transactional(rollbackFor = Exception.class)
    public Object transactionTest(){
        Person person =new Person();
        person.setId(1l);
        person.setUserName("张三");
        person.setPassWord("123456");
        person.setCreateTime(new Date());
        Person newPerson = mongoTemplate.insert(person);
        // 抛出异常，观察数据是否进行回滚
        if(1 == 1){
            throw new RuntimeException("异常");
        }
        return newPerson;
    }
}

本文主要围绕 MongoDB 的 Java 客户端使用进行基本的增删改查操作介绍，在实际的业务场景中，可能还需要用到聚合函数等高级查询，大家如果有这种需求，可以访问如下地址获取更加详细的 api 文档介绍：MongoDB 文档查询 api 介绍

Original: https://www.cnblogs.com/dxflqm/p/16643981.html
Author: 程序员志哥
Title: SpringBoot 整合 MongoDB 实战解说

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/594199/

转载文章受原作者版权保护。转载请注明原作者出处！

Java

【自取】最近整理的，有需要可以领取学习：

Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言刷题答案下载！

基本数据类型-java学习日记

1.不同进制的数据组成二进制：由0,1组成。以0b开头八进制：由0,1,…7组成。以0开头十进制：由0,1,…9组成。整数默认是十进制十六进制：…

Java 2023年6月5日
00104
Java 学习大纲

1.java基础 1.1 Collection和Map(1)掌握Collection和Map的继承体系(2)掌握ArrayList，LinkedList,Vector,Stack,…

Java 2023年5月29日
0067
nginx日志分析解决方案- Awstats

很多PHP搭建的网站都在由apache转向了nginx。nginx的日志信息如何分析呢？当然你可以自己写一个，但是这里也推荐一款结果信息非常详尽的开源工具——Awstats ，它…

Java 2023年5月30日
0088
测试用例千万不能随便，记录由一个测试用例异常引起的思考

一测试用例大家平时写不写？我以前写测试用例只是针对业务接口，每个接口写一个，数据case也只是测一种。能跑通就可以了。要不同的场景case，那就改数据。重新跑一遍。简单省事。 …

Java 2023年6月8日
0095
2022-8-31 jsp el表达式

jsp 注意：1、JSP脚本片段中只能出现java代码，不能出现HTML元素。在访问JSP时，JSP引擎翻译JSP页面中的脚本片段。2、JSP脚本片段中的java代码必须严格遵守…

Java 2023年6月13日
0074
Java开发之JavaWeb速成 —- 第二部分

JavaWeb速成前言以最少时间，快速学完各知识点。知识点围绕概念，作用，使用方法来写，适合有javaweb基础的人复习旨在快速入手/复习，放实例显得冗余，所以实例代码会以截…

Java 2023年6月5日
00104
Vue 前端权限控制的优化改进版

1、前言之前《Vue前端访问控制方案》一文中提出，使用class=”permissions”结合元素id来标识权限控制相关的dom元素，并通过公共方法c…

Java 2023年6月14日
0078
nginx –增加 headers-more-nginx-module

已经编译好的编nginx需要添加headers-more-nginx-module模块来自定义响应头 1.需要下载headers-more-nginx-module wget ht…

Java 2023年5月30日
0078
SPI使用

Dubbo 的可扩展性是基于 SPI 去实现的，而且Dubbo所有的组件都是通过 SPI 机制加载。 SPI 全称为 (Service Provider Interface) ，是…

Java 2023年6月16日
0064
谈谈多线程

多线程真的是一个很宽的话题，可以聊一串东西线程安全、同步机制、锁、线程运行状态、CAS原子操作、线程池、甚至是JMM、内存可见性等。而在日常coding中更多地关注是创建线程池提…

Java 2023年5月30日
0097
自定义异常

class MyException extends Exception { //自定义异常继承Exception类 public MyException(String msg) {…

Java 2023年6月5日
0088
MongoDB常用命令（2）

1、创建数据库 use testdb 2、创建集合 db.t_member.insert({name:"zhaomin",age:23}) 3、查询 db.t_…

Java 2023年6月7日
0085
redis数据结构介绍和redis命令操作_string&hash

redis存储的是：key，value格式的数据，其中key都是字符串，value有物种不同的数据结构 value的数据结构：字符串类型 string 哈希类型 hash ：ma…

Java 2023年6月6日
0079
会话技术 cookie 和 Session（1）

CookieCookie 属于客户端会话技术，它是服务器发送给浏览器的小段文本信息，存储在客户端浏览器的内存中或硬盘上。当浏览器保存了Cookie 后，每次访问服务器，都会在HTT…

Java 2023年6月9日
00105
栈溢出-ret2libc地址泄露笔记

作为一名初学者，在碰到很多攻击思路的时候会感觉很妙，比如gadget的构造，这题的sh参数截断。 1、首先分析程序架构和保护措施。 2、使用IDA开始判断程序是否具备最简单的栈溢出…

Java 2023年6月5日
0088
SQL(三)DDL、DML、DCL总结

表的创建 create table 表名( 字段名1 数据类型, 字段名2 数据类型, 字段名3 数据类型 ); 创建student表并指定性别默认为男： create table…

Java 2023年6月16日
0090

2024 年 5 月
一	二	三	四	五	六	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31

SpringBoot 整合 MongoDB 实战解说

大家都在看