/*
 * Copyright 2002-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.beans.propertyeditors;

import java.beans.PropertyEditorSupport;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ReflectionUtils;

Property editor for Maps, converting any source Map to a given target Map type.
Author:Juergen Hoeller
See Also:
Since:2.0.1
/** * Property editor for Maps, converting any source Map * to a given target Map type. * * @author Juergen Hoeller * @since 2.0.1 * @see java.util.Map * @see java.util.SortedMap */
public class CustomMapEditor extends PropertyEditorSupport { @SuppressWarnings("rawtypes") private final Class<? extends Map> mapType; private final boolean nullAsEmptyMap;
Create a new CustomMapEditor for the given target type, keeping an incoming null as-is.
Params:
  • mapType – the target type, which needs to be a sub-interface of Map or a concrete Map class
See Also:
/** * Create a new CustomMapEditor for the given target type, * keeping an incoming {@code null} as-is. * @param mapType the target type, which needs to be a * sub-interface of Map or a concrete Map class * @see java.util.Map * @see java.util.HashMap * @see java.util.TreeMap * @see java.util.LinkedHashMap */
@SuppressWarnings("rawtypes") public CustomMapEditor(Class<? extends Map> mapType) { this(mapType, false); }
Create a new CustomMapEditor for the given target type.

If the incoming value is of the given type, it will be used as-is. If it is a different Map type or an array, it will be converted to a default implementation of the given Map type. If the value is anything else, a target Map with that single value will be created.

The default Map implementations are: TreeMap for SortedMap, and LinkedHashMap for Map.

Params:
  • mapType – the target type, which needs to be a sub-interface of Map or a concrete Map class
  • nullAsEmptyMap – ap whether to convert an incoming null value to an empty Map (of the appropriate type)
See Also:
/** * Create a new CustomMapEditor for the given target type. * <p>If the incoming value is of the given type, it will be used as-is. * If it is a different Map type or an array, it will be converted * to a default implementation of the given Map type. * If the value is anything else, a target Map with that single * value will be created. * <p>The default Map implementations are: TreeMap for SortedMap, * and LinkedHashMap for Map. * @param mapType the target type, which needs to be a * sub-interface of Map or a concrete Map class * @param nullAsEmptyMap ap whether to convert an incoming {@code null} * value to an empty Map (of the appropriate type) * @see java.util.Map * @see java.util.TreeMap * @see java.util.LinkedHashMap */
@SuppressWarnings("rawtypes") public CustomMapEditor(Class<? extends Map> mapType, boolean nullAsEmptyMap) { Assert.notNull(mapType, "Map type is required"); if (!Map.class.isAssignableFrom(mapType)) { throw new IllegalArgumentException( "Map type [" + mapType.getName() + "] does not implement [java.util.Map]"); } this.mapType = mapType; this.nullAsEmptyMap = nullAsEmptyMap; }
Convert the given text value to a Map with a single element.
/** * Convert the given text value to a Map with a single element. */
@Override public void setAsText(String text) throws IllegalArgumentException { setValue(text); }
Convert the given value to a Map of the target type.
/** * Convert the given value to a Map of the target type. */
@Override public void setValue(@Nullable Object value) { if (value == null && this.nullAsEmptyMap) { super.setValue(createMap(this.mapType, 0)); } else if (value == null || (this.mapType.isInstance(value) && !alwaysCreateNewMap())) { // Use the source value as-is, as it matches the target type. super.setValue(value); } else if (value instanceof Map) { // Convert Map elements. Map<?, ?> source = (Map<?, ?>) value; Map<Object, Object> target = createMap(this.mapType, source.size()); source.forEach((key, val) -> target.put(convertKey(key), convertValue(val))); super.setValue(target); } else { throw new IllegalArgumentException("Value cannot be converted to Map: " + value); } }
Create a Map of the given type, with the given initial capacity (if supported by the Map type).
Params:
  • mapType – a sub-interface of Map
  • initialCapacity – the initial capacity
Returns:the new Map instance
/** * Create a Map of the given type, with the given * initial capacity (if supported by the Map type). * @param mapType a sub-interface of Map * @param initialCapacity the initial capacity * @return the new Map instance */
@SuppressWarnings({"rawtypes", "unchecked"}) protected Map<Object, Object> createMap(Class<? extends Map> mapType, int initialCapacity) { if (!mapType.isInterface()) { try { return ReflectionUtils.accessibleConstructor(mapType).newInstance(); } catch (Throwable ex) { throw new IllegalArgumentException( "Could not instantiate map class: " + mapType.getName(), ex); } } else if (SortedMap.class == mapType) { return new TreeMap<>(); } else { return new LinkedHashMap<>(initialCapacity); } }
Return whether to always create a new Map, even if the type of the passed-in Map already matches.

Default is "false"; can be overridden to enforce creation of a new Map, for example to convert elements in any case.

See Also:
/** * Return whether to always create a new Map, * even if the type of the passed-in Map already matches. * <p>Default is "false"; can be overridden to enforce creation of a * new Map, for example to convert elements in any case. * @see #convertKey * @see #convertValue */
protected boolean alwaysCreateNewMap() { return false; }
Hook to convert each encountered Map key. The default implementation simply returns the passed-in key as-is.

Can be overridden to perform conversion of certain keys, for example from String to Integer.

Only called if actually creating a new Map! This is by default not the case if the type of the passed-in Map already matches. Override alwaysCreateNewMap() to enforce creating a new Map in every case.

Params:
  • key – the source key
See Also:
Returns:the key to be used in the target Map
/** * Hook to convert each encountered Map key. * The default implementation simply returns the passed-in key as-is. * <p>Can be overridden to perform conversion of certain keys, * for example from String to Integer. * <p>Only called if actually creating a new Map! * This is by default not the case if the type of the passed-in Map * already matches. Override {@link #alwaysCreateNewMap()} to * enforce creating a new Map in every case. * @param key the source key * @return the key to be used in the target Map * @see #alwaysCreateNewMap */
protected Object convertKey(Object key) { return key; }
Hook to convert each encountered Map value. The default implementation simply returns the passed-in value as-is.

Can be overridden to perform conversion of certain values, for example from String to Integer.

Only called if actually creating a new Map! This is by default not the case if the type of the passed-in Map already matches. Override alwaysCreateNewMap() to enforce creating a new Map in every case.

Params:
  • value – the source value
See Also:
Returns:the value to be used in the target Map
/** * Hook to convert each encountered Map value. * The default implementation simply returns the passed-in value as-is. * <p>Can be overridden to perform conversion of certain values, * for example from String to Integer. * <p>Only called if actually creating a new Map! * This is by default not the case if the type of the passed-in Map * already matches. Override {@link #alwaysCreateNewMap()} to * enforce creating a new Map in every case. * @param value the source value * @return the value to be used in the target Map * @see #alwaysCreateNewMap */
protected Object convertValue(Object value) { return value; }
This implementation returns null to indicate that there is no appropriate text representation.
/** * This implementation returns {@code null} to indicate that * there is no appropriate text representation. */
@Override @Nullable public String getAsText() { return null; } }