一、背景介绍

---

在之前的文章中，我们详细的介绍了 MongoDB 的配置和使用，如果你对 MongoDB 还不是很了解，也没关系，我们一起在回顾一下。

在 MongoDB 中有三个比较重要的名词：数据库、集合、文档！

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

搞懂这三个名词，基本就可以上手了，今天我们以 SpringBoot 整合 MongoDB 为例，实现数据的增删改查

话不多说，直接开撸！

二、代码实践

---

2.1、创建 SpringBoot 工程，添加 MongoDB 依赖包

<!-- 引入springboot -->
<p>
    <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>

2.2、添加配置文件

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

#配置数据库连接地址
spring.data.mongodb.uri=mongodb://userName:password@127.0.0.1:27017/dbName

相关参数说明：

• userName：表示用户名，根据实际情况填写即可
• password：表示用户密码，根据实际情况填写即可
• dbName：表示数据库，可以自定义，初始化数据的时候，会自动创建
  

  2.3、创建实体类

创建一个实体类Person，其中注解@Document(collection="persons")表示当前实体类对应的集合名称是persons，类似于关系型数据库中的表名称。

注解@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 +
                '}';
    }
}

2.4、操作 MongoDB

Springboot 操作 MongoDB 有两种方式。

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

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

2.5、插入文档

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<P> 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");
    }
}

2.6、存储文档

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");
    }
}

2.7、更新文档

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());
        }
    }
}

2.8、删除文档

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<P> result = mongoTemplate.findAllAndRemove(query, Person.class);
        System.out.println("删除的文档数据：" + result.toString());
    }
}

2.9、查询文档

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

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

@RunWith(SpringRunner.class)
@SpringBootTest
public class PersonServiceTest {
    @Autowired
    private MongoTemplate mongoTemplate;
    /**
     * 查询集合中的全部文档数据
     * @throws Exception
     */
    @Test
    public void findAll() throws Exception {
        List<P> 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<P> 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<P> 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<P> 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<Long> ids = Arrays.asList(1l, 10l, 11l);
        // 创建条件
        Criteria criteria = Criteria.where("id").in(ids);
        // 创建查询对象，然后将条件对象添加到其中
        Query query = new Query(criteria);
        List<P> 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<P> 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<P> 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<P> 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<P> 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);
    }
}

3.0、索引管理

索引在所有的数据库中，暂居的位置非常重要，例如当你检索一张上百万的数据表的时候，如果没走索引，查询效率会极其缓慢，对于 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<Document> 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 +
                '}';
    }
}

3.1、引入 MongoDB 中的事务

单节点 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;
    }
}

四、小结

---

本文主要围绕 SpringBoot 整合 MongoDB 实现数据的增删改查操作进行基本介绍，如果有描述不对的，欢迎大家留言指出！

五、参考

---

1、https://www.runoob.com/mongodb/mongodb-java.html
2、http://www.mydlq.club/article/85

---