|
Commons Beanutils example source code file (BeanMap.java)
The Commons Beanutils BeanMap.java source code/* * 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.beanutils; 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 org.apache.commons.collections.list.UnmodifiableList; import org.apache.commons.collections.keyvalue.AbstractMapEntry; import org.apache.commons.collections.set.UnmodifiableSet; import org.apache.commons.collections.Transformer; /** * 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 * * @version $Revision: 812176 $ $Date: 2009-09-07 15:59:25 +0100 (Mon, 07 Sep 2009) $ * * @author James Strachan * @author Stephen Colebourne */ public class BeanMap extends AbstractMap implements Cloneable { private transient Object bean; private transient HashMap readMethods = new HashMap(); private transient HashMap writeMethods = new HashMap(); private transient HashMap types = new HashMap(); /** * 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 typeTransformers = Collections.unmodifiableMap(createTypeTransformers()); /** * This HashMap has been made unmodifiable to prevent issues when * loaded in a shared ClassLoader enviroment. * * @see "http://issues.apache.org/jira/browse/BEANUTILS-112" * @deprecated Use {@link BeanMap#getTypeTransformer(Class)} method */ public static HashMap defaultTransformers = new HashMap() { public void clear() { throw new UnsupportedOperationException(); } public boolean containsKey(Object key) { return typeTransformers.containsKey(key); } public boolean containsValue(Object value) { return typeTransformers.containsValue(value); } public Set entrySet() { return typeTransformers.entrySet(); } public Object get(Object key) { return typeTransformers.get(key); } public boolean isEmpty() { return false; } public Set keySet() { return typeTransformers.keySet(); } public Object put(Object key, Object value) { throw new UnsupportedOperationException(); } public void putAll(Map m) { throw new UnsupportedOperationException(); } public Object remove(Object key) { throw new UnsupportedOperationException(); } public int size() { return typeTransformers.size(); } public Collection values() { return typeTransformers.values(); } }; private static Map createTypeTransformers() { Map defaultTransformers = new HashMap(); defaultTransformers.put( Boolean.TYPE, new Transformer() { public Object transform( Object input ) { return Boolean.valueOf( input.toString() ); } } ); defaultTransformers.put( Character.TYPE, new Transformer() { public Object transform( Object input ) { return new Character( input.toString().charAt( 0 ) ); } } ); defaultTransformers.put( Byte.TYPE, new Transformer() { public Object transform( Object input ) { return Byte.valueOf( input.toString() ); } } ); defaultTransformers.put( Short.TYPE, new Transformer() { public Object transform( Object input ) { return Short.valueOf( input.toString() ); } } ); defaultTransformers.put( Integer.TYPE, new Transformer() { public Object transform( Object input ) { return Integer.valueOf( input.toString() ); } } ); defaultTransformers.put( Long.TYPE, new Transformer() { public Object transform( Object input ) { return Long.valueOf( input.toString() ); } } ); defaultTransformers.put( Float.TYPE, new Transformer() { public Object transform( Object input ) { return Float.valueOf( input.toString() ); } } ); defaultTransformers.put( Double.TYPE, new Transformer() { public Object transform( Object input ) { return Double.valueOf( input.toString() ); } } ); return defaultTransformers; } // Constructors //------------------------------------------------------------------------- /** * Constructs a new empty <code>BeanMap. */ public BeanMap() { } /** * 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(Object bean) { this.bean = bean; initialise(); } // Map interface //------------------------------------------------------------------------- /** * Renders a string representation of this object. * @return a <code>String representation of this object */ public String toString() { return "BeanMap<" + String.valueOf(bean) + ">"; } /** * 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 */ public Object clone() throws CloneNotSupportedException { 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; Class beanClass = bean.getClass(); // Cannot throw Exception try { newBean = beanClass.newInstance(); } catch (Exception e) { // unable to instantiate throw new CloneNotSupportedException ("Unable to instantiate the underlying bean \"" + beanClass.getName() + "\": " + e); } try { newMap.setBean(newBean); } catch (Exception exception) { throw new CloneNotSupportedException ("Unable to set bean in the cloned bean map: " + exception); } 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. Iterator readableKeys = readMethods.keySet().iterator(); while(readableKeys.hasNext()) { Object key = readableKeys.next(); if(getWriteMethod(key) != null) { newMap.put(key, get(key)); } } } catch (Exception exception) { throw new CloneNotSupportedException ("Unable to copy bean values to cloned bean map: " + exception); } return newMap; } /** * 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(BeanMap map) { Iterator readableKeys = map.readMethods.keySet().iterator(); while (readableKeys.hasNext()) { Object key = readableKeys.next(); if (getWriteMethod(key) != null) { this.put(key, map.get(key)); } } } /** * 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). */ public void clear() { if(bean == null) { return; } Class beanClass = null; try { beanClass = bean.getClass(); bean = beanClass.newInstance(); } catch (Exception e) { throw new UnsupportedOperationException( "Could not create new instance of class: " + beanClass ); } } /** * 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> * Write-only properties will not be matched as the test operates against * property read methods. * * @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 */ public boolean containsKey(Object name) { Method method = getReadMethod(name); return method != null; } /** * Returns true if the bean defines a property whose current value is * the given object. * * @param value the value to check * @return false true if the bean has at least one property whose * current value is that object, false otherwise */ public boolean containsValue(Object value) { // use default implementation return super.containsValue(value); } /** * Returns 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> * Write-only properties will not be matched as the test operates against * property read methods. * * @param name the name of the property whose value to return * @return the value of the property with that name */ public Object get(Object name) { if ( bean != null ) { Method method = getReadMethod( name ); if ( method != null ) { try { return method.invoke( bean, NULL_ARGUMENTS ); } catch ( IllegalAccessException e ) { logWarn( e ); } catch ( IllegalArgumentException e ) { logWarn( e ); } catch ( InvocationTargetException e ) { logWarn( e ); } catch ( NullPointerException e ) { logWarn( e ); } } } return null; } /** * 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 */ public Object put(Object name, Object value) throws IllegalArgumentException, ClassCastException { if ( bean != null ) { Object oldValue = get( name ); Method method = getWriteMethod( name ); if ( method == null ) { throw new IllegalArgumentException( "The bean of type: "+ bean.getClass().getName() + " has no property called: " + name ); } try { Object[] arguments = createWriteMethodArguments( method, value ); method.invoke( bean, arguments ); Object newValue = get( name ); firePropertyChange( name, oldValue, newValue ); } catch ( InvocationTargetException e ) { logInfo( e ); throw new IllegalArgumentException( e.getMessage() ); } catch ( IllegalAccessException e ) { logInfo( e ); throw new IllegalArgumentException( e.getMessage() ); } return oldValue; } return null; } /** * Returns the number of properties defined by the bean. * * @return the number of properties defined by the bean */ public int size() { return readMethods.size(); } /** * Get the keys for this BeanMap. * <p> * Write-only properties are <b>not included in the returned set of * property names, although it is possible to set their value and to get * their type. * * @return BeanMap keys. The Set returned by this method is not * modifiable. */ public Set keySet() { return UnmodifiableSet.decorate(readMethods.keySet()); } /** * Gets a Set of MapEntry objects that are the mappings for this BeanMap. * <p> * Each MapEntry can be set but not removed. * * @return the unmodifiable set of mappings */ public Set entrySet() { return UnmodifiableSet.decorate(new AbstractSet() { public Iterator iterator() { return entryIterator(); } public int size() { return BeanMap.this.readMethods.size(); } }); } /** * Returns the values for the BeanMap. * * @return values for the BeanMap. The returned collection is not * modifiable. */ public Collection values() { ArrayList answer = new ArrayList( readMethods.size() ); for ( Iterator iter = valueIterator(); iter.hasNext(); ) { answer.add( iter.next() ); } return UnmodifiableList.decorate(answer); } // Helper methods //------------------------------------------------------------------------- /** * Returns 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(String name) { return (Class) types.get( name ); } /** * Convenience method for getting an iterator over the keys. * <p> * Write-only properties will not be returned in the iterator. * * @return an iterator over the keys */ public Iterator keyIterator() { return readMethods.keySet().iterator(); } /** * Convenience method for getting an iterator over the values. * * @return an iterator over the values */ public Iterator valueIterator() { final Iterator iter = keyIterator(); return new Iterator() { public boolean hasNext() { return iter.hasNext(); } public Object next() { Object key = iter.next(); return get(key); } public void remove() { throw new UnsupportedOperationException( "remove() not supported for BeanMap" ); } }; } /** * Convenience method for getting an iterator over the entries. * * @return an iterator over the entries */ public Iterator entryIterator() { final Iterator iter = keyIterator(); return new Iterator() { public boolean hasNext() { return iter.hasNext(); } public Object next() { Object key = iter.next(); Object value = get(key); return new Entry( BeanMap.this, key, value ); } public void remove() { throw new UnsupportedOperationException( "remove() not supported for BeanMap" ); } }; } // Properties //------------------------------------------------------------------------- /** * Returns 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; } /** * 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( Object newBean ) { bean = newBean; reinitialise(); } /** * Returns 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(String name) { return (Method) readMethods.get(name); } /** * Returns 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(String name) { return (Method) writeMethods.get(name); } // Implementation methods //------------------------------------------------------------------------- /** * Returns 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( Object name ) { return (Method) readMethods.get( name ); } /** * Returns 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( Object name ) { return (Method) writeMethods.get( name ); } /** * Reinitializes this bean. Called during {@link #setBean(Object)}. * Does introspection to find properties. */ protected void reinitialise() { readMethods.clear(); writeMethods.clear(); types.clear(); initialise(); } private void initialise() { if(getBean() == null) { return; } Class beanClass = getBean().getClass(); try { //BeanInfo beanInfo = Introspector.getBeanInfo( bean, null ); BeanInfo beanInfo = Introspector.getBeanInfo( beanClass ); PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); if ( propertyDescriptors != null ) { for ( int i = 0; i < propertyDescriptors.length; i++ ) { PropertyDescriptor propertyDescriptor = propertyDescriptors[i]; if ( propertyDescriptor != null ) { String name = propertyDescriptor.getName(); Method readMethod = propertyDescriptor.getReadMethod(); Method writeMethod = propertyDescriptor.getWriteMethod(); Class aType = propertyDescriptor.getPropertyType(); if ( readMethod != null ) { readMethods.put( name, readMethod ); } if ( writeMethod != null ) { writeMethods.put( name, writeMethod ); } types.put( name, aType ); } } } } catch ( IntrospectionException e ) { logWarn( e ); } } /** * Called during a successful {@link #put(Object,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( Object key, Object oldValue, Object newValue ) { } // Implementation classes //------------------------------------------------------------------------- /** * Map entry used by {@link BeanMap}. */ protected static class Entry extends AbstractMapEntry { private 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( BeanMap owner, Object key, 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 */ public Object setValue(Object value) { Object key = getKey(); Object oldValue = owner.get( key ); owner.put( key, value ); Object newValue = owner.get( key ); super.setValue( newValue ); return oldValue; } } /** * 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( Method method, Object value ) throws IllegalAccessException, ClassCastException { try { if ( value != null ) { Class[] types = method.getParameterTypes(); if ( types != null && types.length > 0 ) { Class paramType = types[0]; if ( ! paramType.isAssignableFrom( value.getClass() ) ) { value = convertType( paramType, value ); } } } Object[] answer = { value }; return answer; } catch ( InvocationTargetException e ) { logInfo( e ); throw new IllegalArgumentException( e.getMessage() ); } catch ( InstantiationException e ) { logInfo( e ); throw new IllegalArgumentException( e.getMessage() ); } } /** * Converts the given value to the given type. First, reflection is * 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. Other Commons Beanutils examples (source code examples)Here is a short list of links related to this Commons Beanutils BeanMap.java source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2024 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.