The Commons Beanutils WrapDynaClass.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.PropertyDescriptor;
import java.lang.ref.Reference;
import java.lang.ref.SoftReference;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
/**
* <p>Implementation of DynaClass for DynaBeans that wrap
* standard JavaBean instances.</p>
*
* <p>
* It is suggested that this class should not usually need to be used directly
* to create new <code>WrapDynaBean instances.
* It's usually better to call the <code>WrapDynaBean constructor directly.
* For example:</p>
* <code> * Object javaBean = ...;
* DynaBean wrapper = new WrapDynaBean(javaBean);
* </pre>
* <p>
*
* @author Craig McClanahan
* @version $Revision: 690380 $ $Date: 2008-08-29 21:04:38 +0100 (Fri, 29 Aug 2008) $
*/
public class WrapDynaClass implements DynaClass {
// ----------------------------------------------------------- Constructors
/**
* Construct a new WrapDynaClass for the specified JavaBean class. This
* constructor is private; WrapDynaClass instances will be created as
* needed via calls to the <code>createDynaClass(Class) method.
*
* @param beanClass JavaBean class to be introspected around
*/
private WrapDynaClass(Class beanClass) {
this.beanClassRef = new SoftReference(beanClass);
this.beanClassName = beanClass.getName();
introspect();
}
// ----------------------------------------------------- Instance Variables
/**
* Name of the JavaBean class represented by this WrapDynaClass.
*/
private String beanClassName = null;
/**
* Reference to the JavaBean class represented by this WrapDynaClass.
*/
private Reference beanClassRef = null;
/**
* The JavaBean <code>Class which is represented by this
* <code>WrapDynaClass.
*
* @deprecated No longer initialized, use getBeanClass() method instead
*/
protected Class beanClass = null;
/**
* The set of PropertyDescriptors for this bean class.
*/
protected PropertyDescriptor[] descriptors = null;
/**
* The set of PropertyDescriptors for this bean class, keyed by the
* property name. Individual descriptor instances will be the same
* instances as those in the <code>descriptors list.
*/
protected HashMap descriptorsMap = new HashMap();
/**
* The set of dynamic properties that are part of this DynaClass.
*/
protected DynaProperty[] properties = null;
/**
* The set of dynamic properties that are part of this DynaClass,
* keyed by the property name. Individual descriptor instances will
* be the same instances as those in the <code>properties list.
*/
protected HashMap propertiesMap = new HashMap();
// ------------------------------------------------------- Static Variables
private static final ContextClassLoaderLocal CLASSLOADER_CACHE =
new ContextClassLoaderLocal() {
protected Object initialValue() {
return new WeakHashMap();
}
};
/**
* Get the wrap dyna classes cache
*/
private static Map getDynaClassesMap() {
return (Map)CLASSLOADER_CACHE.get();
}
/**
* The set of <code>WrapDynaClass instances that have ever been
* created, keyed by the underlying bean Class. The keys to this map
* are Class objects, and the values are corresponding WrapDynaClass
* objects.
* <p>
* This static variable is safe even when this code is deployed via a
* shared classloader because it is keyed via a Class object. The same
* class loaded via two different classloaders will result in different
* entries in this map.
* <p>
* Note, however, that this HashMap can result in a memory leak. When
* this class is in a shared classloader it will retain references to
* classes loaded via a webapp classloader even after the webapp has been
* undeployed. That will prevent the entire classloader and all the classes
* it refers to and all their static members from being freed.
*
************* !!!!!!!!!!!! PLEASE NOTE !!!!!!!!!!!! *************
*
* THE FOLLOWING IS A NASTY HACK TO SO THAT BEANUTILS REMAINS BINARY
* COMPATIBLE WITH PREVIOUS RELEASES.
*
* There are two issues here:
*
* 1) Memory Issues: The static HashMap caused memory problems (See BEANUTILS-59)
* to resolve this it has been moved into a ContextClassLoaderLocal instance
* (named CLASSLOADER_CACHE above) which holds one copy per
* ClassLoader in a WeakHashMap.
*
* 2) Binary Compatibility: As the "dynaClasses" static HashMap is "protected"
* removing it breaks BeanUtils binary compatibility with previous versions.
* To resolve this all the methods have been overriden to delegate to the
* Map for the ClassLoader in the ContextClassLoaderLocal.
*
* @deprecated The dynaClasses Map will be removed in a subsequent release
*/
protected static HashMap dynaClasses = new HashMap() {
public void clear() {
getDynaClassesMap().clear();
}
public boolean containsKey(Object key) {
return getDynaClassesMap().containsKey(key);
}
public boolean containsValue(Object value) {
return getDynaClassesMap().containsValue(value);
}
public Set entrySet() {
return getDynaClassesMap().entrySet();
}
public boolean equals(Object o) {
return getDynaClassesMap().equals(o);
}
public Object get(Object key) {
return getDynaClassesMap().get(key);
}
public int hashCode() {
return getDynaClassesMap().hashCode();
}
public boolean isEmpty() {
return getDynaClassesMap().isEmpty();
}
public Set keySet() {
return getDynaClassesMap().keySet();
}
public Object put(Object key, Object value) {
return getDynaClassesMap().put(key, value);
}
public void putAll(Map m) {
getDynaClassesMap().putAll(m);
}
public Object remove(Object key) {
return getDynaClassesMap().remove(key);
}
public int size() {
return getDynaClassesMap().size();
}
public Collection values() {
return getDynaClassesMap().values();
}
};
// ------------------------------------------------------ DynaClass Methods
/**
* Return the class of the underlying wrapped bean.
*
* @return the class of the underlying wrapped bean
* @since 1.8.0
*/
protected Class getBeanClass() {
return (Class)beanClassRef.get();
}
/**
* Return the name of this DynaClass (analogous to the
* <code>getName() method of java.lang.Class implementation class to support
* different dynamic classes, with different sets of properties.
*
* @return the name of the DynaClass
*/
public String getName() {
return beanClassName;
}
/**
* Return a property descriptor for the specified property, if it exists;
* otherwise, return <code>null.
*
* @param name Name of the dynamic property for which a descriptor
* is requested
* @return The descriptor for the specified property
*
* @exception IllegalArgumentException if no property name is specified
*/
public DynaProperty getDynaProperty(String name) {
if (name == null) {
throw new IllegalArgumentException
("No property name specified");
}
return ((DynaProperty) propertiesMap.get(name));
}
/**
* <p>Return an array of ProperyDescriptors for the properties
* currently defined in this DynaClass. If no properties are defined, a
* zero-length array will be returned.</p>
*
* <p>FIXME - Should we really be implementing
* <code>getBeanInfo() instead, which returns property descriptors
* and a bunch of other stuff?</p>
*
* @return the set of properties for this DynaClass
*/
public DynaProperty[] getDynaProperties() {
return (properties);
}
/**
* <p>Instantiates a new standard JavaBean instance associated with
* this DynaClass and return it wrapped in a new WrapDynaBean
* instance. <strong>NOTE the JavaBean should have a
* no argument constructor.</p>
*
* <strong>NOTE - Most common use cases should not need to use
* this method. It is usually better to create new
* <code>WrapDynaBean instances by calling its constructor.
* For example:</p>
* <code> * Object javaBean = ...;
* DynaBean wrapper = new WrapDynaBean(javaBean);
* </pre>
* <p>
* (This method is needed for some kinds of <code>DynaBean framework.)
* </p>
*
* @return A new <code>DynaBean instance
* @exception IllegalAccessException if the Class or the appropriate
* constructor is not accessible
* @exception InstantiationException if this Class represents an abstract
* class, an array class, a primitive type, or void; or if instantiation
* fails for some other reason
*/
public DynaBean newInstance()
throws IllegalAccessException, InstantiationException {
return new WrapDynaBean(getBeanClass().newInstance());
}
// --------------------------------------------------------- Public Methods
/**
* Return the PropertyDescriptor for the specified property name, if any;
* otherwise return <code>null.
*
* @param name Name of the property to be retrieved
* @return The descriptor for the specified property
*/
public PropertyDescriptor getPropertyDescriptor(String name) {
return ((PropertyDescriptor) descriptorsMap.get(name));
}
// --------------------------------------------------------- Static Methods
/**
* Clear our cache of WrapDynaClass instances.
*/
public static void clear() {
getDynaClassesMap().clear();
}
/**
* Create (if necessary) and return a new <code>WrapDynaClass
* instance for the specified bean class.
*
* @param beanClass Bean class for which a WrapDynaClass is requested
* @return A new <i>Wrap {@link DynaClass}
*/
public static WrapDynaClass createDynaClass(Class beanClass) {
WrapDynaClass dynaClass =
(WrapDynaClass) getDynaClassesMap().get(beanClass);
if (dynaClass == null) {
dynaClass = new WrapDynaClass(beanClass);
getDynaClassesMap().put(beanClass, dynaClass);
}
return (dynaClass);
}
// ------------------------------------------------------ Protected Methods
/**
* Introspect our bean class to identify the supported properties.
*/
protected void introspect() {
// Look up the property descriptors for this bean class
Class beanClass = getBeanClass();
PropertyDescriptor[] regulars =
PropertyUtils.getPropertyDescriptors(beanClass);
if (regulars == null) {
regulars = new PropertyDescriptor[0];
}
Map mappeds =
PropertyUtils.getMappedPropertyDescriptors(beanClass);
if (mappeds == null) {
mappeds = new HashMap();
}
// Construct corresponding DynaProperty information
properties = new DynaProperty[regulars.length + mappeds.size()];
for (int i = 0; i < regulars.length; i++) {
descriptorsMap.put(regulars[i].getName(),
regulars[i]);
properties[i] =
new DynaProperty(regulars[i].getName(),
regulars[i].getPropertyType());
propertiesMap.put(properties[i].getName(),
properties[i]);
}
int j = regulars.length;
Iterator names = mappeds.keySet().iterator();
while (names.hasNext()) {
String name = (String) names.next();
PropertyDescriptor descriptor =
(PropertyDescriptor) mappeds.get(name);
properties[j] =
new DynaProperty(descriptor.getName(),
Map.class);
propertiesMap.put(properties[j].getName(),
properties[j]);
j++;
}
}
}
Other Commons Beanutils examples (source code examples)
Here is a short list of links related to this Commons Beanutils WrapDynaClass.java source code file:
The search page
Other Commons Beanutils source code examples at this package level
Click here to learn more about this project
