mongodb是最早热门非关系数据库的之一，使用也比较普遍，一般会用做离线数据分析来使用，放到内网的居多。由于很多公司使用了云服务，服务器默认都开放了外网地址，导致前一阵子大批 MongoDB 因配置漏洞被攻击，数据被删，引起了人们的注意，感兴趣的可以看看这篇文章：场屠戮MongoDB的盛宴反思：超33000个数据库遭遇入侵勒索，同时也说明了很多公司生产中大量使用mongodb。

mongodb简介

MongoDB（来自于英文单词“Humongous”，中文含义为“庞大”）是可以应用于各种规模的企业、各个行业以及各类应用程序的开源数据库。基于分布式文件存储的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB是一个高性能，开源，无模式的文档型数据库，是当前NoSql数据库中比较热门的一种。

MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构非常松散，是类似json的bjson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。

传统的关系数据库一般由数据库（database）、表（table）、记录（record）三个层次概念组成，MongoDB是由数据库（database）、集合（collection）、文档对象（document）三个层次组成。MongoDB对于关系型数据库里的表，但是集合中没有列、行和关系概念，这体现了模式自由的特点。

MongoDB中的一条记录就是一个文档，是一个数据结构，由字段和值对组成。MongoDB文档与JSON对象类似。字段的值有可能包括其它文档、数组以及文档数组。MongoDB支持OS X、Linux及Windows等操作系统，并提供了Python，PHP，Ruby，Java及C++语言的驱动程序，社区中也提供了对Erlang及.NET等平台的驱动程序。

MongoDB的适合对大量或者无固定格式的数据进行存储，比如：日志、缓存等。对事物支持较弱，不适用复杂的多文档（多表）的级联查询。文中演示mongodb版本为3.4。

mongodb的增删改查

Spring Boot对各种流行的数据源都进行了封装，当然也包括了mongodb,下面给大家介绍如何在spring boot中使用mongodb：

1、pom包配置

pom包里面添加spring-boot-starter-data-mongodb包引用

  1. <dependencies>
  2.     <dependency> 
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-data-mongodb</artifactId>
  5.     </dependency> 
  6. </dependencies>

2、在application.properties中添加配置

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

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

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

2、创建数据实体

  1. public class UserEntity implements Serializable {
  2.         private static final long serialVersionUID = -3258839839160856613L;
  3.         private Long id;
  4.         private String userName;
  5.         private String passWord;
  7.       //getter、setter省略
  8. }

3、创建实体dao的增删改查操作

dao层实现了UserEntity对象的增删改查

  1. @Component
  2. public class UserDaoImpl implements UserDao {
  4.     @Autowired
  5.     private MongoTemplate mongoTemplate;
  7.     /**
  8.      * 创建对象
  9.      * @param user
  10.      */
  11.     @Override
  12.     public void saveUser(UserEntity user) {
  13.         mongoTemplate.save(user);
  14.     }
  16.     /**
  17.      * 根据用户名查询对象
  18.      * @param userName
  19.      * @return
  20.      */
  21.     @Override
  22.     public UserEntity findUserByUserName(String userName) {
  23.         Query query=new Query(Criteria.where("userName").is(userName));
  24.         UserEntity user =  mongoTemplate.findOne(query , UserEntity.class);
  25.         return user;
  26.     }
  28.     /**
  29.      * 更新对象
  30.      * @param user
  31.      */
  32.     @Override
  33.     public void updateUser(UserEntity user) {
  34.         Query query=new Query(Criteria.where("id").is(user.getId()));
  35.         Update update= new Update().set("userName", user.getUserName()).set("passWord", user.getPassWord());
  36.         //更新查询返回结果集的第一条
  37.         mongoTemplate.updateFirst(query,update,UserEntity.class);
  38.         //更新查询返回结果集的所有
  39.         // mongoTemplate.updateMulti(query,update,UserEntity.class);
  40.     }
  42.     /**
  43.      * 删除对象
  44.      * @param id
  45.      */
  46.     @Override
  47.     public void deleteUserById(Long id) {
  48.         Query query=new Query(Criteria.where("id").is(id));
  49.         mongoTemplate.remove(query,UserEntity.class);
  50.     }
  51. }

4、开发对应的测试方法

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class UserDaoTest {
  5.     @Autowired
  6.     private UserDao userDao;
  8.     @Test
  9.     public void testSaveUser() throws Exception {
  10.         UserEntity user=new UserEntity();
  11.         user.setId(2l);
  12.         user.setUserName("小明");
  13.         user.setPassWord("fffooo123");
  14.         userDao.saveUser(user);
  15.     }
  17.     @Test
  18.     public void findUserByUserName(){
  19.        UserEntity user= userDao.findUserByUserName("小明");
  20.        System.out.println("user is "+user);
  21.     }
  23.     @Test
  24.     public void updateUser(){
  25.         UserEntity user=new UserEntity();
  26.         user.setId(2l);
  27.         user.setUserName("天空");
  28.         user.setPassWord("fffxxxx");
  29.         userDao.updateUser(user);
  30.     }
  32.     @Test
  33.     public void deleteUserById(){
  34.         userDao.deleteUserById(1l);
  35.     }
  37. }

5、查看验证结果

可以使用工具mongoVUE工具来连接后直接图形化展示查看，也可以登录服务器用命令来查看

1.登录mongos

bin/mongo -host localhost -port 20000

2、切换到test库

use test

3、查询userEntity集合数据

db.userEntity.find()

根据3查询的结果来观察测试用例的执行是否正确。

到此springboot对应mongodb的增删改查功能已经全部实现。

多数据源mongodb的使用

在多mongodb数据源的情况下，我们换种更优雅的方式来实现

1、pom包配置

添加lombok和spring-boot-autoconfigure包引用

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-data-mongodb</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>org.projectlombok</groupId>
  7.     <artifactId>lombok</artifactId>
  8. </dependency>
  9. <dependency>
  10.     <groupId>org.springframework.boot</groupId>
  11.     <artifactId>spring-boot-autoconfigure</artifactId>
  12.     <version>RELEASE</version>
  13. </dependency>

  • Lombok - 是一个可以通过简单的注解形式来帮助我们简化消除一些必须有但显得很臃肿的Java代码的工具，通过使用对应的注解，可以在编译源码的时候生成对应的方法。简单试了以下这个工具还挺好玩的，加上注解我们就不用手动写 getter\setter、构建方式类似的代码了。

  • spring-boot-autoconfigure - 就是spring boot的自动化配置

2、配置文件使用YAML的形式添加两条数据源，如下：

  1. mongodb:
  2.   primary:
  3.     host: 192.168.9.60
  4.     port: 20000
  5.     database: test
  6.   secondary:
  7.     host: 192.168.9.60
  8.     port: 20000
  9.     database: test1

3、配置两个库的数据源

封装读取以mongodb开头的两个配置文件

  1. @Data
  2. @ConfigurationProperties(prefix = "mongodb")
  3. public class MultipleMongoProperties {
  5.     private MongoProperties primary = new MongoProperties();
  6.     private MongoProperties secondary = new MongoProperties();
  7. }

配置不同包路径下使用不同的数据源

第一个库的封装

  1. @Configuration
  2. @EnableMongoRepositories(basePackages = "com.neo.model.repository.primary",
  3.         mongoTemplateRef = PrimaryMongoConfig.MONGO_TEMPLATE)
  4. public class PrimaryMongoConfig {
  6.     protected static final String MONGO_TEMPLATE = "primaryMongoTemplate";
  7. }

第二个库的封装

  1. @Configuration
  2. @EnableMongoRepositories(basePackages = "com.neo.model.repository.secondary",
  3.         mongoTemplateRef = SecondaryMongoConfig.MONGO_TEMPLATE)
  4. public class SecondaryMongoConfig {
  6.     protected static final String MONGO_TEMPLATE = "secondaryMongoTemplate";
  7. }

读取对应的配置信息并且构造对应的MongoTemplate

  1. @Configuration
  2. public class MultipleMongoConfig {
  4.     @Autowired
  5.     private MultipleMongoProperties mongoProperties;
  7.     @Primary
  8.     @Bean(name = PrimaryMongoConfig.MONGO_TEMPLATE)
  9.     public MongoTemplate primaryMongoTemplate() throws Exception {
  10.         return new MongoTemplate(primaryFactory(this.mongoProperties.getPrimary()));
  11.     }
  13.     @Bean
  14.     @Qualifier(SecondaryMongoConfig.MONGO_TEMPLATE)
  15.     public MongoTemplate secondaryMongoTemplate() throws Exception {
  16.         return new MongoTemplate(secondaryFactory(this.mongoProperties.getSecondary()));
  17.     }
  19.     @Bean
  20.     @Primary
  21.     public MongoDbFactory primaryFactory(MongoProperties mongo) throws Exception {
  22.         return new SimpleMongoDbFactory(new MongoClient(mongo.getHost(), mongo.getPort()),
  23.                 mongo.getDatabase());
  24.     }
  26.     @Bean
  27.     public MongoDbFactory secondaryFactory(MongoProperties mongo) throws Exception {
  28.         return new SimpleMongoDbFactory(new MongoClient(mongo.getHost(), mongo.getPort()),
  29.                 mongo.getDatabase());
  30.     }
  31. }

两个库的配置信息已经完成。

4、创建两个库分别对应的对象和Repository

借助lombok来构建对象

  1. @Data
  2. @AllArgsConstructor
  3. @NoArgsConstructor
  4. @Document(collection = "first_mongo")
  5. public class PrimaryMongoObject {
  7.     @Id
  8.     private String id;
  10.     private String value;
  12.     @Override
  13.     public String toString() {
  14.         return "PrimaryMongoObject{" + "id='" + id + '\'' + ", value='" + value + '\''
  15.                 + '}';
  16.     }
  17. }

对应的Repository

  1. public interface PrimaryRepository extends MongoRepository<PrimaryMongoObject, String> {
  2. }

继承了 MongoRepository 会默认实现很多基本的增删改查，省了很多自己写dao层的代码

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

5、最后测试

  1. @RunWith(SpringRunner.class)
  2. @SpringBootTest
  3. public class MuliDatabaseTest {
  5.     @Autowired
  6.     private PrimaryRepository primaryRepository;
  8.     @Autowired
  9.     private SecondaryRepository secondaryRepository;
  11.     @Test
  12.     public void TestSave() {
  14.         System.out.println("************************************************************");
  15.         System.out.println("测试开始");
  16.         System.out.println("************************************************************");
  18.         this.primaryRepository
  19.                 .save(new PrimaryMongoObject(null, "第一个库的对象"));
  21.         this.secondaryRepository
  22.                 .save(new SecondaryMongoObject(null, "第二个库的对象"));
  24.         List<PrimaryMongoObject> primaries = this.primaryRepository.findAll();
  25.         for (PrimaryMongoObject primary : primaries) {
  26.             System.out.println(primary.toString());
  27.         }
  29.         List<SecondaryMongoObject> secondaries = this.secondaryRepository.findAll();
  31.         for (SecondaryMongoObject secondary : secondaries) {
  32.             System.out.println(secondary.toString());
  33.         }
  35.         System.out.println("************************************************************");
  36.         System.out.println("测试完成");
  37.         System.out.println("************************************************************");
  38.     }
  40. }

到此，mongodb多数据源的使用已经完成。