扫码关注公众号:芋道源码

发送: 百事可乐
获取永久解锁本站全部文章的链接

《Dubbo 实现原理与源码解析 —— 精品合集》 《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》 《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》 《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》 《Java 面试题 + Java 学习指南》

摘要: 原创出处 http://www.iocoder.cn/Spring-Boot/MongoDB/ 「芋道源码」欢迎转载,保留摘要,谢谢!


🙂🙂🙂关注微信公众号:【芋道源码】有福利:

  1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
  2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
  3. 您对于源码的疑问每条留言将得到认真回复。甚至不知道如何读源码也可以请教噢
  4. 新的源码解析文章实时收到通知。每周更新一篇左右
  5. 认真的源码交流微信群。

1. 概述

可能有一些胖友对 MongoDB 不是很了解,这里我们引用一段介绍:

FROM 《分布式文档存储数据库 MongoDB》

MongoDB 是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的。

他支持的数据结构非常松散,是类似 json 的 bjson 格式,因此可以存储比较复杂的数据类型。

Mongo 最大的特点是他支持的查询语言非常强大,其语法有点类似于面向对象的查询语言,几乎可以实现类似关系数据库单表查询的绝大部分功能,而且还支持对数据建立索引。

MongoDB 中的许多概念在 MySQL 中具有相近的类比。本表概述了每个系统中的一些常见概念。

对于不熟悉的胖友,可以先看下该表,然后开始本文的旅程。

MySQL MongoDB
库 Database 库 Database
表 Table 集合 Collection
行 Row 文档 Document
列 Column 字段 Field
joins 嵌入文档或者链接

在早期,在项目中 MongoDB 的 ORM 框架使用 Morphia 较多。随着 Spring Data MongoDB 的日趋完善,更为主流。目前,艿艿手头所有的项目,都从 Morphia 该用 Spring Data MongoDB 。

在 Spring Data MongoDB 中,有两种方式进行 MongoDB 操作:

  • Spring Data Repository 方式
  • MongoTemplate

艿艿:如果胖友还没安装 MongoDB ,可以参考下 《MongoDB 安装部署》 文章,先进行下安装。

2. 快速入门

示例代码对应仓库:lab-16-spring-data-mongodb

  • MongoDB 版本号:4.2.1

本小节,我们会使用 spring-boot-starter-data-mongodb 自动化配置 Spring Data MongoDB 主要配置。同时,使用 Spring Data Repository 实现的 MongoDB 的 CRUD 操作。

2.1 引入依赖

pom.xml 文件中,引入相关依赖。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.3.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<modelVersion>4.0.0</modelVersion>

<artifactId>lab-16-spring-data-mongodb</artifactId>

<dependencies>
<!-- 自动化配置 Spring Data Mongodb -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

<!-- 方便等会写单元测试 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

</dependencies>

</project>

具体每个依赖的作用,胖友自己认真看下艿艿添加的所有注释噢。

2.2 Application

创建 Application.java 类,配置 @SpringBootApplication 注解即可。代码如下:

// Application.java

@SpringBootApplication(exclude = {ElasticsearchAutoConfiguration.class, ElasticsearchDataAutoConfiguration.class})
public class Application {
}

2.3 MongoDBConfig

cn.iocoder.springboot.lab16.springdatamongodb.config 包路径下,创建 MongoDBConfig 配置类。代码如下:

// MongoDBConfig.java

@Configuration
public class MongoDBConfig {

@Bean // 目的,就是为了移除 _class field 。参考博客 https://blog.csdn.net/bigtree_3721/article/details/82787411
public MappingMongoConverter mappingMongoConverter(MongoDbFactory factory,
MongoMappingContext context,
BeanFactory beanFactory) {
// 创建 DbRefResolver 对象
DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
// 创建 MappingMongoConverter 对象
MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver, context);
// 设置 conversions 属性
try {
mappingConverter.setCustomConversions(beanFactory.getBean(CustomConversions.class));
} catch (NoSuchBeanDefinitionException ignore) {
}
// 设置 typeMapper 属性,从而移除 _class field 。
mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null));
return mappingConverter;
}

}
  • 通过在自定义 MappingMongoConverter Bean 对象,避免实体保存到 MongoDB 中时,会多一个 _class 字段,存储实体的全类名。

2.4 配置文件

application.yml 中,添加 MongoDB 配置,如下:

spring:
data:
# MongoDB 配置项,对应 MongoProperties 类
mongodb:
host: 127.0.0.1
port: 27017
database: yourdatabase
username: test01
password: password01
# 上述属性,也可以只配置 uri

logging:
level:
org:
springframework:
data:
mongodb:
core: DEBUG # 打印 mongodb 操作的具体语句。生产环境下,不建议开启。

2.5 UserDO

cn.iocoder.springboot.lab16.springdatamongodb.dataobject 包路径下,创建 UserDO 类。代码如下:

@Document(collection = "User")
public class UserDO {

/**
* 用户信息
*/
public static class Profile {

/**
* 昵称
*/
private String nickname;
/**
* 性别
*/
private Integer gender;

// ... 省略 setting/getting 方法

}

@Id
private Integer id;
/**
* 账号
*/
private String username;
/**
* 密码
*/
private String password;
/**
* 创建时间
*/
private Date createTime;
/**
* 用户信息
*/
private Profile profile;

// ... 省略 setting/getting 方法

}
  • 在 UserDO 类中,我们内嵌了一个 profile 属性,它是 Profile 类。这里仅仅作为示例,实际场景下,还是建议把 User 和 Profile 拆分开。
  • 推荐阅读 《你应该知道的 MongoDB 最佳实践》 文章。对于初用 MongoDB 的开发者,往往错误的使用内嵌属性,需要去理解一下。

2.6 UserRepository

cn.iocoder.springboot.lab16.springdatamongodb.repository 包路径下,创建 UserRepository 接口。代码如下:

// ProductRepository.java

public interface UserRepository extends MongoRepository<UserDO, Integer> {
}

艿艿:如果胖友看过艿艿写的 《芋道 Spring Boot JPA 入门》 文章,会发现和 Spring Data JPA 的使用方式,基本一致。这就是 Spring Data 带给我们的好处,使用相同的 API ,统一访问不同的数据源。o( ̄▽ ̄)d 点赞。

2.7 简单测试

创建 UserRepositoryTest 测试类,我们来测试一下简单的 UserRepositoryTest 的每个操作。代码如下:

// UserRepositoryTest.java

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class UserRepositoryTest {

@Autowired
private UserRepository userRepository;

@Test // 插入一条记录
public void testInsert() {
// 创建 UserDO 对象
UserDO user = new UserDO();
user.setId(1); // 这里先临时写死一个 ID 编号,后面演示自增 ID 的时候,在修改这块
user.setUsername("yudaoyuanma");
user.setPassword("buzhidao");
user.setCreateTime(new Date());
// 创建 Profile 对象
UserDO.Profile profile = new UserDO.Profile();
profile.setNickname("芋道源码");
profile.setGender(1);
user.setProfile(profile);
// 存储到 DB
userRepository.insert(user);
}

// 这里要注意,如果使用 save 方法来更新的话,必须是全量字段,否则其它字段会被覆盖。
// 所以,这里仅仅是作为一个示例。
@Test // 更新一条记录
public void testUpdate() {
// 查询用户
Optional<UserDO> userResult = userRepository.findById(1);
Assert.isTrue(userResult.isPresent(), "用户一定要存在");
// 更新
UserDO updateUser = userResult.get();
updateUser.setUsername("yutou");
userRepository.save(updateUser);
}

@Test // 根据 ID 编号,删除一条记录
public void testDelete() {
userRepository.deleteById(1);
}

@Test // 根据 ID 编号,查询一条记录
public void testSelectById() {
Optional<UserDO> userDO = userRepository.findById(1);
System.out.println(userDO.isPresent());
}

@Test // 根据 ID 编号数组,查询多条记录
public void testSelectByIds() {
Iterable<UserDO> users = userRepository.findAllById(Arrays.asList(1, 4));
users.forEach(System.out::println);
}

}
  • 每个测试单元方法,胖友自己看看方法上的注释。

具体的,胖友可以自己跑跑,妥妥的。

3. 基于方法名查询

示例代码对应仓库:lab-16-spring-data-mongodb

《芋道 Spring Boot JPA 入门》 文章的「4. 基于方法名查询」小节中,我们已经提到:

在 Spring Data 中,支持根据方法名作生成对应的查询(WHERE)条件,进一步进化我们使用 JPA ,具体是方法名以 findByexistsBycountBydeleteBy 开头,后面跟具体的条件。具体的规则,在 《Spring Data JPA —— Query Creation》 文档中,已经详细提供。如下:

关键字 方法示例 JPQL snippet
And findByLastnameAndFirstname … where x.lastname = ?1 and x.firstname = ?2
Or findByLastnameOrFirstname … where x.lastname = ?1 or x.firstname = ?2
Is, Equals findByFirstname,findByFirstnameIs,findByFirstnameEquals … where x.firstname = ?1
Between findByStartDateBetween … where x.startDate between ?1 and ?2
LessThan findByAgeLessThan … where x.age < ?1
LessThanEqual findByAgeLessThanEqual … where x.age <= ?1
GreaterThan findByAgeGreaterThan … where x.age > ?1
GreaterThanEqual findByAgeGreaterThanEqual … where x.age >= ?1
After findByStartDateAfter … where x.startDate > ?1
Before findByStartDateBefore … where x.startDate < ?1
IsNull, Null findByAge(Is)Null … where x.age is null
IsNotNull, NotNull findByAge(Is)NotNull … where x.age not null
Like findByFirstnameLike … where x.firstname like ?1
NotLike findByFirstnameNotLike … where x.firstname not like ?1
StartingWith findByFirstnameStartingWith … where x.firstname like ?1 (parameter bound with appended %)
EndingWith findByFirstnameEndingWith … where x.firstname like ?1 (parameter bound with prepended %)
Containing findByFirstnameContaining … where x.firstname like ?1 (parameter bound wrapped in %)
OrderBy findByAgeOrderByLastnameDesc … where x.age = ?1 order by x.lastname desc
Not findByLastnameNot … where x.lastname <> ?1
In findByAgeIn(Collection ages) … where x.age in ?1
NotIn findByAgeNotIn(Collection ages) … where x.age not in ?1
True findByActiveTrue() … where x.active = true
False findByActiveFalse() … where x.active = false
IgnoreCase findByFirstnameIgnoreCase … where UPPER(x.firstame) = UPPER(?1)
  • 注意,如果我们有排序需求,可以使用 OrderBy 关键字。

下面,我们来编写一个简单的示例。

艿艿:IDEA 牛逼,提供的插件已经能够自动提示上述关键字。太强了~

3.1 UserRepository02

cn.iocoder.springboot.lab16.springdatamongodb.repository 包路径下,创建 UserRepository02 接口。代码如下:

// UserRepository02.java

public interface UserRepository02 extends MongoRepository<UserDO, Integer> {

UserDO findByUsername(String username);

Page<UserDO> findByUsernameLike(String username, Pageable pageable);

}
  • 对于分页操作,需要使用到 Pageable 参数,需要作为方法的最后一个参数。
  • 注意噢,基于方法名查询,不支持内嵌对象的属性。(⊙o⊙)… 至少在网上翻了一波资料,没有提及这块。

3.2 简单测试

创建 UserRepository02Test 测试类,我们来测试一下简单的 UserRepository02Test 的每个操作。代码如下:

// UserRepository02Test.java

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class UserRepository02Test {

@Autowired
private UserRepository02 userRepository;

@Test // 根据名字获得一条记录
public void testFindByName() {
UserDO user = userRepository.findByUsername("yutou");
System.out.println(user);
}

@Test // 使用 username 模糊查询,分页返回结果
public void testFindByNameLike() {
// 创建排序条件
Sort sort = new Sort(Sort.Direction.DESC, "id"); // ID 倒序
// 创建分页条件。
Pageable pageable = PageRequest.of(0, 10, sort);
// 执行分页操作
Page<UserDO> page = userRepository.findByUsernameLike("yu", pageable);
// 打印
System.out.println(page.getTotalElements());
System.out.println(page.getTotalPages());
}

}
  • 每个测试单元方法,胖友自己看看方法上的注释。

具体的,胖友可以自己跑跑,妥妥的。

4. 基于 Example 查询

示例代码对应仓库:lab-16-spring-data-mongodb

实际场景下,我们并不会基于 Example 查询。所以本小节,胖友可以选择性看看即可。

对于大多数胖友,可能不了解 Spring Data Example 。我们先来一起看看官方文档的介绍:

Query by Example (QBE) is a user-friendly querying technique with a simple interface.
使用 Example 进行查询,是一种友好的查询方式,可以使用便捷的 API 方法。

It allows dynamic query creation and does not require to write queries containing field names.
它允许创建动态查询,而无需编写包含字段名的查询。

In fact, Query by Example does not require to write queries using store-specific query languages at all.
事实上,在使用 Example 进行查询的时候,我们无需使用特定的存储器(数据库)的查询语言。

  • 请原谅艿艿蹩脚的翻译。简单来说,我们可以通过 Example 进行编写动态的查询条件,而无需使用每个不同的 Spring Data 实现类的 Query 对象。例如说:
    • Spring Data JPA 提供的 javax.persistence.criteria.Predicate
    • Spring Data MongoDB 提供的 org.springframework.data.mongodb.core.query.Query
  • 相当于说,不同 Spring Data 实现框架,会将 Spring Data Example 条件,翻译成对应的查询对象。例如说:
    • Spring Data JPA 将 Example 转换成 Predicate 。
    • Spring Data MongoDB 将 Example 转换成 Query 。
  • 当然,并不是所有 Spring Data 实现都支持 Spring Data Example 。例如说,Spring Data Elasticsearch 并不支持。一般情况下,支持 Spring Data Example 的 Spring Data 实现框架,它们的 Repository 都继承了 org.springframework.data.repository.query.QueryByExampleExecutor 接口。例如说:

Example API 一共包含三部分:

  • Probe :含有对应字段的实体对象。通过设置该实体对象的字段,作为查询字段。

    注意,Probe 并不是一个类,而是实体对象的泛指。

  • ExampleMatcher :ExampleMatcher 可以定义特定字段的匹配模式。例如说,全模糊匹配、前缀模糊匹配等等。

    简单来说,通过实体对象的字段作为查询条件,只能满足相等的情况,对于 !=LIKE 等等情况,需要通过 ExampleMatcher 特殊指定。如果不理解,没事,看了示例会更容易明白。

  • Example :是 Probe 和 ExampleMatcher 的组合,构成查询对象。

当然,Example 有它的限制条件:

No support for nested/grouped property constraints like firstname = ?0 or (firstname = ?1 and lastname = ?2)
不支持嵌套或分组约束。例如说,firstname = ?0 or (firstname = ?1 and lastname = ?2)

Only supports starts/contains/ends/regex matching for strings and exact matching for other property types
对于字符串,只支持 tarts/contains/ends/regex 匹配方式;对于其它类型,只支持精确匹配。

4.1 UserRepository03

cn.iocoder.springboot.lab16.springdatamongodb.repository 包路径下,创建 UserRepository02 接口。代码如下:

// UserRepository03.java

public interface UserRepository03 extends MongoRepository<UserDO, Integer> {

// 使用 username 精准匹配
default UserDO findByUsername01(String username) {
// 创建 Example 对象,使用 username 查询
UserDO probe = new UserDO();
probe.setUsername(username); // 精准匹配 username 查询
Example<UserDO> example = Example.of(probe);
// 执行查询
return findOne(example)
.orElse(null); // 如果为空,则返回 null
}

// 使用 username 模糊匹配
default UserDO findByUsernameLike01(String username) {
// 创建 Example 对象,使用 username 查询
UserDO probe = new UserDO();
probe.setUsername(username); // 这里还需要设置
ExampleMatcher matcher = ExampleMatcher.matching()
.withMatcher("username", ExampleMatcher.GenericPropertyMatchers.contains()); // 模糊匹配 username 查询
Example<UserDO> example = Example.of(probe, matcher);
// 执行查询
return findOne(example)
.orElse(null); // 如果为空,则返回 null
}

}

4.2 简单测试

创建 UserRepository03Test 测试类,我们来测试一下简单的 UserRepository03Test 的每个操作。代码如下:

// UserRepository03Test.java

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class UserRepository03Test {

@Autowired
private UserRepository03 userRepository;

@Test
public void testFindByUsername01() {
UserDO user = userRepository.findByUsername01("yutou");
System.out.println(user);
}

@Test
public void testFindByUsernameLike01() {
UserDO user = userRepository.findByUsernameLike01("yu");
System.out.println(user);
}

}
  • 每个测试单元方法,胖友自己看看方法上的注释。

具体的,胖友可以自己跑跑,妥妥的。更多示例,可以看看如下文章:

5. MongoTemplate

示例代码对应仓库:lab-16-spring-data-mongodb

在 Spring Data MongoDB 中,有一个 MongoTemplate 类,提供了 MongoDB 操作模板,方便我们操作 MongoDB 。

5.1 UserDao

cn.iocoder.springboot.lab16.springdatamongodb.dao 包路径下,创建 UserDao 类。代码如下:

// UserDao.java

@Repository
public class UserDao {

@Autowired
private MongoTemplate mongoTemplate;

public void insert(UserDO entity) {
mongoTemplate.insert(entity);
}

public void updateById(UserDO entity) {
// 生成 Update 条件
final Update update = new Update();
// 反射遍历 entity 对象,将非空字段设置到 Update 中
ReflectionUtils.doWithFields(entity.getClass(), new ReflectionUtils.FieldCallback() {

@Override
public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
// 排除指定条件
if ("id".equals(field.getName()) // 排除 id 字段,因为作为查询主键
|| field.getAnnotation(Transient.class) != null // 排除 @Transient 注解的字段,因为非存储字段
|| Modifier.isStatic(field.getModifiers())) { // 排除静态字段
return;
}
// 设置字段可反射
if (!field.isAccessible()) {
field.setAccessible(true);
}
// 排除字段为空的情况
if (field.get(entity) == null) {
return;
}
// 设置更新条件
update.set(field.getName(), field.get(entity));
}

});
// 防御,避免有业务传递空的 Update 对象
if (update.getUpdateObject().isEmpty()) {
return;
}
// 执行更新
mongoTemplate.updateFirst(new Query(Criteria.where("_id").is(entity.getId())), update, UserDO.class);
}

public void deleteById(Integer id) {
mongoTemplate.remove(new Query(Criteria.where("_id").is(id)), UserDO.class);
}

public UserDO findById(Integer id) {
return mongoTemplate.findOne(new Query(Criteria.where("_id").is(id)), UserDO.class);
}

public UserDO findByUsername(String username) {
return mongoTemplate.findOne(new Query(Criteria.where("username").is(username)), UserDO.class);
}

public List<UserDO> findAllById(List<Integer> ids) {
return mongoTemplate.find(new Query(Criteria.where("_id").in(ids)), UserDO.class);
}

}
  • 使用 MongoTemplate 实现了 CRUD 的功能。其它 findAndModify/findAndRemove/count/upsert 等操作,胖友可以自己尝试下。
  • 对于 #updateById(UserDO entity) 方法,胖友可以自己抽象成一个通用的 #updateEntityFieldsById(Object id, Object entity) 方法,封装在一个 BaseMongoDao 抽象类中。

    友情提示:此处暂时有个问题,对于 UserDO 内嵌的 profile 对象,一旦设置了值,是整个 Profile 对象覆盖更新。所以,使用时需要注意下。

    目前艿艿自己项目里,大多数内嵌对象,全量更新不存在问题。如果存在问题的,提供了另外的方法解决。

    当然,也可以进一步封装 #updateEntityFieldsById(Object id, Object entity, String... fields) 方法,只更新指定字段。

5.2 简单测试

创建 UserDaoTest 测试类,我们来测试一下简单的 UserDaoTest 的每个操作。代码如下:

// UserDaoTest.java

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class UserDaoTest {

@Autowired
private UserDao userDao;

@Test // 插入一条记录
public void testInsert() {
// 创建 UserDO 对象
UserDO user = new UserDO();
user.setId(1); // 这里先临时写死一个 ID 编号,后面演示自增 ID 的时候,在修改这块
user.setUsername("yudaoyuanma");
user.setPassword("buzhidao");
user.setCreateTime(new Date());
// 创建 Profile 对象
UserDO.Profile profile = new UserDO.Profile();
profile.setNickname("芋道源码");
profile.setGender(1);
user.setProfile(profile);
// 存储到 DB
userDao.insert(user);
}

// 这里要注意,如果使用 save 方法来更新的话,必须是全量字段,否则其它字段会被覆盖。
// 所以,这里仅仅是作为一个示例。
@Test // 更新一条记录
public void testUpdate() {
// 创建 UserDO 对象
UserDO updateUser = new UserDO();
updateUser.setId(1);
updateUser.setUsername("nicai");

// 执行更新
userDao.updateById(updateUser);
}

@Test // 根据 ID 编号,删除一条记录
public void testDelete() {
userDao.deleteById(1);
}

@Test // 根据 ID 编号,查询一条记录
public void testSelectById() {
UserDO userDO = userDao.findById(1);
System.out.println(userDO);
}

@Test // 根据 ID 编号数组,查询多条记录
public void testSelectByIds() {
List<UserDO> users = userDao.findAllById(Arrays.asList(1, 4));
users.forEach(System.out::println);
}

}
  • 每个测试单元方法,胖友自己看看方法上的注释。

具体的,胖友可以自己跑跑,妥妥的。

6. 自增主键

示例代码对应仓库:lab-16-spring-data-mongodb

MongoDB 自带的主键选择是 ObjectId 类型,需要占用 12 字节。相比 Int 4 字节或者 Long 8 字节占用更多的内存空间。而绝大多数业务场景下,Int 或 Long 足够使用,所以我们更加偏向使用 Int 或 Long 作为自增 ID 主键。

当然,我们在日志记录上,我们还是采用 ObjectId 为主。

我们在实现 MongoDB 自增主键时,会创建一个名为 "sequence" 的集合。字段如下:

"sequence" 集合名,也可以取其它名字,看自己喜好。

  • _id :String 类型,集合的实体类名。
  • value :Long 类型,存储每个集合的自增序列。

在程序中,每次插入实体对象到 MongoDB 之前,通过 $inc 操作,从 "sequence" 自增获得最新的 ID ,然后将该 ID 赋值给实体对象,最终在插入到 MongoDB 之中。

当然,考虑到并不是所有实体都需要使用自增 ID ,所以我们要有方式去标记:

  • 方式一:创建自定义 @AutoIncKey 注解,添加到 ID 属性上。
  • 方式二:创建 IncIdEntity 抽象基类,这样需要自增的实体继承它。

对于方式一,网上博客比较多,胖友可以看看 《Java 中实现 MongoDB 主键自增》 文章。

对于方式二,目前艿艿项目采用这种方式,主要是我们自己的 BaseMongoDao 提供的很多方法,是基于 IncIdEntity 抽象类的。例如说,#updateEntityFieldsById(final IncIdEntity entity, String... fields) 方法,这样可以方便的直接获取到 ID 属性。

当然,无论方式一还是方式二,实现原理是一致的,差异仅仅在于获取 ID 属性不同。下面,本小节我们就来实现下方式二。

6.1 IncIdEntity

cn.iocoder.springboot.lab16.springdatamongodb.mongo 包路径下,创建 IncIdEntity 类。代码如下:

// IncIdEntity.java

/**
* 自增主键实体
*
* @param <T> 主键泛型
*/
public abstract class IncIdEntity<T extends Number> {

@Id
private T id;

public T getId() {
return id;
}

public void setId(T id) {
this.id = id;
}

}

6.2 ProductDO

cn.iocoder.springboot.lab16.springdatamongodb.dataobject 包路径下,创建 ProductDO 类。代码如下:

// ProductDO.java

@Document(collection = "Product")
public class ProductDO extends IncIdEntity<Integer> {

/**
* 商品名
*/
private String name;

public String getName() {
return name;
}

public ProductDO setName(String name) {
this.name = name;
return this;
}

}
  • 继承 IncIdEntity 抽象类,使用 Integer 自增主键。

6.3 MongoInsertEventListener

cn.iocoder.springboot.lab16.springdatamongodb.dataobject 包路径下,创建 MongoInsertEventListener 类。代码如下:

// MongoInsertEventListener.java

@Component
public class MongoInsertEventListener extends AbstractMongoEventListener<IncIdEntity> {

/**
* sequence - 集合名
*/
private static final String SEQUENCE_COLLECTION_NAME = "sequence";
/**
* sequence - 自增值的字段名
*/
private static final String SEQUENCE_FIELD_VALUE = "value";

@Autowired
private MongoTemplate mongoTemplate;

@Override
public void onBeforeConvert(BeforeConvertEvent<IncIdEntity> event) {
IncIdEntity entity = event.getSource();
// 判断 id 为空
if (entity.getId() == null) {
// 获得下一个编号
Number id = this.getNextId(entity);
// 设置到实体中
// noinspection unchecked
entity.setId(id);
}
}

/**
* 获得实体的下一个主键 ID 编号
*
* @param entity 实体对象
* @return ID 编号
*/
private Number getNextId(IncIdEntity entity) {
// 使用实体名的简单类名,作为 ID 编号
String id = entity.getClass().getSimpleName();
// 创建 Query 对象
Query query = new Query(Criteria.where("_id").is(id));
// 创建 Update 对象
Update update = new Update();
update.inc(SEQUENCE_FIELD_VALUE, 1); // 自增值
// 创建 FindAndModifyOptions 对象
FindAndModifyOptions options = new FindAndModifyOptions();
options.upsert(true); // 如果不存在时,则进行插入
options.returnNew(true); // 返回新值
// 执行操作
@SuppressWarnings("unchecked")
HashMap<String, Object> result = mongoTemplate.findAndModify(query, update, options,
HashMap.class, SEQUENCE_COLLECTION_NAME);
// 返回主键
return (Number) result.get(SEQUENCE_FIELD_VALUE);
}

}
  • MongoDB 实体对象在插入之前,会发布 BeforeConvertEvent 事件。所以,我们可以通过创建 MongoInsertEventListener 监听器,监听该事件,生成自增主键 ID 主键,设置到实体对象中。
  • 如果胖友想要使用集合名作为 "sequence" 集合的 "id" ,可以使用 BeforeConvertEvent.collectionName 属性。

6.4 ProductRepository

cn.iocoder.springboot.lab16.springdatamongodb.repository 包路径下,创建 ProductRepository 接口。代码如下:

// ProductRepository.java

public interface ProductRepository extends MongoRepository<ProductDO, Integer> {
}

6.5 简单测试

创建 ProductRepositoryTest 测试类,我们来测试一下简单的 ProductRepositoryTest 的每个操作。代码如下:

// ProductRepositoryTest.java

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class ProductRepositoryTest {

@Autowired
private ProductRepository productRepository;

@Test
public void testInsert() {
// 创建 ProductDO 对象
ProductDO product = new ProductDO();
product.setName("芋头");
// 插入
productRepository.insert(product);
// 打印 ID
System.out.println(product.getId());
}

}

666. 彩蛋

艿艿的项目中,只采用 MongoTemplate 。主要是我们封装了 BaseMongoDao ,提供了一些我们日常开发需要的功能,例如说:

  • #insertToMongo(Object objectToSave) 方法:插入实体,使用自增 ID 主键。
  • #updateEntityFieldsById(final IncIdEntity entity, String... fields) 方法:只更新实体指定字段。

推荐阅读:

文章目录
  1. 1. 1. 概述
  2. 2. 2. 快速入门
    1. 2.1. 2.1 引入依赖
    2. 2.2. 2.2 Application
    3. 2.3. 2.3 MongoDBConfig
    4. 2.4. 2.4 配置文件
    5. 2.5. 2.5 UserDO
    6. 2.6. 2.6 UserRepository
    7. 2.7. 2.7 简单测试
  3. 3. 3. 基于方法名查询
    1. 3.1. 3.1 UserRepository02
    2. 3.2. 3.2 简单测试
  4. 4. 4. 基于 Example 查询
    1. 4.1. 4.1 UserRepository03
    2. 4.2. 4.2 简单测试
  5. 5. 5. MongoTemplate
    1. 5.1. 5.1 UserDao
    2. 5.2. 5.2 简单测试
  6. 6. 6. 自增主键
    1. 6.1. 6.1 IncIdEntity
    2. 6.2. 6.2 ProductDO
    3. 6.3. 6.3 MongoInsertEventListener
    4. 6.4. 6.4 ProductRepository
    5. 6.5. 6.5 简单测试
  7. 7. 666. 彩蛋