Source code
package org.springframework.core.convert.support;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.jspecify.annotations.Nullable;
import org.springframework.core.CollectionFactory;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.core.convert.converter.ConditionalGenericConverter;
/**
* Converts a Map to another Map.
*
* <p>First, creates a new Map of the requested targetType with a size equal to the
* size of the source Map. Then copies each element in the source map to the target map.
* Will perform a conversion from the source map's parameterized K,V types to the target
* map's parameterized types K,V if necessary.
*
* @author Keith Donald
* @author Juergen Hoeller
* @since 3.0
*/
final class MapToMapConverter implements ConditionalGenericConverter {
private final ConversionService conversionService;
public MapToMapConverter(ConversionService conversionService) {
this.conversionService = conversionService;
}
@Override
public Set<ConvertiblePair> getConvertibleTypes() {
return Collections.singleton(new ConvertiblePair(Map.class, Map.class));
}
@Override
public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
return canConvertKey(sourceType, targetType) && canConvertValue(sourceType, targetType);
}
@Override
public @Nullable Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
if (source == null) {
return null;
}
@SuppressWarnings("unchecked")
Map<Object, Object> sourceMap = (Map<Object, Object>) source;
// Shortcut if possible...
boolean copyRequired = !targetType.getType().isInstance(source);
if (!copyRequired && sourceMap.isEmpty()) {
return sourceMap;
}
TypeDescriptor keyDesc = targetType.getMapKeyTypeDescriptor();
TypeDescriptor valueDesc = targetType.getMapValueTypeDescriptor();
List<MapEntry> targetEntries = new ArrayList<>(sourceMap.size());
for (Map.Entry<Object, Object> entry : sourceMap.entrySet()) {
Object sourceKey = entry.getKey();
Object sourceValue = entry.getValue();
Object targetKey = convertKey(sourceKey, sourceType, keyDesc);
Object targetValue = convertValue(sourceValue, sourceType, valueDesc);
targetEntries.add(new MapEntry(targetKey, targetValue));
if (sourceKey != targetKey || sourceValue != targetValue) {
copyRequired = true;
}
}
if (!copyRequired) {
return sourceMap;
}
Map<Object, Object> targetMap = CollectionFactory.createMap(targetType.getType(),
(keyDesc != null ? keyDesc.getType() : null), sourceMap.size());
for (MapEntry entry : targetEntries) {
entry.addToMap(targetMap);
}
return targetMap;
}
// internal helpers
private boolean canConvertKey(TypeDescriptor sourceType, TypeDescriptor targetType) {
return ConversionUtils.canConvertElements(sourceType.getMapKeyTypeDescriptor(),
targetType.getMapKeyTypeDescriptor(), this.conversionService);
}
private boolean canConvertValue(TypeDescriptor sourceType, TypeDescriptor targetType) {
return ConversionUtils.canConvertElements(sourceType.getMapValueTypeDescriptor(),
targetType.getMapValueTypeDescriptor(), this.conversionService);
}
private @Nullable Object convertKey(Object sourceKey, TypeDescriptor sourceType, @Nullable TypeDescriptor targetType) {
if (targetType == null) {
return sourceKey;
}
return this.conversionService.convert(sourceKey, sourceType.getMapKeyTypeDescriptor(sourceKey), targetType);
}
private @Nullable Object convertValue(Object sourceValue, TypeDescriptor sourceType, @Nullable TypeDescriptor targetType) {
if (targetType == null) {
return sourceValue;
}
return this.conversionService.convert(sourceValue, sourceType.getMapValueTypeDescriptor(sourceValue), targetType);
}
private static class MapEntry {
private final @Nullable Object key;
private final @Nullable Object value;
public MapEntry(@Nullable Object key, @Nullable Object value) {
this.key = key;
this.value = value;
}
public void addToMap(Map<Object, Object> map) {
map.put(this.key, this.value);
}
}
}
Run 1
The code is highly readable. It has a clear and logical structure, with the main conversion method followed by well-named helper methods and a private static inner class. Nesting is minimal; the only conditional inside the loop is a simple check. The intent of each method is clear from its name and the Javadoc explains the overall conversion process. Code length is appropriate and not verbose, though the targetEntries list could be avoided in simple cases. Action granularity is excellent, with one main action per line. Reading flow is natural—the convert method tells a story of checking for shortcuts, preparing entries, and building the target map. Overall, this follows clean code principles effectively.
Run 2
The code is well-structured with clear separation of concerns: public conversion logic, internal helpers, and a private MapEntry class. Nesting is shallow – the deepest is one level inside the convert method's loop. Intent is clearly expressed through descriptive method names like canConvertKey, convertValue, and the Javadoc explaining the conversion strategy. The code is concise, though slightly verbose due to Spring's TypeDescriptor pattern. Each major operation occupies its own line, improving readability. The reading flow is natural: null check, shortcut, type extraction, iteration, map construction, and entry addition. Minor deductions: the copyRequired shortcut logic requires careful reading, and the conversion method signatures involve many parameters, though this is typical for Spring's conversion framework.
Run 3
The code is well-structured with clear separation of concerns: type checking, conversion, and entry storage. Nesting is minimal, with early returns and guard clauses reducing indentation. Intent is clear through descriptive method names and concise comments. The convert method breaks actions into logical steps—null checks, shortcut handling, entry conversion, and target map creation. However, there is a minor readability issue: the MapEntry class adds a layer of abstraction that can make the flow slightly harder to follow at first glance. Line lengths and method granularity are appropriate. Overall, the code follows Spring’s style and is highly readable for an experienced Java developer.
Run 1
Code Structure: Logically organized into converter methods, focused helpers, and a small entry holder. Nesting: Shallow loops and conditionals, with early returns keeping control flow flat. Clarity of intent: Descriptive names and class documentation make map conversion clear; identity comparisons and deferred copying require slightly more thought. Code length: Mostly concise, though parallel key/value helpers and the intermediate entry class add some verbosity. Action granularity: Statements generally perform one action per line, making conversion steps easy to follow. Reading flow: Naturally progresses from validation and shortcuts through element conversion to target-map creation; the two-pass approach introduces modest cognitive overhead but remains well structured.
Run 2
Code Structure: Well organized into interface methods, focused conversion helpers, and a small entry class. Nesting: Shallow conditionals and loops, with early returns keeping control flow flat. Clarity of intent: Descriptive names and class documentation clearly communicate map conversion; identity comparisons and copyRequired tracking require some thought. Code length: Mostly concise, though the intermediate entry list, two-pass processing, and wrapper class add complexity to preserve source-map reuse. Action granularity: Statements generally perform one action per line, with compound expressions remaining manageable. Reading flow: Natural progression from null handling through conversion, reuse checks, and target population; consistent formatting and helper extraction support scanning.
Run 3
Code Structure: Well organized into converter methods, focused helpers, and a small entry holder. Nesting: Shallow loops and conditionals, with early returns preventing deep nesting. Clarity of intent: Descriptive names and documentation clearly communicate map conversion; reference-identity checks and deferred copying require slightly more thought. Code length: Generally concise, though parallel key/value helpers and the MapEntry wrapper add some verbosity. Action granularity: Statements consistently perform one action per line, making intermediate conversions easy to follow. Reading flow: Natural progression from null handling and shortcuts through conversion to target construction. The two-pass approach and copyRequired state introduce minor cognitive overhead, but formatting and method boundaries keep the implementation highly readable.