Springboot集成MongoDB

时间：2022-03-15 08:30

简介

MongoDB（来自于英文单词“Humongous”，中文含义为“庞大”）是可以应用于各种规模的企业、各个行业以及各类应用程序的开源数据库。作为一个适用于敏捷开发的数据库，MongoDB的数据模式可以随着应用程序的发展而灵活地更新。与此同时，它也为开发人员提供了传统数据库的功能：二级索引，完整的查询系统以及严格一致性等等。 MongoDB能够使企业更加具有敏捷性和可扩展性，各种规模的企业都可以通过使用MongoDB来创建新的应用，提高与客户之间的工作效率，加快产品上市时间，以及降低企业成本。

安装mongoDB

创建项目

pom

<?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">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.test</groupId>
  <artifactId>springboot-with-mongodb</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>springboot-with-mongodb</name>
  <description>Demo project for Spring Boot</description>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.2.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
  </properties>

  <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>io.springfox</groupId>
      <artifactId>springfox-swagger2</artifactId>
      <version>2.7.0</version>
    </dependency>
    <dependency>
      <groupId>io.springfox</groupId>
      <artifactId>springfox-swagger-ui</artifactId>
      <version>2.7.0</version>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
    </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>


</project>

配置文件

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

创建一个表/集合

一个消费者

@Data
public class Customer {

    @Id
    public String id;

    public String firstName;
    public String lastName;
    private List<Hobby> hobbies;

    public Customer() {
    }

    public Customer(String firstName, String lastName, List<Hobby> hobbies) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.hobbies = hobbies;
    }

}

import org.springframework.data.annotation.Id; 是mongodb里的主键

创建Repository

JPA的一个特性就是简化了CRUD, 通过解析方法名实现数据的传输

import com.test.springbootwithmongodb.entity.Customer;
import java.util.List;
import org.springframework.data.mongodb.repository.MongoRepository;

public interface CustomerRepository extends MongoRepository<Customer, String> {

    Customer findByFirstName(String firstName);

    List<Customer> findByLastName(String lastName);

}

方法名findBy字段名即可实现查询。

启动并测试


@SpringBootApplication
public class SpringbootWithMongodbApplication implements CommandLineRunner {

    private final CustomerRepository repository;
    private final BookRepository bookRepository;
    private final AuthorRepository authorRepository;

    @Autowired
    public SpringbootWithMongodbApplication(CustomerRepository repository,
        BookRepository bookRepository,
        AuthorRepository authorRepository) {
        this.repository = repository;
        this.bookRepository = bookRepository;
        this.authorRepository = authorRepository;
    }

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

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

        repository.deleteAll();

        // save a couple of customers
        repository.save(new Customer("Alice", "Smith", Lists.newArrayList(new Hobby("读书", 1), new Hobby("看电影", 2))));
        repository.save(new Customer("Bob", "Smith", Lists.newArrayList()));

        // fetch all customers
        System.out.println("Customers found with findAll():");
        System.out.println("-------------------------------");
        for (Customer customer : repository.findAll()) {
            System.out.println(customer);
        }
        System.out.println();

        // fetch an individual customer
        System.out.println("Customer found with findByFirstName('Alice'):");
        System.out.println("--------------------------------");
        System.out.println(repository.findByFirstName("Alice"));

        System.out.println("Customers found with findByLastName('Smith'):");
        System.out.println("--------------------------------");
        for (Customer customer : repository.findByLastName("Smith")) {
            System.out.println(customer);
        }

    }
}

至此，hello world完成。基本实现了mongoDB持久层的工作，只要继续深入开发即可。

关联表

创建一个书籍的集合

import java.time.LocalDate;
import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

@Data
@Document(collection = "books")
public class Book {

    @Id
    private String id;
    private String title;
    @Field("published")
    private LocalDate publicationDate;

    // No args Constructor
    public Book(String title, LocalDate publicationDate) {
        this.title = title;
        this.publicationDate = publicationDate;
    }

}

@Field指定数据库映射的字段
@Transient标注的字段则不会映射到db
@Document(collection = "books")可以指定集合名称，如果不指定则是类名首字母小写

创建一个作者，作者拥有书籍

@Data
public class Author {

    @Id
    private ObjectId id;
    @Indexed(unique = true)
    private String name;
    @DBRef
    private Set<Book> books;

    // No args Constructor
    public Author(String name) {
        this.name = name;
    }

}

@DBRef会引用books的表
@Indexed(unique = true)设置索引，并且是唯一性索引

CRUD

暂时不自定义查询了，利用内置的查询即可

public interface AuthorRepository extends MongoRepository<Author, ObjectId> {

}
public interface BookRepository extends MongoRepository<Book, ObjectId> {

}

测试

bookRepository.deleteAll();
authorRepository.deleteAll();
Book ci = new Book("Continous Integration", LocalDate.now());
// id will be generated after save
bookRepository.save(ci);
Book c2 = new Book("Java编程思想", LocalDate.now());
Book c3 = new Book("Java核心技术", LocalDate.now());
Book c4 = new Book("Effective Java", LocalDate.now());
Book c5 = new Book("深入理解虚拟机", LocalDate.now());
Book c6 = new Book("深入理解虚拟机", LocalDate.now());
bookRepository.save(c2);
bookRepository.save(c3);
bookRepository.save(c4);
bookRepository.save(c5);
bookRepository.save(c6);

List<Book> books = bookRepository.findAll();
System.out.println(books);

Author julius = new Author("Julius");
julius.setBooks(Stream.of(ci, c2, c3, c4, c5, c6).collect(Collectors.toSet()));
authorRepository.save(julius);
System.out.println(authorRepository.findAll());

启动可以看到控制台输出：

[Book(id=5b0bec767a49d017f0e46c63, title=Continous Integration, publicationDate=2018-05-28), Book(id=5b0bec767a49d017f0e46c64, title=Java编程思想, publicationDate=2018-05-28), Book(id=5b0bec767a49d017f0e46c65, title=Java核心技术, publicationDate=2018-05-28), Book(id=5b0bec767a49d017f0e46c66, title=Effective Java, publicationDate=2018-05-28), Book(id=5b0bec767a49d017f0e46c67, title=深入理解虚拟机, publicationDate=2018-05-28), Book(id=5b0bec767a49d017f0e46c68, title=深入理解虚拟机, publicationDate=2018-05-28)]
[Author(id=5b0bec767a49d017f0e46c69, name=Julius, books=[Book(id=5b0bec767a49d017f0e46c64, title=Java编程思想, publicationDate=2018-05-28), Book(id=5b0bec767a49d017f0e46c68, title=深入理解虚拟机, publicationDate=2018-05-28), Book(id=5b0bec767a49d017f0e46c67, title=深入理解虚拟机, publicationDate=2018-05-28), Book(id=5b0bec767a49d017f0e46c63, title=Continous Integration, publicationDate=2018-05-28), Book(id=5b0bec767a49d017f0e46c65, title=Java核心技术, publicationDate=2018-05-28), Book(id=5b0bec767a49d017f0e46c66, title=Effective Java, publicationDate=2018-05-28)])]

连接db，查询

db.author.find({})

{ 
    "_id" : ObjectId("5b0bec767a49d017f0e46c69"), 
    "name" : "Julius", 
    "books" : [
        DBRef("books", ObjectId("5b0bec767a49d017f0e46c64")), 
        DBRef("books", ObjectId("5b0bec767a49d017f0e46c68")), 
        DBRef("books", ObjectId("5b0bec767a49d017f0e46c67")), 
        DBRef("books", ObjectId("5b0bec767a49d017f0e46c63")), 
        DBRef("books", ObjectId("5b0bec767a49d017f0e46c65")), 
        DBRef("books", ObjectId("5b0bec767a49d017f0e46c66"))
    ], 
    "_class" : "com.test.springbootwithmongodb.entity.Author"
}

MongoTemplate

可以自己注入MongoTemplate来实现更多操作, 比如

private final MongoTemplate mongoTemplate;

List<Customer> list = mongoTemplate.findAll(Customer.class);

索引

还可以这样设置联合索引

@Document
@CompoundIndexes({
    @CompoundIndex(name = "email_age", def = "{'email.id' : 1, 'age': 1}")
})
public class User {
    //
}

查询索引

db.user.getIndexes();

{
    "v" : 1,
    "key" : {
        "email.id" : 1,
        "age" : 1
    },
    "name" : "email_age",
    "ns" : "test.user"
}