目录

1. 配置
2. Maven Dependencies
3. 项目结构
4. 创建数据库
5. 应用配置
   1. 建立模型
   2. 定义数据访问层接口
   3. 实施数据访问层
   4. 使用分页查询
   5. 通过精确值获取对象
   6. 按范围和数据列表查找
   7. 更新对象
   8. 删除对象
   9. 制作命令行运行器
6. 结论

​ 在本教程中，我们将构建一个Spring Boot应用程序，该应用程序演示如何使用MongoTemplate API访问MongoDB数据库中的数据。

​ 对于MongoDB，我们将使用mLab，它提供了MongoDB数据库即服务平台，因此您甚至不必在计算机上安装MongoDB数据库。

配置

​ 为了快速设置我们的项目，我们将使用一个称为Spring Initializr的工具。使用此工具，我们可以快速提供所需的依赖项列表并下载引导程序：

使用Spring Initializr创建新的Spring Boot项目时，仅选择两个依赖项：

• Web (Spring Boot Starter Web)
• MongoDB (MongoDB Starter)

Maven Dependencies

当下载使用Spring Initializr生成的项目并打开其pom.xml文件时，您应该看到添加了以下依赖项：

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

  <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-test</artifactId>
     <scope>test</scope>
  </dependency>
</dependencies>

<build>
  <plugins>
     <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
     </plugin>
  </plugins>
</build>

项目结构

在继续进行并开始处理该项目的代码之前，让我们介绍一下完成所有代码添加到项目后将拥有的项目结构：

该代码以多个程序包进行组织，因此遵循关注点分离的原则，并且代码保持模块化。

创建数据库

​ 对于MongoDB，我们将使用mLab。您可以使用mLab创建一个免费帐户，并在云中使用MongoDB，而无需在计算机上下载和安装它。

登录到mLab后，您将看到一个类似的仪表板：

要创建一个新的MongoDB数据库，请单击创建新按钮：

输入所有详细信息后，我们可以确认：

完成此操作后，我们将看到一个连接字符串，如下图所示：

在开始使用此数据库之前，我们还需要创建一个用户。让我们在上图所示的“用户”标签上执行此操作：

现在，我们已经准备好继续写些Java代码，因为我们的mLab数据库已经完全准备就绪。

应用配置

使用Spring Boot，仅使用MongoDB连接String的单个必需属性即可轻松配置我们的应用程序：

# application properties
server.port=8090

# MongoDB properties
spring.data.mongodb.uri=mongodb://cicoding.cn:password@ds915721.mlab.com:29670/cicoding_db

我们只是提供了一个MongoDB连接字符串，该字符串将由Spring Boot读取，并且将使用内部API建立连接。

建立模型

我们将创建一个简单的Person实体，其中包含一些字段，我们将使用它们来演示简单的MongoDB查询：

package com.cicoding.mongotemplatedemo.model;

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Locale;

import static java.util.Calendar.DATE;
import static java.util.Calendar.MONTH;
import static java.util.Calendar.YEAR;

@Document(collection = "person")
public class Person {

   @Id
   private String personId;
   private String name;
   private long age;
   private List<String> favoriteBooks;
   private Date dateOfBirth;

   public Person() {
   }

   public Person(String name, List<String> childrenName, Date dateOfBirth) {
       this.name = name;
       this.favoriteBooks = childrenName;
       this.dateOfBirth = dateOfBirth;
       this.age = getDiffYears(dateOfBirth, new Date());
   }

   // standard getters and setters

   private int getDiffYears(Date first, Date last) {
       Calendar a = getCalendar(first);
       Calendar b = getCalendar(last);
       int diff = b.get(YEAR) - a.get(YEAR);
       if (a.get(MONTH) > b.get(MONTH) ||
               (a.get(MONTH) == b.get(MONTH) && a.get(DATE) > b.get(DATE))) {
           diff--;
       }
       return diff;
   }

   private Calendar getCalendar(Date date) {
       Calendar cal = Calendar.getInstance(Locale.US);
       cal.setTime(date);
       return cal;
   }

   @Override
   public String toString() {
       return String.format("Person{personId='%s', name='%s', age=%d, dateOfBirth=%s}\n",
               personId, name, age, dateOfBirth);
   }
}

除了简单的字段外，我们还添加了一些帮助程序功能，可以在保存用户的出生日期时计算该用户的年龄。这使我们不必计算用户的年龄。

定义数据访问层接口

让我们定义一个数据层接口，该接口将通知我们在应用程序中将演示多少操作。这是界面：

public interface PersonDAL {
   Person savePerson(Person person);
   List<Person> getAllPerson();
   List<Person> getAllPersonPaginated(
      int pageNumber, int pageSize);
   Person findOneByName(String name);
   List<Person> findByName(String name);
   List<Person> findByBirthDateAfter(Date date);
   List<Person> findByAgeRange(int lowerBound, int upperBound);
   List<Person> findByFavoriteBooks(String favoriteBook);
   void updateMultiplePersonAge();
   Person updateOnePerson(Person person);
   void deletePerson(Person person);
}

这些是相当多的操作。真正的乐趣是当我们执行这些操作时，接下来将要做的事情。

实施数据访问层

我们将使用MongoTemplate bean，它是由Spring Boot使用上面在application.properties中定义的属性初始化的。让我们看看如何定义所需的bean：

@Repository
public class PersonDALImpl implements PersonDAL {

    private final MongoTemplate mongoTemplate;

    @Autowired
    public PersonDALImpl(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }

    ...
}

我们将开始使用简单的方法来理解查询，首先是要保存并从数据库中获取所有人员：

@Override
public Person savePerson(Person person) {
   mongoTemplate.save(person);
   return person;
}

@Override
public List<Person> getAllPerson() {
   return mongoTemplate.findAll(Person.class);
}

MongoTemplate为我们提供了一些抽象方法，通过这些方法我们可以将对象保存到数据库中，也可以从数据库中获取所有数据。

使用分页查询

上述从数据库中获取所有人的方法的问题在于，数据库中可能有数千个对象。 我们应该始终在查询中实现分页，以便可以确保仅从数据库中提取有限的数据：

@Override
public List<Person> getAllPersonPaginated(int pageNumber, int pageSize) {
   Query query = new Query();
   query.skip(pageNumber * pageSize);
   query.limit(pageSize);

   return mongoTemplate.find(query, Person.class);
}

这样，一次将仅从数据库中获取pageSize个对象。

通过精确值获取对象

我们也可以通过匹配数据库中的精确值来提取对象：

@Override
public Person findOneByName(String name) {
   Query query = new Query();
   query.addCriteria(Criteria.where("name").is(name));

   return mongoTemplate.findOne(query, Person.class);
}

@Override
public List<Person> findByName(String name) {
   Query query = new Query();
   query.addCriteria(Criteria.where("name").is(name));

   return mongoTemplate.find(query, Person.class);
}

我们展示了两种方法。第一种方法是从数据库中获取单个对象，而第二种方法是从数据库中获取具有匹配条件的所有对象。

按范围和数据列表查找

我们还可以找到具有指定范围内的字段值的对象。或具有特定日期之后的日期数据的对象。让我们看看如何做到这一点，以及如何构造相同的查询：

@Override
public List<Person> findByBirthDateAfter(Date date) {
   Query query = new Query();
   query.addCriteria(Criteria.where("dateOfBirth").gt(date));

   return mongoTemplate.find(query, Person.class);
}

@Override
public List<Person> findByAgeRange(int lowerBound, int upperBound) {
   Query query = new Query();
   query.addCriteria(Criteria.where("age").gt(lowerBound)
           .andOperator(Criteria.where("age").lt(upperBound)));

   return mongoTemplate.find(query, Person.class);
}

@Override
public List<Person> findByFavoriteBooks(String favoriteBook) {
   Query query = new Query();
   query.addCriteria(Criteria.where("favoriteBooks").in(favoriteBook));
   return mongoTemplate.find(query, Person.class);
}

更新对象

我们可以使用Update查询更新MongoDB中的数据。我们可以找到一个对象，然后自己更新提供的字段：

@Override
public void updateMultiplePersonAge() {

   Query query = new Query();
   Update update = new Update().inc("age", 1);
   mongoTemplate.findAndModify(query, update, Person.class);;
}

@Override
public Person updateOnePerson(Person person) {
   mongoTemplate.save(person);
   return person;
}

在第一个查询中，由于没有向查询添加任何条件，因此我们收到了所有对象。接下来，我们提供了一个Update子句，其中所有用户的年龄都增加了一个。

删除对象

删除对象也与单个方法调用有关：

@Override
public void deletePerson(Person person) {
   mongoTemplate.remove(person);
}

我们也可以简单地传递Query对象以及要删除的人的ID。

制作命令行运行器

我们将在适当的位置使用命令行运行程序来运行我们的应用程序，该命令行运行程序将提供我们在上面的数据访问层实现中定义的一些功能。这是命令行运行器：

package com.cicoding.mongotemplatedemo;

import com.cicoding.mongotemplatedemo.dal.PersonDAL;
import com.cicoding.mongotemplatedemo.model.Person;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.util.Arrays;
import java.util.Date;

@SpringBootApplication
public class MongoTemplateApp implements CommandLineRunner {

  private static final Logger LOG = LoggerFactory.getLogger("cicoding");

  private final PersonDAL personDAL;

  @Autowired
  public MongoTemplateApp(PersonDAL personDAL) {
     this.personDAL = personDAL;
  }

  public static void main(String[] args) {
     SpringApplication.run(MongoTemplateApp.class, args);
  }

  @Override
  public void run(String... args) {

     personDAL.savePerson(new Person(
           "Shubham", Arrays.asList("Harry potter", "Waking Up"), new Date(769372200000L)));
     personDAL.savePerson(new Person(
           "Sergey", Arrays.asList("Startup Guides", "Java"), new Date(664309800000L)));
     personDAL.savePerson(new Person(
           "David", Arrays.asList("Harry potter", "Success"), new Date(695845800000L)));
     personDAL.savePerson(new Person(
           "Ivan", Arrays.asList("Secrets of Butene", "Meeting Success"), new Date(569615400000L)));
     personDAL.savePerson(new Person(
           "Sergey", Arrays.asList("Harry potter", "Startup Guides"), new Date(348777000000L)));

     LOG.info("Getting all data from MongoDB: \n{}",
           personDAL.getAllPerson());

     LOG.info("Getting paginated data from MongoDB: \n{}",
           personDAL.getAllPersonPaginated(0, 2));

     LOG.info("Getting person By name 'Sergey': {}",
           personDAL.findByName("Sergey"));

     LOG.info("Getting all person By name 'Sergey': {}",
           personDAL.findOneByName("Sergey"));

     LOG.info("Getting people between age 22 & 26: {}",
           personDAL.findByAgeRange(22, 26));

  }
}

我们可以使用一个简单的命令来运行我们的应用程序：

mvn spring-boot:run

运行应用程序后，我们将能够在终端中看到一个简单的输出：

结论

如果我们将MongoTemplate与简单的Spring Data JPA进行比较，它看起来可能很复杂，但是它也使我们对如何构造查询有更多的控制。

Spring Data JPA过多地提取了有关构造什么查询，将哪些条件传递给查询等的详细信息。 使用MongoTemplate，我们可以对查询组成进行更细粒度的控制，Spring Boot为我们提供了易于开发的应用程序。

相关文章

• SpringBoot2.1.X整合MongoDB（支持事务）
• Docker部署Spring Boot项目