不知道大家在工作项目中有没有使用MongoDB，在哪些场景中使用。MongoDB作为NoSQL数据库，不像SQL数据库那样，可以使用Mybatis框架。

如果需要在SpringBoot中使用MongoDB的话，我目前知道有三种方式，第一种是直接使用MongoDB官方的SDK，第二种是使用SpringJpa的方式，第三种是使用MongoTemplate。第二种在内部也是使用MongoTemplate的方式，只是封装了一些通用的CRUD操作，MongoTemplate也是对官方SDK的操作封装，其实本质上是没有什么区别的。

我在工作项目中，在云存储和IM系统中都使用了MongoDB，MongoTemplate和SpringJpa都有使用过，但是SpringJpa并不是特别好用，同时也踩过很多的坑，下面就来看看MongoDB在SpringBoot中的高级用法。

MongoDB注解

Spring Data MongoDB提供了很多的注解来简化简化操作，这些注解包括@Id, @Document, @Field等，这些注解可以在org.springframework.data.annotation 和org.springframework.data.mongodb.core.mapping 包中找到。这些注解用于指示SpringBoot如何将Java对象映射到MongoDB的Document中。

• @Id：该注解用于指定哪个字段被作为主键，可以配合@Field字段使用

  @Id
  @Field(value = "_id", targetType = FieldType.STRING)
  private String userId;// 将userId字段作为主键, 存储到Mongodb中的字段名为_id
  

• @Field：该注解用于指定Document中字段的名称，默认情况下，Spring会将Java对象的字段的名作为Document中的字段名，如果你希望Document中的字段名和Java对象中的字段名不同，那么可以使用该注解进行指定。

• @Document：用于将一个Java类映射到MongoDB的集合，默认情况下，Spring使用类名作为Collection名字，但是你也可以使用该注解来自定义Collection名字。

监听器

使用MongoTemplate进行CRUD操作时，会触发多个不同种类的监听器，我们可以创建不同类型的监听器，从而对查询条件，删除条件，Document映射等进行修改，日志记录，性能优化等。

上面这7个监听器，全部由org.springframework.data.mongodb.core.mapping.event.AbstractMongoEventListener#onApplicationEvent 方法触发，创建监听器也非常简单，只需要创建一个类继承自AbstractMongoEventListener ，然后根据所执行的CRUD操作，重写对应的方法，最后将该类放入Spring容器中就可以了，可以存在多个监听器。下面是监听器的一些基本用法：

设置主键值

MongoDB在插入时，如果没有指定_id字段的值，那么MongoDB会自动生成一个ObjectId类型的值作为_id 字段值，但是默认生成的是String类型。如果我们需要使用int，long类型作为_id字段类型，那么就必须在执行最终插入前手动进行设置。

假如又不想每次执行insert操作时，都手动设置对象中主键字段的值，那么可以在xcye.xyz.mongodb.demos.test.TestAbstractMongoEventListener#onBeforeConvert 方法中统一的对Java对象中主键字段进行赋值，比如使用uuid，雪花算法等自动生成一个唯一的主键值。

@Override
    public void onBeforeConvert(BeforeConvertEvent<Object> event) {
        Object source = event.getSource();

        if (!(source instanceof MongoBaseDomain)) {
            return;
        }

        MongoBaseDomain<?> mongoBaseDomain = (MongoBaseDomain<?>) source;
        if (mongoBaseDomain.getId() != null) {
            return;
        }

        // 根据id字段的类型，如Long，String，Integer，自动生成一个唯一的主键值
        mongoBaseDomain.setId(idValue);
    }

日志记录

onBeforeSave,onBeforeDelete 方法会在执行remove和save之前触发，我们可以分别在这两个方法中记录删除条件和最终保存的对象，对于update方法，我并没有找到任何的方法。

在Mybatis中可以记录执行的SQL，在MongoTemplate中，我们也可以通过该监听器来实现。但是需要注意的是，MongoTemplate中提供的触发方法只有7个，如果执行的是aggregate，bulk等操作，无法通过监听器来记录最终执行的操作语句。

移除_class

默认情况下，在将Java对象保存至MongoDB时，MongoTemplate会在Java对象转换为Document时，会增加一个额外的_class 字段用于保存该Java对象的全限定名。

在执行查询操作时，MongoTemplate也会在查询条件上增加{_class: {$in: [java全限定名，以及子类的全限定名]}}。需要注意的是，额外的增加查询条件和原始的条件是and 操作，正常情况下是没有任何问题的，但是如果我们在插入时，使用Map作为插入的对象，手动指定CollectionName，那么MongoTemplate不会在Document上增加_class 字段(MongoTemplate对Map不做任何的处理，Document本身就是Map的子类)。

在这种情况下，我们执行查询条件时(根据条件修改，删除，查询)，可能会出现查询不到的情况，根本原因便是使用Map插入的这个Document上并没有_class 字段。

解决方法有两个：1. 移除_class，2. 对于使用Map插入时，手动设置Map对象中_class 字段的值，这两种方式各有优点。

我更倾向于移除_class。如果Java对象的全限定名称比较长，并且Collection中数据比较多时，每次保存时都设置_class ，势必会导致不必要的存储空间浪费，而且_class 的作用只是通知Spring，MongoDB中保存的这条Document需要被反序列化为哪个Java类。

正常情况下，我们并不会在同一个Collection中存储多个不同的Java类型，所以在每个Document中存储_class 是完全没有必要的。

从Document中移除_class后，反序列化还正常么？

确定Document应该反序列化为哪个Java对象的工作是在org.springframework.data.convert.DefaultTypeMapper#readType(S, org.springframework.data.util.TypeInformation<T>) 方法中进行的，默认的行为是从查询到的Document中获取_class 字段的值，然后和find(Query query, Class<T> entityClass) 中的entityClass进行比较，最终决定是使用Document中的_class 还是entityClass。

我在上面也说了，通常情 况下，我们并不会在同一个Collection中保存多个不同的Java对象，所以可以直接使用entityClass作为反序列化类型就可以了。

/**
 * 根据source和basicType(source来自于数据库数据)，返回一个更具体的类型信息, 默认行为为，从source中获取_class，并且根据全限定名从缓存中获取,
 * 因为类型都是直接从mongoTemplate指定的，所以从{@link TypeInformation#getType()}中获取的Class便是最具体的类型
 *
 * @param source    must not be {@literal null}.
 * @param basicType must not be {@literal null}.
 * @return 类型信息
 */
@Override
public <T> TypeInformation<? extends T> readType(Bson source, TypeInformation<T> basicType) {
    Class<T> entityClass = basicType.getType();
    // 如果entityClass为空, 将执行逻辑交给父类去处理，由或者可以从本地缓存中根据CollectionName获取Collection对应的Java类的
    if (entityClass == null) {
        return super.readType(source, basicType);
    }
    ClassTypeInformation<?> targetType = ClassTypeInformation.from(entityClass);
    return basicType.specialize(targetType);
}

写操作

默认情况下，会在org.springframework.data.convert.DefaultTypeMapper#writeType(org.springframework.data.util.TypeInformation<?>, S) 方法中向Document中增加_class 字段，我们需要移除_class 字段，只需要让该方法什么都不做就行

/**
 * 默认行为是在写操作时，向document中增加{_class: "全限定名"}
 *
 * @param info must not be {@literal null}.
 * @param sink must not be {@literal null}.
 */
@Override
public void writeType(TypeInformation<?> info, Bson sink) {}

查询

默认情况下，会在writeTypeRestrictions(Document result, @Nullable Set<Class<?>> restrictedTypes) 方法中向查询条件中添加{_class: {$in:[]}}，这会导致在没有_class 字段时，查询出错，解决方案也是重写writeTypeRestrictions 方法，让它什么都不做

/**
 * 默认行文是在查询的时候，向语句中写入{_class: {$in: []}}
 *
 * @param result          must not be {@literal null}
 * @param restrictedTypes must not be {@literal null}
 */
@Override
public void writeTypeRestrictions(Document result, Set<Class<?>> restrictedTypes) {}

主键

在MongoDB中，主键字段名是固定的_id，默认情况下，如果在插入时，没有指定主键字段的值，那么MongoDB会自动生成一个ObjectId类型的值作为_id的值。

使用MongoTemplate执行insert操作时，也可以像Mybatis那样，如果对象中主键值缺失，那么保存成功后，MongoTemplate会将MongoDB自动生成的_id 值赋值给Java对象中@Id 注解修饰的字段值。

User user = new User();
user.setUsername("xcye");
user.setPassword("xcye");
User insert = mongoTemplate.insert(user);
// insert.id = xxxx

如果需要MongoTemplate自动设置id字段的值，必须保证id字段的类型是ObjectId, String,BigInteger ，否则在插入时，会抛出异常，具体判断方法请看org.springframework.data.mongodb.core.EntityOperations.MappedEntity#assertUpdateableIdIfNotSet。

自定义_id转换器

这是一个坑，假如User这个Collection中，使用userId作为_id 字段的值，这是一个字符串。当我们通过userId查询，修改，删除，可能会出现查询不到对应记录的情况，但是我们传入的userId确是真实存在的，而且这种情况只存在于部分userId中。

出现这种情况的原因是因为，MongoTemplate在执行时，会对传入的_id字段进行推断，其会判断传入的这个_id 是否是ObjectId类型，如果能转成ObjectId的话，那么MongoTemplate会使用ObjectId对象作为_id 的值，但是因为MongoDB中_id 字段的类型是普通的字符串，并非是ObjectId，所以就会出现查询不到的情况。

我们传入的查询条件：

db.User.find({_id: "66aeeb73142fcf1d5591c29c"})

MongoTemplate执行时，推断出66aeeb73142fcf1d5591c29c能够转为ObjectId类型，于是最终的查询条件变为：

db.User.find({_id: new ObjectId("66aeeb73142fcf1d5591c29c")})

这个过程是在MongoConverter#convertId 方法中完成的

default Object convertId(@Nullable Object id, Class<?> targetType) {

		if (id == null || ClassUtils.isAssignableValue(targetType, id)) {
			return id;
		}
       // Spring推断出66aeeb73142fcf1d5591c29c能够转为ObjectId，于是targetType为ObjectId
		if (ClassUtils.isAssignable(ObjectId.class, targetType)) {
			if (id instanceof String) {
               // 字符串被转为了ObjectId
				if (ObjectId.isValid(id.toString())) {
					return new ObjectId(id.toString());
				}

				// avoid ConversionException as convertToMongoType will return String anyways.
				return id;
			}
		}

		try {
			return getConversionService().canConvert(id.getClass(), targetType)
					? getConversionService().convert(id, targetType)
					: convertToMongoType(id, (TypeInformation<?>) null);
		} catch (ConversionException o_O) {
			return convertToMongoType(id,(TypeInformation<?>)  null);
		}
	}

所以为了避免普通的字符串被转为ObjectId，我们需要重写convertId方法。只需要创建一个类继承自MappingMongoConverter类，并且重写其中的convertId就可以了。

@AutoConfiguration(after = MongoAutoConfiguration.class, before = MongoDataAutoConfiguration.class)
@ConditionalOnSingleCandidate(MongoClient.class)
public class MongoAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean(MongoConverter.class)
    MappingMongoConverter mappingMongoConverter(MongoDatabaseFactory factory, MongoMappingContext context,
                                                MongoCustomConversions conversions) {
        DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
        //
        MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver, context) {
            @Override
            public Object convertId(Object id, Class<?> targetType) {
                if (id == null) {
                    return null;
                }

                if (id instanceof String) {
                    return id;
                }
                
                // 其他的转换
            }
        };
        mappingConverter.setCustomConversions(conversions);
        return mappingConverter;
    }
}

数据库自动切换

使用MongoTemplate操作时，我们可以动态的切换MongoDB数据库，这个功能在分库的场景下非常好用，动态切换MongoDB数据库是通过MongoDatabaseFactorySupport 来完成的。

MongoTemplate在每次执行时，都会调用org.springframework.data.mongodb.core.MongoTemplate#doGetDatabase 获取操作的数据库，我们只需要创建自己的MongoDatabaseFactory，在getMongoDatabase方法中返回操作的数据库就行，可以参照SimpleMongoClientDatabaseFactory。

@AutoConfiguration(after = MongoAutoConfiguration.class, before = MongoDataAutoConfiguration.class)
@ConditionalOnSingleCandidate(MongoClient.class)
public class MongoAutoConfiguration {

    @Bean
    MongoDatabaseFactorySupport<?> mongoDatabaseFactory(MongoClient mongoClient, MongoProperties properties) {
        return new CustomMongoDatabaseFactory(mongoClient, properties.getMongoClientDatabase());
    }
}

因为MongoDB是NoSQL数据库，在操作时，并不需要像SQL数据库那样，必须要数据库和数据库表存在才可以。MongoDB执行时，如果数据库或Collection不存在，那么其会自动创建。