第 4-7 课：Spring Boot 简单集成 MongoDB

我会带着你远行 2023-06-29 01:58 15阅读 0赞

MongoDB  如今是最流⾏的  NoSQL  数据库，被⼴泛应⽤于各⾏各业中，很多创业公司数据库选型就直接使⽤

了  MongoDB ，但对于⼤部分公司，使⽤  MongoDB  的场景是做⼤规模数据查询和离线分析。 MongoDB  ⼀经

推出就受到了⼴⼤社区的热爱，可以说是对程序员最友好的⼀种数据库，下⾯我们来了解⼀下它的特性。

### **MongoDB** 简介 ###

MongoDB （ Humongous ，庞⼤）是可以应⽤于各种规模的企业、各个⾏业以及各类应⽤程序的开源数据

库，作为⼀个适⽤于敏捷开发的数据库， MongoDB  的数据模式可以随着应⽤程序的发展⽽灵活地更新。与

此同时，它也为开发⼈员提供了传统数据库的功能：⼆级索引、完整的查询系统及严格⼀致性等。 MongoDB

能够使企业更加具有敏捷性和可扩展性，各种规模的企业都可以通过使⽤  MongoDB  来创建新的应⽤，来提

⾼与客户之间的⼯作效率，加快产品上市时间，以及降低企业成本。

MongoDB  是专⻔为可扩展性、⾼性能和⾼可⽤性⽽设计的数据库，它可以从单服务器部署扩展到⼤型、复

杂的多数据中⼼架构。利⽤内存计算的优势， MongoDB  能够提供⾼性能的数据读写操作。  MongoDB  的本

地复制和⾃动故障转移功能使应⽤程序具有企业级的可靠性和操作灵活性。

### **MongoDB** 相关概念 ###

在学习  MongoDB  之前需要先了解⼀些专业术语，常说  MongoDB  是最像关系数据库的  NoSQL  数据库，我

们⽤关系数据库和  MongoDB  做⼀下对⽐，⽅便更清晰地认识它。

<table style="margin-left:11.8pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:95.3pt;"> SQL 术语/概念 </td> 
 <td style="vertical-align:top;width:125.75pt;"> MongoDB 术语/概念 </td> 
 <td style="vertical-align:top;width:241.85pt;"> 解释/说明 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:95.3pt;"> DataBase </td> 
 <td style="vertical-align:top;width:125.75pt;"> DataBase </td> 
 <td style="vertical-align:top;width:241.85pt;"> 数据库 </td> 
 </tr> 
 <tr> 
 <td style="width:95.3pt;"> Table </td> 
 <td style="width:125.75pt;"> Collection </td> 
 <td style="width:241.85pt;"> 数据库表/集合 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:95.3pt;"> Row </td> 
 <td style="vertical-align:top;width:125.75pt;"> Document </td> 
 <td style="vertical-align:top;width:241.85pt;"> 数据记录⾏行行/⽂文档 </td> 
 </tr> 
 <tr> 
 <td style="width:95.3pt;"> Column </td> 
 <td style="width:125.75pt;"> Field </td> 
 <td style="width:241.85pt;"> 数据字段/域 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:95.3pt;"> index </td> 
 <td style="vertical-align:top;width:125.75pt;"> index </td> 
 <td style="vertical-align:top;width:241.85pt;"> 索引 </td> 
 </tr> 
 <tr> 
 <td style="width:95.3pt;"> Table joins </td> 
 <td style="width:125.75pt;"> &nbsp; </td> 
 <td style="width:241.85pt;"> 表连接，MongoDB 不不⽀支持 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:95.3pt;"> primary key </td> 
 <td style="vertical-align:top;width:125.75pt;"> primary key </td> 
 <td style="vertical-align:top;width:241.85pt;"> 主键，MongoDB ⾃自动将 _id 字段设置为主键 </td> 
 </tr> 
 </tbody> 
</table>

MongoDB  和关系数据库⼀样有库的概念，⼀个  MongoDB  数据库可以有很多数据库， MongoDB  中的集合就

相当于我们关系数据库中的表，⽂档就相当于关系数据库中的⾏，域就相当于关系数据库中的列， MongoDB

也⽀持各种索引有唯⼀主键，但不⽀持表连接查询。

### **Spring Boot MongoDB**  ###

Spring Boot  操作数据库的各种  Starters  都继承于  Spring Data ， Spring Data  是  Spring  为了简化数据库操作

⽽封装的⼀个组件包，提供了操作多种数据库的⽀持，其  API  简洁、调⽤⽅便。

spring-boot-starter-data-mongodb  是  Spring Data  的⼀个⼦模块。⽬标是为  MongoDB  提供⼀个相近的、⼀

致的、基于  Spring  的编程模型。 spring-boot-starter-data-mongodb  核⼼功能是映射  POJO  到  Mongo  的

DBCollection  中的⽂档，并且提供  Repository  ⻛格数据访问层。

我们使⽤  Spring Boot  进⾏  MongoDB  连接，需要使⽤  spring-boot-starter-data-mongodb  包。 spring-boot

starter-data-mongodb  继承  Spring Data  的通⽤功能外，针对  MongoDB  的特性开发了很多定制的功能，让

我们使⽤  Spring Boot  操作  MongoDB  更加简便。

Spring Boot  操作  MongoDB  有两种⽐较流⾏的使⽤⽅法，⼀种是将  MongoTemplate  直接注⼊到  Dao  中使

⽤，⼀种是继承  MongoRepository ， MongoRepository  内置了很多⽅法可直接使⽤。

我们分别来介绍它们的使⽤。

### **MongoTemplate** 的使⽤  ###

MongoTemplate  提供了⾮常多的操作  MongoDB  ⽅法，它是线程安全的，可以在多线程的情况下使⽤。

MongoTemplate  实现了  MongoOperations  接⼝ ,  此接⼝定义了众多的操作⽅法如  fifind 、 fifindAndModify 、

fifindOne 、 insert 、 remove 、 save 、 update and updateMulti  等。它转换  domain object  为  DBObject ，并提供

了  Query 、 Criteria and Update  等流式  API 。

我们后⾯在使⽤动态查询时候会⽤到  DBObject  对象的操作。

### （**1**）**pom** 包配置 ###

pom  包⾥⾯添加  spring-boot-starter-data-mongodb  包引⽤：

<dependencies>
 <dependency> 
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-mongodb</artifactId>
 </dependency> 
 </dependencies>

### （**2**）在 **application.properties** 中添加配置 ###

spring.data.mongodb.uri=mongodb://name:pass@localhost:27017/test

多个  IP  集群可以采⽤以下配置：

spring.data.mongodb.uri=mongodb://user:pwd@ip1:port1,ip2:port2/database

当然了密码和⽤户名如果没有设置可以不⽤添加，像这样：

spring.data.mongodb.uri=mongodb://localhost:27017/test

注： Mongo 3.0 Java  驱动不⽀持  spring.data.mongodb.host  和  spring.data.mongodb.port ，对于这种情

况， spring.data.mongodb.uri  需要提供全部的配置信息。

### （**3**）创建数据实体 ###

public class User implements Serializable {
     private static final long serialVersionUID = -3258839839160856613L;
     private Long id;
     private String userName;
     private String passWord;
     //getter、setter 省略
    }

### （**4**）对实体进⾏增删改查操作  ###

Repository  层实现了  User  对象的增、删、改、查功能。

⾸先将  MongoTemplate  注⼊到实体类中：

@Component
    public class UserRepositoryImpl implements UserRepository {
     @Autowired
     private MongoTemplate mongoTemplate;
    }

做增、删、改、查功能时，直接使⽤即可。

添加数据：

@Override
    public void saveUser(UserEntity user) {
     mongoTemplate.save(user);
    }

save  ⽅法中会进⾏判断，如果对象包含了  ID  信息就会进⾏更新，如果没有包含  ID  信息就⾃动保存。

根据⽤户名查询对象：

@Override
    public User findUserByUserName(String userName) {
     Query query=new Query(Criteria.where("userName").is(userName));
     User user = mongoTemplate.findOne(query , User.class);
     return user;
    }

更新对象⽐较灵活，可以选择更新⼀条数据，或者更新多条数据。

@Override
    public long updateUser(User user) {
     Query query=new Query(Criteria.where("id").is(user.getId()));
     Update update= new Update().set("userName", user.getUserName()).set("passWord"
    , user.getPassWord());
     //更新查询返回结果集的第⼀条
     UpdateResult result =mongoTemplate.updateFirst(query,update,User.class);
     //更新查询返回结果集的所有
     // mongoTemplate.updateMulti(query,update,UserEntity.class);
     if(result!=null)
     return result.getMatchedCount();
     else
     return 0;
    }

删除对象：

@Override
    public void deleteUserById(Long id) {
     Query query=new Query(Criteria.where("id").is(id));
     mongoTemplate.remove(query,User.class);
    }

### （**5**）开发对应的测试⽅法  ###

测试时注⼊封装好的  UserRepository ，根据情况调⽤对应的⽅法即可：

@RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserRepositoryTest {
     @Autowired
     private UserRepository userRepository;
    }

测试插⼊数据：

@Test
    public void testSaveUser() throws Exception {
     User user=new User();
     user.setId(2l);
     user.setUserName("⼩明");
     user.setPassWord("fffooo123");
     userRepository.saveUser(user);
    }

测试查询⽅法：

@Test
    public void findUserByUserName(){
     User user= userRepository.findUserByUserName("⼩明");
     System.out.println("user is "+user);
    }

测试更新：

@Test
    public void updateUser(){
     User user=new User();
     user.setId(2l);
     user.setUserName("天空");
     user.setPassWord("fffxxxx");
     userRepository.updateUser(user);
    }

最后测试删除：

@Test
    public void deleteUserById(){
     userRepository.deleteUserById(1L);
    }

### （**6**）查看验证结果  ###

可以使⽤⼯具  Robo 3T  来连接后直接图形化展示查看，也可以登录服务器⽤命令来查看。

a. 登录  mongos ：

bin/mongo -host localhost -port 20000

b. 切换到  test  库：

use test

c. 查询  userEntity  集合数据：

db.user.find()

根据  c  查询的结果来观察测试⽤例的执⾏是否正确，到此  MongoTemplate  的增、删、改、查功能已经全部

实现。

### **MongoRepository** 的使⽤  ###

MongoRepository  继承于  PagingAndSortingRepository ，再往上就是  CrudRepository ，根据下⾯的类图可以

看出  MongoRepository  和前⾯  JPA 、 Elasticsearch  的使⽤⽐较类似，都是  Spring Data  家族的产品，最终使

⽤⽅法也就和  JPA 、 ElasticSearch  的使⽤⽅式类似，可以根据⽅法名⾃动⽣成  SQL  来查询。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MjI3ODk2_size_16_color_FFFFFF_t_70][]

MongoRepository  项⽬结构和上⾯类似，只有  Repository  层的代码有所变化，如下：

public interface UserRepository extends MongoRepository<UserEntity, Long> {
 UserEntity findByUserName(String userName);
 }

我们新建  UserRepository  需要继承  MongoRepository ，这样就可直接使⽤  MongoRepository  的内置⽅法。

使⽤ UserRepository 进⾏增、删、改、查功能，⾸先将 UserRepository 注⼊到类中：

@RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserDaoTest {
     @Autowired
     private UserRepository userRepository;
    }

集成  MongoRepository  会默认实现很多的内置⽅法，其中就包括保持、删除等操作。

测试保存数据：

@Test
    public void testSaveUser() throws Exception {
     User user=new User();
     user.setId(i);
     user.setUserName("⼩明"+i);
     user.setPassWord("fffooo123");
     userRepository.save(user);
    }

测试根据属性查询：

@Test
    public void findUserByUserName(){
     User user= userRepository.findByUserName("⼩明");
     System.out.println("user is "+user);
    }

测试更新属性，保存和更新都使⽤的是  save()  ⽅法，内部会根据实体是否有注解来判断是⽤来更新还是⽤来

保存。

@Test
    public void updateUser(){
     User user=new User();
     user.setId(2l);
     user.setUserName("天空");
     user.setPassWord("fffxxxx");
     userRepository.save(user);
    }

测试删除数据：

@Test
    public void deleteUserById(){
     userRepository.delete(1l);
    }

我们发现  UserRepository  已经⾃动实现了常⽤的数据库操作，不⽤像使⽤  MongoTemplate  那样需要⼿动来

实现。

如果想使⽤分⻚怎么办？只需要在  UserRepository  再加⼊⼀个空⽅法，不需要⾃⼰实现。

Page<UserEntity> findAll(Pageable var1);

⾸先使⽤  save  ⽅法插⼊  100  个  UserEntity ：

@Test
 public void testSaveUser() throws Exception {
 for (long i=0;i<100;i++) {
 User user=new User();
 user.setId(i);
 user.setUserName("⼩明"+i);
 user.setPassWord("fffooo123");
 userRepository.save(user);
 }
 }

返回测试分⻚，设置以  ID  的倒叙排序，每⻚  10  条数据，取第⼆⻚的⽤户列表。

@Test
    public void testPage(){
     Sort sort = new Sort(Sort.Direction.DESC, "id");
     Pageable pageable = PageRequest.of(2, 10, sort);
     Page page=userRepository.findAll(pageable);
     System.out.println("users: "+page.getContent().toString());
    }

*  Pageable 是 Spring Data 库中定义的⼀个接⼝，该接⼝是所有分⻚相关信息的⼀个抽象，通过该接⼝， 可以得到和分⻚相关所有信息（如 pageNumber、pageSize 等），这样，JPA 就能够通过 pageable 参 数来得到⼀个带分⻚信息的 SQL 语句。 
 *  Page 类也是 Spring Data 提供的⼀个接⼝，该接⼝表示⼀部分数据的集合以及其相关的下⼀部分数据、 数据总数等相关信息，通过该接⼝，可以得到数据的总体信息（数据总数、总⻚数...）以及当前数据的 信息（当前数据的集合、当前⻚数等）。

在  Spring Boot 2.0  中  new PageRequest(2, 10, sort)  已经过期不再推荐使⽤， 2.0  中推荐使⽤

PageRequest.of(2, 10, sort)  来做排序参数控制。

我们发现使⽤  Repository  的⽅式和前⼏课介绍的  Spring Boot JPA  ⾮常相似，其实  spring-boot-starter-data

mongodb  和  Spring-boot-starter-data-jpa  都来⾃于  Spring Data  ⼤家族，它们的实现原理基本⼀致，因此使

⽤  Repository  完全可以参考前⾯课程  JPA  ⽤法。

## ##

### 多数据源 **MongoDB** 的使⽤  ###

我们来学习在多数据源的情况下，如何使⽤  MongoDB 。

### （**1**）添加配置  ###

⾸先在配置⽂件中添加不同的数据源，配置⽂件添加两条数据源，如下：

mongodb.primary.uri=mongodb://192.168.0.1:27017
    mongodb.primary.database=primary
    mongodb.secondary.uri=mongodb://192.168.0.1:27017
    mongodb.secondary.database=secondary

如果使⽤的是  MongoDB  集群可以这样配置：

mongodb.xxx.uri=mongodb://192.168.0.1:27017,192.168.0.2:27017,192.168.0.3:27017
    mongodb.xxx.database=xxx

### （**2**）配置数据源  ###

封装读取以  MongoDB  开头的两个配置⽂件：

@Data
    @ConfigurationProperties(prefix = "mongodb")
    public class MultipleMongoProperties {
     private MongoProperties primary = new MongoProperties();
     private MongoProperties secondary = new MongoProperties();
     //省略 getter、setter
    }

创建  MultipleMongoConfifig  类分别创建两个数据源的  MongoTemplate 。

@Configuration
    public class MultipleMongoConfig {
     @Autowired
     private MultipleMongoProperties mongoProperties;
    }

根据配置⽂件信息构建第⼀个数据源的  MongoDbFactory 。

@Bean
    @Primary
    public MongoDbFactory primaryFactory(MongoProperties mongo) throws Exception {
     MongoClient client = new MongoClient(new MongoClientURI(mongoProperties.getPri
    mary().getUri()));
     return new SimpleMongoDbFactory(client, mongoProperties.getPrimary().getDataba
    se());
    }

利⽤上⾯构建好的  MongoDbFactory  创建对应的  MongoTemplate  。

@Primary
    @Bean(name = "primaryMongoTemplate")
    public MongoTemplate primaryMongoTemplate() throws Exception {
     return new MongoTemplate(primaryFactory(this.mongoProperties.getPrimary()));
    }

最后将  MongoTemplate  信息注⼊到对应的包路径下：

@Configuration
    @EnableConfigurationProperties(MultipleMongoProperties.class)
    @EnableMongoRepositories(basePackages = "com.neo.repository.primary",
     mongoTemplateRef = "primaryMongoTemplate")
    public class PrimaryMongoConfig {
    }

以上第⼀个数据源就配置完成了，第⼆个数据源的配置过程类似，⼤家可以直接看课程演示项⽬。总结⼀下

封装过程：读取配置信息封装为  Properties ，根据  Properties  信息构建  Factory ，再由  Factory  构建出最后需

要使⽤的  MongoTemplate ， MongoTemplate  在根据包路径配置注⼊到对应的包下。

### （**3**）创建两个库分别对应的对象和 **Repository**  ###

public class User implements Serializable {
     private static final long serialVersionUID = -3258839839160856613L;
     private String id;
     private String userName;
     private String passWord;
     //省略getter setter
    }

对应的  Repository ：

public interface PrimaryRepository extends MongoRepository<User, String> {
 }

继承了  MongoRepository  会默认实现很多基本的增、删、改、查功能，省了很多⾃⼰写  Dao  层的代码，

Secondary  和上⾯的代码类似就不贴出来了。

### （**4**）最后测试 ###

@RunWith(SpringRunner.class)
 @SpringBootTest
 public class MuliDatabaseTest {
 @Autowired
 private PrimaryRepository primaryRepository;
 @Autowired
 private SecondaryRepository secondaryRepository;
 @Test
 public void TestSave() {
 this.primaryRepository.save(new User("⼩张", "123456"));
 this.secondaryRepository.save(new User("⼩王", "654321"));
 List<User> primaries = this.primaryRepository.findAll();
 for (User primary : primaries) {
 System.out.println(primary.toString());
 }
 List<User> secondaries = this.secondaryRepository.findAll();
 for (User secondary : secondaries) {
 System.out.println(secondary.toString());
 }
 }
 }

输出内容如下：

com.neo.entity.UserEntity@2a3a299[id=5a0ed2d7439f6618ac294ba6,userName=⼩张,passWor
    d=123456]
    com.neo.entity.UserEntity@5b989dc7[id=5a0ed2d7439f6618ac294ba7,userName=⼩王,passWo
    rd=654321]

使⽤  Robo 3T  分别查看两个库的数据，均已经有对应的  User  对象，说明多数据源使⽤测试成功。

### 总结  ###

两种⽅式都可以⽅便地操作  MongoDB  数据库， MongoTemplate  模式⽐较灵活可以根据⾃⼰的使⽤情况进⾏

组装， MongoRepository  的使⽤⽅式更简单，因为继承了  Spring Data ，所以默认实现了很多基础的增、

删、改、查功能，业务直接拿来使⽤即可。简单⽇常的使⽤推荐  MongoRepository ，简单⽅便利于项⽬快速

开发，复杂多变的查询推荐使⽤  MongoTemplate  ⾃⾏进⾏封装。

[点击这⾥下载源码][Link 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MjI3ODk2_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200109184542797.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0MjI3ODk2,size_16,color_FFFFFF,t_70
[Link 1]: https://github.com/ityouknow/spring-boot-leaning/tree/gitbook_column2.0