Field Detail

• LOGGER

  protected static final org.slf4j.Logger LOGGER

• mappingContext

  protected final MappingContext<? extends MongoPersistentEntity<?>,MongoPersistentProperty> mappingContext

• idMapper

  protected final QueryMapper idMapper

• dbRefResolver

  protected final DbRefResolver dbRefResolver

• dbRefProxyHandler

  protected final org.springframework.data.mongodb.core.convert.DefaultDbRefProxyHandler dbRefProxyHandler

• applicationContext

  @Nullable
  protected ApplicationContext applicationContext

• typeMapper

  protected MongoTypeMapper typeMapper

• mapKeyDotReplacement

  @Nullable
  protected String mapKeyDotReplacement

Constructor Detail

• MappingMongoConverter

  public MappingMongoConverter(DbRefResolver dbRefResolver,
                               MappingContext<? extends MongoPersistentEntity<?>,MongoPersistentProperty> mappingContext)

  Creates a new MappingMongoConverter given the new DbRefResolver and MappingContext.

  Parameters:

  dbRefResolver - must not be null.

  mappingContext - must not be null.

• MappingMongoConverter

  @Deprecated
  public MappingMongoConverter(MongoDbFactory mongoDbFactory,
                                           MappingContext<? extends MongoPersistentEntity<?>,MongoPersistentProperty> mappingContext)

  Deprecated. use the constructor taking a DbRefResolver instead.
  Creates a new MappingMongoConverter given the new MongoDbFactory and MappingContext.

  Parameters:

  mongoDbFactory - must not be null.

  mappingContext - must not be null.

Method Detail

• setTypeMapper

  public void setTypeMapper(@Nullable
                            MongoTypeMapper typeMapper)

  Configures the MongoTypeMapper to be used to add type information to Documents created by the converter and how to lookup type information from Documents when reading them. Uses a DefaultMongoTypeMapper by default. Setting this to null will reset the TypeMapper to the default one.

  Parameters:

  typeMapper - the typeMapper to set. Can be null.

• getTypeMapper

  public MongoTypeMapper getTypeMapper()

  Description copied from interface: MongoConverter
  Returns thw TypeMapper being used to write type information into Documents created with that converter.

  Specified by:

  getTypeMapper in interface MongoConverter

  Returns:

  will never be null.

• setMapKeyDotReplacement

  public void setMapKeyDotReplacement(@Nullable
                                      String mapKeyDotReplacement)

  Configure the characters dots potentially contained in a Map shall be replaced with. By default we don't do any translation but rather reject a Map with keys containing dots causing the conversion for the entire object to fail. If further customization of the translation is needed, have a look at potentiallyEscapeMapKey(String) as well as potentiallyUnescapeMapKey(String).

  Parameters:

  mapKeyDotReplacement - the mapKeyDotReplacement to set. Can be null.

• getMappingContext

  public MappingContext<? extends MongoPersistentEntity<?>,MongoPersistentProperty> getMappingContext()

  Specified by:

  getMappingContext in interface EntityConverter<MongoPersistentEntity<?>,MongoPersistentProperty,Object,org.bson.conversions.Bson>

• setApplicationContext

  public void setApplicationContext(ApplicationContext applicationContext)
                             throws BeansException

  Specified by:

  setApplicationContext in interface ApplicationContextAware

  Throws:

  BeansException

• read

  public <S> S read(Class<S> clazz,
                    org.bson.conversions.Bson bson)

  Specified by:

  read in interface EntityReader<Object,org.bson.conversions.Bson>

• read

  protected <S> S read(TypeInformation<S> type,
                       org.bson.conversions.Bson bson)

• toDBRef

  public com.mongodb.DBRef toDBRef(Object object,
                                   @Nullable
                                   MongoPersistentProperty referringProperty)

  Description copied from interface: MongoWriter
  Creates a DBRef to refer to the given object.

  Specified by:

  toDBRef in interface MongoWriter<Object>

  Parameters:

  object - the object to create a DBRef to link to. The object's type has to carry an id attribute.

  referringProperty - the client-side property referring to the object which might carry additional metadata for the DBRef object to create. Can be null.

  Returns:

  will never be null.

• write

  public void write(Object obj,
                    org.bson.conversions.Bson bson)

  Root entry method into write conversion. Adds a type discriminator to the Document. Shouldn't be called for nested conversions.

  Specified by:

  write in interface EntityWriter<Object,org.bson.conversions.Bson>

  See Also:

  org.springframework.data.mongodb.core.convert.MongoWriter#write(java.lang.Object, com.mongodb.Document)

• writeInternal

  protected void writeInternal(@Nullable
                               Object obj,
                               org.bson.conversions.Bson bson,
                               @Nullable
                               TypeInformation<?> typeHint)

  Internal write conversion method which should be used for nested invocations.

  Parameters:

  obj -

  bson -

  typeHint -

• writeInternal

  protected void writeInternal(@Nullable
                               Object obj,
                               org.bson.conversions.Bson bson,
                               @Nullable
                               MongoPersistentEntity<?> entity)

• writePropertyInternal

  protected void writePropertyInternal(@Nullable
                                       Object obj,
                                       org.springframework.data.mongodb.core.convert.DocumentAccessor accessor,
                                       MongoPersistentProperty prop)

• createCollection

  protected List<Object> createCollection(Collection<?> collection,
                                          MongoPersistentProperty property)

  Writes the given Collection using the given MongoPersistentProperty information.

  Parameters:

  collection - must not be null.

  property - must not be null.

  Returns:

• createMap

  protected org.bson.conversions.Bson createMap(Map<Object,Object> map,
                                                MongoPersistentProperty property)

  Writes the given Map using the given MongoPersistentProperty information.

  Parameters:

  map - must not null.

  property - must not be null.

  Returns:

• writeMapInternal

  protected org.bson.conversions.Bson writeMapInternal(Map<Object,Object> obj,
                                                       org.bson.conversions.Bson bson,
                                                       TypeInformation<?> propertyType)

  Writes the given Map to the given Document considering the given TypeInformation.

  Parameters:

  obj - must not be null.

  bson - must not be null.

  propertyType - must not be null.

  Returns:

• potentiallyEscapeMapKey

  protected String potentiallyEscapeMapKey(String source)

  Potentially replaces dots in the given map key with the configured map key replacement if configured or aborts conversion if none is configured.

  Parameters:

  source -

  Returns:

  See Also:

  setMapKeyDotReplacement(String)

• potentiallyUnescapeMapKey

  protected String potentiallyUnescapeMapKey(String source)

  Translates the map key replacements in the given key just read with a dot in case a map key replacement has been configured.

  Parameters:

  source -

  Returns:

• addCustomTypeKeyIfNecessary

  protected void addCustomTypeKeyIfNecessary(@Nullable
                                             TypeInformation<?> type,
                                             Object value,
                                             org.bson.conversions.Bson bson)

  Adds custom type information to the given Document if necessary. That is if the value is not the same as the one given. This is usually the case if you store a subtype of the actual declared type of the property.

  Parameters:

  type -

  value - must not be null.

  bson - must not be null.

• createDBRef

  protected com.mongodb.DBRef createDBRef(Object target,
                                          MongoPersistentProperty property)

• getValueInternal

  public Object getValueInternal(MongoPersistentProperty prop,
                                 org.bson.conversions.Bson bson,
                                 SpELExpressionEvaluator evaluator,
                                 org.springframework.data.mongodb.core.convert.ObjectPath path)

  Resolves the value for the given MongoPersistentProperty within the given Document using the given SpELExpressionEvaluator and ObjectPath.

  Returns:

• readMap

  protected Map<Object,Object> readMap(TypeInformation<?> type,
                                       org.bson.conversions.Bson bson,
                                       org.springframework.data.mongodb.core.convert.ObjectPath path)

  Reads the given Document into a Map. will recursively resolve nested Maps as well.

  Parameters:

  type - the Map TypeInformation to be used to unmarshall this Document.

  bson - must not be null

  path - must not be null

  Returns:

• convertToMongoType

  @Nullable
  public Object convertToMongoType(@Nullable
                                             Object obj,
                                             TypeInformation<?> typeInformation)

  Description copied from interface: MongoWriter
  Converts the given object into one Mongo will be able to store natively but retains the type information in case the given TypeInformation differs from the given object type.

  Specified by:

  convertToMongoType in interface MongoWriter<Object>

  Parameters:

  obj - can be null.

  typeInformation - can be null.

  Returns:

• maybeConvertList

  public List<Object> maybeConvertList(Iterable<?> source,
                                       TypeInformation<?> typeInformation)