Spring Data MongoDB

用途

快速集成 MongoDB，不用写一行 MongoDB 的 CRUD 语句。而是使用 Spring Data 独有的方法命名方式定义数据库操作，并且可以方便地替换各种数据库，比如 MysqL。

快速开始

（0）开始之前

确保已有可连接的 MongoDB

（1）依赖引入

在 build.gradle 中添加如下依赖。

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:2.0.5.RELEASE")
    }
}

apply plugin: 'java'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'

repositories {
    mavenCentral()
}

sourceCompatibility = 1.8
targetCompatibility = 1.8

dependencies {
    compile("org.springframework.boot:spring-boot-starter-data-mongodb")
}

（2）配置 MongoDB 连接

这里配置了 MongoDB 的连接地址和使用的数据库，还配置了扫描 Repositories 的位置。Repositories 我们后面会讲到是什么。

@Configuration
@EnableMongoRepositories(basePackages = "com.example.dao")
public class MongoConfig {

  @Bean
  public MongoOperations mongoTemplate() throws UnkNownHostException {
    return new MongoTemplate(mongoDbFactory());
  }

  @Bean
  public MongoDbFactory mongoDbFactory() throws UnkNownHostException {
    return new SimpleMongoDbFactory(new MongoClientURI("mongodb://localhost:27017/test"));
  }

}

（3）定义一个简单的实体类

实体类是一个 POJO，不过会多一些注解。简单介绍下这些注解吧：

@Document ，用于自定义 MongoDB 中 Collection 的名称，默认情况下 collection 值为空，使用类名的小写形式作为 Collection 的名称；
@Id ，用于指定 MongoDB 内部使用字段 _id 的值，如果不指定，则使用自动生成的值。
@Field ，用于指定字段存储时的名称，如果不指定，则直接使用字段名。如果字段名为id，那么一定要使用该注解，否则会读取时使用系统的_id作为 id 的值。
@Indexed，用于为指定字段添加索引，会调用 MongoDB 的 createIndex 方法。值得注意的是：必须 @Document 注解，否则不会自动生成索引。

@Document(collection = "Customer")
public class Customer {
    @Id
    public String id;
    
    @Indexed
    @Field("first_name")
    public String firstName;
    
    @Field("last_name")
    public String lastName;
    
    public Customer() {}

    public Customer(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

（4）定义一个 Repository

MongoRepository 中定义的基本的 CRUD 操作，你可以自定义查询方法，不过要遵守一定的规范，Spring Data MongoDB 会根据方法名和参数去执行数据库操作。这个规范参见下文支持的查询方法关键字列表。此处只需要了解有 findByXx 的方法名即可。

public interface CustomerRepository extends MongoRepository<Customer, String> {

    public Customer findByFirstName(String firstName);
    public List<Customer> findByLastName(String lastName);
}

（5）让 Spring Boot 自动装配 CustomerRepository

@SpringBootApplication
public class Application implements CommandLineRunner {

    @Autowired
    private CustomerRepository repository;

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

    @Override
    public void run(String... args) throws Exception {
        repository.deleteall();

        // save a couple of customers
        repository.save(new Customer("Alice", "Smith"));
        repository.save(new Customer("Bob", "Smith"));

        System.out.println("-------------------------------");

        // fetch an individual customer
        System.out.println(repository.findByFirstName("Alice"));
    }
}

（6）使用 MongoDB 命令行查询

$ mongo
> use test
> db.Customer.find({})

深入探讨

常用的匹配注解列表

Annotation	Desc
`@Id`	用于指定 MongoDB 内部使用字段 `_id` 的值，如果不指定，则使用自动生成的值。
`@Field`	用于指定数据库中存储的字段名。
`@Document`	用于指定该类的实例对应 MongoDB 的某个指定 Collection 下的 Document。
`@Indexed`	用于为指定字段添加索引。`@Indexed(unique = true)` 可注解唯一键
`@Compoundindex`	用于指定复合索引。
`@Transient`	用于将某些字段排除，不与数据库匹配。
`@Version`	用于指定字段的版本，默认值为 0，在每次更新字段后自增。

复合索引用例：

@Document
@Compoundindexes({
    // lastName 升序，age 降序的复合索引，名称为 age_idx。
    @Compoundindex(name = "age_idx", def = "{'lastName': 1, 'age': -1}")
})
public class Person<T extends Address> {
    //...
}

支持的查询 方法关键字列表

Keyword	Sample	Logical result
`After`	`findByBirthdateAfter(Date date)`	`{"birthdate" : {"$gt" : date}}`
`GreaterThan`	`findByAgeGreaterThan(int age)`	`{"age" : {"$gt" : age}}`
`GreaterThanEqual`	`findByAgeGreaterThanEqual(int age)`	`{"age" : {"$gte" : age}}`
`Before`	`findByBirthdateBefore(Date date)`	`{"birthdate" : {"$lt" : date}}`
`Lessthan`	`findByAgeLessthan(int age)`	`{"age" : {"$lt" : age}}`
`LessthanEqual`	`findByAgeLessthanEqual(int age)`	`{"age" : {"$lte" : age}}`
`Between`	`findByAgeBetween(int from, int to)`	`{"age" : {"$gt" : from, "$lt" : to}}`
`In`	`findByAgeIn(Collection ages)`	`{"age" : {"$in" : [ages…]}}`
`notin`	`findByAgenotin(Collection ages)`	`{"age" : {"$nin" : [ages…]}}`
`IsNotNull`, `NotNull`	`findByFirstnameNotNull()`	`{"firstname" : {"$ne" : null}}`
`IsNull`, `Null`	`findByFirstnameNull()`	`{"firstname" : null}`
`Like`, `StartingWith`, `EndingWith`	`findByFirstnameLike(String name)`	`{"firstname" : name} (name as regex)`
`NotLike`, `IsNotLike`	`findByFirstnameNotLike(String name)`	`{"firstname" : { "$not" : name }} (name as regex)`
`Containing` on String	`findByFirstnameContaining(String name)`	`{"firstname" : name} (name as regex)`
`NotContaining` on String	`findByFirstnameNotContaining(String name)`	`{"firstname" : { "$not" : name}} (name as regex)`
`Containing` on Collection	`findByAddressesContaining(Address address)`	`{"addresses" : { "$in" : address}}`
`NotContaining` on Collection	`findByAddressesNotContaining(Address address)`	`{"addresses" : { "$not" : { "$in" : address}}}`
`Regex`	`findByFirstnameRegex(String firstname)`	`{"firstname" : {"$regex" : firstname }}`
`(No keyword)`	`findByFirstname(String name)`	`{"firstname" : name}`
`Not`	`findByFirstnameNot(String name)`	`{"firstname" : {"$ne" : name}}`
`Near`	`findByLocationNear(Point point)`	`{"location" : {"$near" : [x,y]}}`
`Near`	`findByLocationNear(Point point, distance max)`	`{"location" : {"$near" : [x,y], "$maxdistance" : max}}`
`Near`	`findByLocationNear(Point point, distance min, distance max)`	`{"location" : {"$near" : [x,y], "$mindistance" : min, "$maxdistance" : max}}`
`Within`	`findByLocationWithin(Circle circle)`	`{"location" : {"$geoWithin" : {"$center" : [ [x, y], distance]}}}`
`Within`	`findByLocationWithin(Box Box)`	`{"location" : {"$geoWithin" : {"$Box" : [ [x1, y1], x2, y2]}}}`
`IsTrue`, `True`	`findByActiveIsTrue()`	`{"active" : true}`
`IsFalse`, `False`	`findByActiveIsFalse()`	`{"active" : false}`
`Exists`	`findByLocationExists(boolean exists)`	`{"location" : {"$exists" : exists }}`

Tip：将以上的 findBy 替换成 deleteBy 含义就变成了：查找后进行删除操作。

下面是一个使用示例：查询指定状态集合的 JobFlow。

// 方式一：使用 SqEL(Spring 表达式)
@Query("{ 'status': { $in: ?0 } }")
List<JobFlow> findByStatus(String... status);
// 方式二：使用 In
List<JobFlow> findByStatusIn(List<String> statusList);

save 的原理

// SimpleMongoRepository.java
public <S extends T> S save(S entity) {

    Assert.notNull(entity, "Entity must not be null!");

    if (entityinformation.isNew(entity)) {
        mongoOperations.insert(entity, entityinformation.getCollectionName());
    } else {
        mongoOperations.save(entity, entityinformation.getCollectionName());
    }

    return entity;
}

public <S extends T> List<S> save(Iterable<S> entities) {

    Assert.notNull(entities, "The given Iterable of entities not be null!");

    List<S> result = convertIterabletoList(entities);
    boolean allNew = true;

    for (S entity : entities) {
        if (allNew && !entityinformation.isNew(entity)) {
            allNew = false;
        }
    }

    if (allNew) {
        mongoOperations.insertAll(result);
    } else {

        for (S entity : result) {
            save(entity);
        }
    }

    return result;
}

// AbstractEntityinformation.java
public boolean isNew(T entity) {

    ID id = getId(entity);
    Class<ID> idType = getIdType();

    if (!idType.isPrimitive()) {
        return id == null;
    }

    if (id instanceof Number) {
        return ((Number) id).longValue() == 0L;
    }

    throw new IllegalArgumentException(String.format("Unsupported primitive id type %s!", idType));
}