Allow using complex types as Map keys [DATAMONGO-242]

[spring-projects-issues]

Oliver Drotbohm opened DATAMONGO-242 and commented

As indicated in DATAMONGO-241 it would be cool if we could support complex types as Map key types.

A few key points to consider:

• complex key types require completely different storing (BasicDBList of BasicDBObject instances)
• the inner BasicDBObject instances need keys to store key and value of the map entries, these should be configurable
• we have to support scenarios where data in that custom format is read and written with custom converters being registered for the complex key type (which essentially result in a migration back to simple BasicDBObject instances
• indexing metadata

---

Affects: 1.0 M3

Issue Links:

• DATAMONGO-449 Spring-Data Mongo doesn't use converters while serializing key Objects from Map Properties
  ("is duplicated by")
• DATAMONGO-485 Dont require Converters for Complex classes that are used as Ids
  ("is duplicated by")
• DATAMONGO-241 Allow Map conversion behavior overriding

4 votes, 1 watchers

[spring-projects-issues]

Eduards Sizovs commented

Hi Oliver,

For my needs I have created an extension of MappingMongoConverter which writes a Map in a given format:

mapName {
   0: { key: DBO, value: DBO }
   1: { key: DBO, value: DBO }
}

An implementation indexes entries starting from zero, therefore there is not need for user to specify a key for an Entry Key and Entry Value.

Maybe I've missed something. Looking forward for your comments.

[spring-projects-issues]

Eduards Sizovs commented

Worth to note that when constructing a Map, indexes are not taken into account

[spring-projects-issues]

Oliver Drotbohm commented

With customizing the keys I actually meant deciding what to use for what you have hard coded as key and value. Is there a reason you chose an artificial, indexed map (using 0, 1 etc as keys) over a plain Mongo array (BasicDBList)?

mapName : [
  { key : DBO, value : DBO},
  { key : DBO, value : DBO}
]

Is there some code you could share (maybe a patch or pull request)?

[spring-projects-issues]

Eduards Sizovs commented

Hi Oliver,

I was confused slightly by Javadocs in BasicBSONList. Currently I've leveraged BasicDBList for Map entries, but anyway it creates indexes automatically, so the resulting structure is like I've posted before. Any ideas how to avoid 0, 1, 2... keys altogether?

Here is the extension of MappingMongoConverter. Probably I haven't covered some cases, but it worked out for me:

import java.util.Map;
import java.util.Map.Entry;

import org.springframework.core.CollectionFactory;
import org.springframework.data.mapping.context.MappingContext;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
import org.springframework.data.util.TypeInformation;

import com.mongodb.BasicDBList;
import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;

public class FixedMappingMongoConverter extends MappingMongoConverter {

	private static final String MAP_VALUE = "value";
	private static final String MAP_KEY = "key";

	public FixedMappingMongoConverter(MongoDbFactory mongoDbFactory,
			MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext) {
		super(mongoDbFactory, mappingContext);
	}

	@SuppressWarnings("unchecked")
	@Override
	protected Map<Object, Object> readMap(TypeInformation<?> type, DBObject dbObject) {

		Class<?> customMapType = findTypeToBeUsed(dbObject);
		Class<?> mapType = customMapType == null ? type.getType() : customMapType;

		Map<Object, Object> map = CollectionFactory.createMap(mapType, dbObject.keySet().size());
		Map<String, Object> sourceMap = dbObject.toMap();

		for (Entry<String, Object> entry : sourceMap.entrySet()) {
			if (entry.getKey().equals(CUSTOM_TYPE_KEY)) {
				continue;
			}

			DBObject mapEntry = (DBObject) entry.getValue();
			Object mapKey = toObject(type.getComponentType(), (DBObject) mapEntry.get(MAP_KEY));
			if (null != mapEntry.get(MAP_VALUE) && mapEntry.get(MAP_VALUE) instanceof DBObject) {
				Object mapValue = toObject(type.getMapValueType(), (DBObject) mapEntry.get(MAP_VALUE));
				map.put(mapKey, mapValue);
			} else {
				map.put(mapKey, getPotentiallyConvertedSimpleRead(entry.getValue(), type.getMapValueType().getType()));
			}
		}
		return map;

	}

	// FIXME: Copied from a superclass due to insufficient method visibility 
	@SuppressWarnings({ "unchecked", "rawtypes" })
	private Object getPotentiallyConvertedSimpleRead(Object value, Class<?> target) {

		if (value == null) {
			return null;
		}

		if (conversions.hasCustomReadTarget(value.getClass(), target)) {
			return conversionService.convert(value, target);
		}

		if (target.isEnum()) {
			return Enum.valueOf((Class<Enum>) target, value.toString());
		}

		return value;
	}

	@Override
	protected void writeMapInternal(Map<Object, Object> obj, DBObject dbo, TypeInformation<?> propertyType) {

		BasicDBList dboMap = new BasicDBList();
		addCustomTypeKeyIfNecessary(propertyType, obj, dbo);

		for (Map.Entry<Object, Object> entry : obj.entrySet()) {
			DBObject dboMapEntry = createDBObjectFromMapEntry(entry);
			dboMap.add(dboMapEntry);
		}

		dbo.putAll(dboMap);
	}

	private DBObject createDBObjectFromMapEntry(Map.Entry<Object, Object> entry) {
		DBObject dboEntryKey = toDBObject(entry.getKey());
		DBObject dboEntryVal = toDBObject(entry.getValue());

		DBObject dboEntry = new BasicDBObject(2);
		dboEntry.put(MAP_KEY, dboEntryKey);
		dboEntry.put(MAP_VALUE, dboEntryVal);
		return dboEntry;
	}

	private DBObject toDBObject(Object object) {
		DBObject dboEntry = new BasicDBObject();
		writeInternal(object, dboEntry);
		return dboEntry;
	}

	private Object toObject(TypeInformation<?> valueType, DBObject valueSource) {
		return valueType.isMap() ? readMap(valueType, valueSource) : read(valueType, valueSource);
	}
}