BeanMap.java
- /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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
- *
- * http://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.apache.commons.beanutils2;
- import java.beans.BeanInfo;
- import java.beans.IntrospectionException;
- import java.beans.Introspector;
- import java.beans.PropertyDescriptor;
- import java.lang.reflect.Constructor;
- import java.lang.reflect.InvocationTargetException;
- import java.lang.reflect.Method;
- import java.util.AbstractMap;
- import java.util.AbstractSet;
- import java.util.ArrayList;
- import java.util.Collection;
- import java.util.Collections;
- import java.util.HashMap;
- import java.util.Iterator;
- import java.util.Map;
- import java.util.Set;
- import java.util.function.Function;
- /**
- * An implementation of Map for JavaBeans which uses introspection to get and put properties in the bean.
- * <p>
- * If an exception occurs during attempts to get or set a property then the property is considered non existent in the Map
- * </p>
- */
- public class BeanMap extends AbstractMap<String, Object> implements Cloneable {
- /**
- * Map entry used by {@link BeanMap}.
- */
- protected static class Entry extends AbstractMap.SimpleEntry<String, Object> {
- private static final long serialVersionUID = 1L;
- /**
- * The owner.
- */
- private final BeanMap owner;
- /**
- * Constructs a new {@code Entry}.
- *
- * @param owner the BeanMap this entry belongs to
- * @param key the key for this entry
- * @param value the value for this entry
- */
- protected Entry(final BeanMap owner, final String key, final Object value) {
- super(key, value);
- this.owner = owner;
- }
- /**
- * Sets the value.
- *
- * @param value the new value for the entry
- * @return the old value for the entry
- */
- @Override
- public Object setValue(final Object value) {
- final String key = getKey();
- final Object oldValue = owner.get(key);
- owner.put(key, value);
- final Object newValue = owner.get(key);
- super.setValue(newValue);
- return oldValue;
- }
- }
- /**
- * An empty array. Used to invoke accessors via reflection.
- */
- public static final Object[] NULL_ARGUMENTS = {};
- /**
- * Maps primitive Class types to transformers. The transformer transform strings into the appropriate primitive wrapper.
- *
- * N.B. private & unmodifiable replacement for the (public & static) defaultTransformers instance.
- */
- private static final Map<Class<? extends Object>, Function<?, ?>> typeTransformers = Collections.unmodifiableMap(createTypeTransformers());
- private static Map<Class<? extends Object>, Function<?, ?>> createTypeTransformers() {
- final Map<Class<? extends Object>, Function<?, ?>> defTransformers = new HashMap<>();
- defTransformers.put(Boolean.TYPE, input -> Boolean.valueOf(input.toString()));
- defTransformers.put(Character.TYPE, input -> Character.valueOf(input.toString().charAt(0)));
- defTransformers.put(Byte.TYPE, input -> Byte.valueOf(input.toString()));
- defTransformers.put(Short.TYPE, input -> Short.valueOf(input.toString()));
- defTransformers.put(Integer.TYPE, input -> Integer.valueOf(input.toString()));
- defTransformers.put(Long.TYPE, input -> Long.valueOf(input.toString()));
- defTransformers.put(Float.TYPE, input -> Float.valueOf(input.toString()));
- defTransformers.put(Double.TYPE, input -> Double.valueOf(input.toString()));
- return defTransformers;
- }
- private transient Object bean;
- private final transient HashMap<String, Method> readMethods = new HashMap<>();
- private final transient HashMap<String, Method> writeMethods = new HashMap<>();
- private final transient HashMap<String, Class<? extends Object>> types = new HashMap<>();
- /**
- * Constructs a new empty {@code BeanMap}.
- */
- public BeanMap() {
- }
- // Map interface
- /**
- * Constructs a new {@code BeanMap} that operates on the specified bean. If the given bean is {@code null}, then this map will be empty.
- *
- * @param bean the bean for this map to operate on
- */
- public BeanMap(final Object bean) {
- this.bean = bean;
- initialize();
- }
- /**
- * This method reinitializes the bean map to have default values for the bean's properties. This is accomplished by constructing a new instance of the bean
- * which the map uses as its underlying data source. This behavior for {@code clear()} differs from the Map contract in that the mappings are not actually
- * removed from the map (the mappings for a BeanMap are fixed).
- */
- @Override
- public void clear() {
- if (bean == null) {
- return;
- }
- Class<? extends Object> beanClass = null;
- try {
- beanClass = bean.getClass();
- bean = beanClass.newInstance();
- } catch (final Exception e) {
- throw new UnsupportedOperationException("Could not create new instance of class: " + beanClass, e);
- }
- }
- /**
- * Clone this bean map using the following process:
- *
- * <ul>
- * <li>If there is no underlying bean, return a cloned BeanMap without a bean.
- * <li>Since there is an underlying bean, try to instantiate a new bean of the same type using Class.newInstance().
- * <li>If the instantiation fails, throw a CloneNotSupportedException
- * <li>Clone the bean map and set the newly instantiated bean as the underlying bean for the bean map.
- * <li>Copy each property that is both readable and writable from the existing object to a cloned bean map.
- * <li>If anything fails along the way, throw a CloneNotSupportedException.
- * </ul>
- *
- * @return a cloned instance of this bean map
- * @throws CloneNotSupportedException if the underlying bean cannot be cloned
- */
- @Override
- public Object clone() throws CloneNotSupportedException {
- final BeanMap newMap = (BeanMap) super.clone();
- if (bean == null) {
- // no bean, just an empty bean map at the moment. return a newly
- // cloned and empty bean map.
- return newMap;
- }
- Object newBean = null;
- final Class<? extends Object> beanClass = bean.getClass(); // Cannot throw Exception
- try {
- newBean = beanClass.newInstance();
- } catch (final Exception e) {
- // unable to instantiate
- final CloneNotSupportedException cnse = new CloneNotSupportedException(
- "Unable to instantiate the underlying bean \"" + beanClass.getName() + "\": " + e);
- cnse.initCause(e);
- throw cnse;
- }
- try {
- newMap.setBean(newBean);
- } catch (final Exception e) {
- final CloneNotSupportedException cnse = new CloneNotSupportedException("Unable to set bean in the cloned bean map: " + e);
- cnse.initCause(e);
- throw cnse;
- }
- try {
- // copy only properties that are readable and writable. If its
- // not readable, we can't get the value from the old map. If
- // its not writable, we can't write a value into the new map.
- readMethods.keySet().forEach(key -> {
- if (getWriteMethod(key) != null) {
- newMap.put(key, get(key));
- }
- });
- } catch (final Exception e) {
- final CloneNotSupportedException cnse = new CloneNotSupportedException("Unable to copy bean values to cloned bean map: " + e);
- cnse.initCause(e);
- throw cnse;
- }
- return newMap;
- }
- /**
- * Returns true if the bean defines a property with the given name.
- * <p>
- * The given name must be a {@code String}; if not, this method returns false. This method will also return false if the bean does not define a property
- * with that name.
- * </p>
- * <p>
- * Write-only properties will not be matched as the test operates against property read methods.
- * </p>
- *
- * @param name the name of the property to check
- * @return false if the given name is null or is not a {@code String}; false if the bean does not define a property with that name; or true if the bean does
- * define a property with that name
- */
- @Override
- public boolean containsKey(final Object name) {
- return getReadMethod(name) != null;
- }
- /**
- * Converts the given value to the given type. First, reflection is used to find a public constructor declared by the given class that takes one argument,
- * which must be the precise type of the given value. If such a constructor is found, a new object is created by passing the given value to that
- * constructor, and the newly constructed object is returned.
- * <p>
- * If no such constructor exists, and the given type is a primitive type, then the given value is converted to a string using its {@link Object#toString()
- * toString()} method, and that string is parsed into the correct primitive type using, for instance, {@link Integer#valueOf(String)} to convert the string
- * into an {@code int}.
- * </p>
- * <p>
- * If no special constructor exists and the given type is not a primitive type, this method returns the original value.
- * </p>
- *
- * @param <R> The return type.
- * @param newType the type to convert the value to
- * @param value the value to convert
- * @return the converted value
- * @throws NumberFormatException if newType is a primitive type, and the string representation of the given value cannot be converted to that type
- * @throws InstantiationException if the constructor found with reflection raises it
- * @throws InvocationTargetException if the constructor found with reflection raises it
- * @throws IllegalAccessException never
- * @throws IllegalArgumentException never
- */
- protected <R> Object convertType(final Class<R> newType, final Object value)
- throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
- // try call constructor
- try {
- final Constructor<R> constructor = newType.getConstructor(value.getClass());
- return constructor.newInstance(value);
- } catch (final NoSuchMethodException e) {
- // try using the transformers
- final Function<Object, R> transformer = getTypeTransformer(newType);
- if (transformer != null) {
- return transformer.apply(value);
- }
- return value;
- }
- }
- /**
- * Creates an array of parameters to pass to the given mutator method. If the given object is not the right type to pass to the method directly, it will be
- * converted using {@link #convertType(Class,Object)}.
- *
- * @param method the mutator method
- * @param value the value to pass to the mutator method
- * @return an array containing one object that is either the given value or a transformed value
- * @throws IllegalAccessException if {@link #convertType(Class,Object)} raises it
- * @throws IllegalArgumentException if any other exception is raised by {@link #convertType(Class,Object)}
- * @throws ClassCastException if an error occurs creating the method args
- */
- protected Object[] createWriteMethodArguments(final Method method, Object value) throws IllegalAccessException, ClassCastException {
- try {
- if (value != null) {
- final Class<? extends Object>[] paramTypes = method.getParameterTypes();
- if (paramTypes != null && paramTypes.length > 0) {
- final Class<? extends Object> paramType = paramTypes[0];
- if (!paramType.isAssignableFrom(value.getClass())) {
- value = convertType(paramType, value);
- }
- }
- }
- return new Object[] { value };
- } catch (final InvocationTargetException | InstantiationException e) {
- throw new IllegalArgumentException(e.getMessage(), e);
- }
- }
- /**
- * Convenience method for getting an iterator over the entries.
- *
- * @return an iterator over the entries
- */
- public Iterator<Map.Entry<String, Object>> entryIterator() {
- final Iterator<String> iter = keyIterator();
- return new Iterator<Map.Entry<String, Object>>() {
- @Override
- public boolean hasNext() {
- return iter.hasNext();
- }
- @Override
- public Map.Entry<String, Object> next() {
- final String key = iter.next();
- final Object value = get(key);
- // This should not cause any problems; the key is actually a
- // string, but it does no harm to expose it as Object
- return new Entry(BeanMap.this, key, value);
- }
- @Override
- public void remove() {
- throw new UnsupportedOperationException("remove() not supported for BeanMap");
- }
- };
- }
- /**
- * Gets a Set of MapEntry objects that are the mappings for this BeanMap.
- * <p>
- * Each MapEntry can be set but not removed.
- * </p>
- *
- * @return the unmodifiable set of mappings
- */
- @Override
- public Set<Map.Entry<String, Object>> entrySet() {
- return Collections.unmodifiableSet(new AbstractSet<Map.Entry<String, Object>>() {
- @Override
- public Iterator<Map.Entry<String, Object>> iterator() {
- return entryIterator();
- }
- @Override
- public int size() {
- return BeanMap.this.readMethods.size();
- }
- });
- }
- /**
- * Called during a successful {@link #put(String,Object)} operation. Default implementation does nothing. Override to be notified of property changes in the
- * bean caused by this map.
- *
- * @param key the name of the property that changed
- * @param oldValue the old value for that property
- * @param newValue the new value for that property
- */
- protected void firePropertyChange(final Object key, final Object oldValue, final Object newValue) {
- // noop
- }
- /**
- * Gets the value of the bean's property with the given name.
- * <p>
- * The given name must be a {@link String} and must not be null; otherwise, this method returns {@code null}. If the bean defines a property with the given
- * name, the value of that property is returned. Otherwise, {@code null} is returned.
- * </p>
- * <p>
- * Write-only properties will not be matched as the test operates against property read methods.
- * </p>
- *
- * @param name the name of the property whose value to return
- * @return the value of the property with that name
- */
- @Override
- public Object get(final Object name) {
- if (bean != null) {
- final Method method = getReadMethod(name);
- if (method != null) {
- try {
- return method.invoke(bean, NULL_ARGUMENTS);
- } catch (final IllegalAccessException | NullPointerException | InvocationTargetException | IllegalArgumentException e) {
- logWarn(e);
- }
- }
- }
- return null;
- }
- /**
- * Gets the bean currently being operated on. The return value may be null if this map is empty.
- *
- * @return the bean being operated on by this map
- */
- public Object getBean() {
- return bean;
- }
- // Helper methods
- /**
- * Gets the accessor for the property with the given name.
- *
- * @param name the name of the property
- * @return null if the name is null; null if the name is not a {@link String}; null if no such property exists; or the accessor method for that property
- */
- protected Method getReadMethod(final Object name) {
- return readMethods.get(name);
- }
- /**
- * Gets the accessor for the property with the given name.
- *
- * @param name the name of the property
- * @return the accessor method for the property, or null
- */
- public Method getReadMethod(final String name) {
- return readMethods.get(name);
- }
- /**
- * Gets the type of the property with the given name.
- *
- * @param name the name of the property
- * @return the type of the property, or {@code null} if no such property exists
- */
- public Class<?> getType(final String name) {
- return types.get(name);
- }
- /**
- * Gets a transformer for the given primitive type.
- *
- * @param <R> The transformer result type.
- * @param type the primitive type whose transformer to return
- * @return a transformer that will convert strings into that type, or null if the given type is not a primitive type
- */
- protected <R> Function<Object, R> getTypeTransformer(final Class<R> type) {
- return (Function<Object, R>) typeTransformers.get(type);
- }
- /**
- * Gets the mutator for the property with the given name.
- *
- * @param name the name of the
- * @return null if the name is null; null if the name is not a {@link String}; null if no such property exists; null if the property is read-only; or the
- * mutator method for that property
- */
- protected Method getWriteMethod(final Object name) {
- return writeMethods.get(name);
- }
- /**
- * Gets the mutator for the property with the given name.
- *
- * @param name the name of the property
- * @return the mutator method for the property, or null
- */
- public Method getWriteMethod(final String name) {
- return writeMethods.get(name);
- }
- private void initialize() {
- if (getBean() == null) {
- return;
- }
- final Class<? extends Object> beanClass = getBean().getClass();
- try {
- // BeanInfo beanInfo = Introspector.getBeanInfo( bean, null );
- final BeanInfo beanInfo = Introspector.getBeanInfo(beanClass);
- final PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
- if (propertyDescriptors != null) {
- for (final PropertyDescriptor propertyDescriptor : propertyDescriptors) {
- if (propertyDescriptor != null) {
- final String name = propertyDescriptor.getName();
- final Method readMethod = propertyDescriptor.getReadMethod();
- final Method writeMethod = propertyDescriptor.getWriteMethod();
- final Class<? extends Object> aType = propertyDescriptor.getPropertyType();
- if (readMethod != null) {
- readMethods.put(name, readMethod);
- }
- if (writeMethod != null) {
- writeMethods.put(name, writeMethod);
- }
- types.put(name, aType);
- }
- }
- }
- } catch (final IntrospectionException e) {
- logWarn(e);
- }
- }
- /**
- * Convenience method for getting an iterator over the keys.
- * <p>
- * Write-only properties will not be returned in the iterator.
- * </p>
- *
- * @return an iterator over the keys
- */
- public Iterator<String> keyIterator() {
- return readMethods.keySet().iterator();
- }
- // Implementation methods
- /**
- * Gets the keys for this BeanMap.
- * <p>
- * Write-only properties are <strong>not</strong> included in the returned set of property names, although it is possible to set their value and to get
- * their type.
- * </p>
- *
- * @return BeanMap keys. The Set returned by this method is not modifiable.
- */
- @SuppressWarnings({ "unchecked", "rawtypes" })
- // The set actually contains strings; however, because it cannot be
- // modified there is no danger in selling it as Set<Object>
- @Override
- public Set<String> keySet() {
- return Collections.unmodifiableSet((Set) readMethods.keySet());
- }
- /**
- * Logs the given exception to {@code System.out}. Used to display warnings while accessing/mutating the bean.
- *
- * @param ex the exception to log
- */
- protected void logInfo(final Exception ex) {
- // Deliberately do not use LOG4J or Commons Logging to avoid dependencies
- System.out.println("INFO: Exception: " + ex);
- }
- /**
- * Logs the given exception to {@code System.err}. Used to display errors while accessing/mutating the bean.
- *
- * @param ex the exception to log
- */
- protected void logWarn(final Exception ex) {
- // Deliberately do not use LOG4J or Commons Logging to avoid dependencies
- System.out.println("WARN: Exception: " + ex);
- ex.printStackTrace();
- }
- /**
- * Sets the bean property with the given name to the given value.
- *
- * @param name the name of the property to set
- * @param value the value to set that property to
- * @return the previous value of that property
- * @throws IllegalArgumentException if the given name is null; if the given name is not a {@link String}; if the bean doesn't define a property with that
- * name; or if the bean property with that name is read-only
- * @throws ClassCastException if an error occurs creating the method args
- */
- @Override
- public Object put(final String name, final Object value) throws IllegalArgumentException, ClassCastException {
- if (bean != null) {
- final Object oldValue = get(name);
- final Method method = getWriteMethod(name);
- if (method == null) {
- throw new IllegalArgumentException("The bean of type: " + bean.getClass().getName() + " has no property called: " + name);
- }
- try {
- final Object[] arguments = createWriteMethodArguments(method, value);
- method.invoke(bean, arguments);
- final Object newValue = get(name);
- firePropertyChange(name, oldValue, newValue);
- } catch (final InvocationTargetException | IllegalAccessException e) {
- throw new IllegalArgumentException(e.getMessage(), e);
- }
- return oldValue;
- }
- return null;
- }
- /**
- * Puts all of the writable properties from the given BeanMap into this BeanMap. Read-only and Write-only properties will be ignored.
- *
- * @param map the BeanMap whose properties to put
- */
- public void putAllWriteable(final BeanMap map) {
- map.readMethods.keySet().forEach(key -> {
- if (getWriteMethod(key) != null) {
- put(key, map.get(key));
- }
- });
- }
- // Implementation classes
- /**
- * Reinitializes this bean. Called during {@link #setBean(Object)}. Does introspection to find properties.
- */
- protected void reinitialise() {
- readMethods.clear();
- writeMethods.clear();
- types.clear();
- initialize();
- }
- /**
- * Sets the bean to be operated on by this map. The given value may be null, in which case this map will be empty.
- *
- * @param newBean the new bean to operate on
- */
- public void setBean(final Object newBean) {
- bean = newBean;
- reinitialise();
- }
- /**
- * Returns the number of properties defined by the bean.
- *
- * @return the number of properties defined by the bean
- */
- @Override
- public int size() {
- return readMethods.size();
- }
- /**
- * Renders a string representation of this object.
- *
- * @return a {@code String} representation of this object
- */
- @Override
- public String toString() {
- return "BeanMap<" + bean + ">";
- }
- /**
- * Convenience method for getting an iterator over the values.
- *
- * @return an iterator over the values
- */
- public Iterator<Object> valueIterator() {
- final Iterator<?> iter = keyIterator();
- return new Iterator<Object>() {
- @Override
- public boolean hasNext() {
- return iter.hasNext();
- }
- @Override
- public Object next() {
- final Object key = iter.next();
- return get(key);
- }
- @Override
- public void remove() {
- throw new UnsupportedOperationException("remove() not supported for BeanMap");
- }
- };
- }
- /**
- * Gets the values for the BeanMap.
- *
- * @return values for the BeanMap. The returned collection is not modifiable.
- */
- @Override
- public Collection<Object> values() {
- final ArrayList<Object> answer = new ArrayList<>(readMethods.size());
- valueIterator().forEachRemaining(answer::add);
- return Collections.unmodifiableList(answer);
- }
- }