org.apache.commons.beanutils.WrapDynaClass Maven / Gradle / Ivy
/*
* 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.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
/**
* Implementation of DynaClass for DynaBeans that wrap
* standard JavaBean instances.
*
*
* It is suggested that this class should not usually need to be used directly
* to create new WrapDynaBean instances.
* It's usually better to call the WrapDynaBean constructor directly.
* For example:
*
* Object javaBean = ...;
* DynaBean wrapper = new WrapDynaBean(javaBean);
*
*
* @version $Id: WrapDynaClass.java 1547902 2013-12-04 20:35:01Z oheger $
*/
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 createDynaClass(Class) method.
*
* @param beanClass JavaBean class to be introspected around
* @param propUtils the {@code PropertyUtilsBean} associated with this class
*/
private WrapDynaClass(Class beanClass, PropertyUtilsBean propUtils) {
this.beanClassRef = new SoftReference>(beanClass);
this.beanClassName = beanClass.getName();
propertyUtilsBean = propUtils;
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;
/** Stores the associated {@code PropertyUtilsBean} instance. */
private final PropertyUtilsBean propertyUtilsBean;
/**
* The JavaBean Class which is represented by this
* WrapDynaClass.
*
* @deprecated No longer initialized, use getBeanClass() method instead
*/
@Deprecated
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 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 properties list.
*/
protected HashMap propertiesMap = new HashMap();
// ------------------------------------------------------- Static Variables
private static final ContextClassLoaderLocal> CLASSLOADER_CACHE =
new ContextClassLoaderLocal>() {
@Override
protected Map initialValue() {
return new WeakHashMap();
}
};
/**
* Get the wrap dyna classes cache. Note: This method only exists to
* satisfy the deprecated {@code dynaClasses} hash map.
*/
@SuppressWarnings("unchecked")
private static Map getDynaClassesMap() {
@SuppressWarnings("rawtypes")
Map cache = CLASSLOADER_CACHE.get();
return cache;
}
/**
* Returns the cache for the already created class instances. For each
* combination of bean class and {@code PropertyUtilsBean} instance an
* entry is created in the cache.
* @return the cache for already created {@code WrapDynaClass} instances
*/
private static Map getClassesCache() {
return CLASSLOADER_CACHE.get();
}
/**
* The set of 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.
*
* 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.
*
* 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
*/
@Deprecated
protected static HashMap dynaClasses = new HashMap() {
@Override
public void clear() {
getDynaClassesMap().clear();
}
@Override
public boolean containsKey(Object key) {
return getDynaClassesMap().containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return getDynaClassesMap().containsValue(value);
}
@Override
public Set> entrySet() {
return getDynaClassesMap().entrySet();
}
@Override
public boolean equals(Object o) {
return getDynaClassesMap().equals(o);
}
@Override
public Object get(Object key) {
return getDynaClassesMap().get(key);
}
@Override
public int hashCode() {
return getDynaClassesMap().hashCode();
}
@Override
public boolean isEmpty() {
return getDynaClassesMap().isEmpty();
}
@Override
public Set
*
* Object javaBean = ...;
* DynaBean wrapper = new WrapDynaBean(javaBean);
*
* (This method is needed for some kinds of DynaBean framework.)
*
*
* @return A new 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 null.
*
* @param name Name of the property to be retrieved
* @return The descriptor for the specified property
*/
public PropertyDescriptor getPropertyDescriptor(String name) {
return (descriptorsMap.get(name));
}
// --------------------------------------------------------- Static Methods
/**
* Clear our cache of WrapDynaClass instances.
*/
public static void clear() {
getClassesCache().clear();
}
/**
* Create (if necessary) and return a new WrapDynaClass
* instance for the specified bean class.
*
* @param beanClass Bean class for which a WrapDynaClass is requested
* @return A new Wrap {@link DynaClass}
*/
public static WrapDynaClass createDynaClass(Class beanClass) {
return createDynaClass(beanClass, null);
}
/**
* Create (if necessary) and return a new {@code WrapDynaClass} instance
* for the specified bean class using the given {@code PropertyUtilsBean}
* instance for introspection. Using this method a specially configured
* {@code PropertyUtilsBean} instance can be hooked into the introspection
* mechanism of the managed bean. The argument is optional; if no
* {@code PropertyUtilsBean} object is provided, the default instance is used.
* @param beanClass Bean class for which a WrapDynaClass is requested
* @param pu the optional {@code PropertyUtilsBean} to be used for introspection
* @return A new Wrap {@link DynaClass}
* @since 1.9
*/
public static WrapDynaClass createDynaClass(Class beanClass, PropertyUtilsBean pu) {
PropertyUtilsBean propUtils = (pu != null) ? pu : PropertyUtilsBean.getInstance();
CacheKey key = new CacheKey(beanClass, propUtils);
WrapDynaClass dynaClass = getClassesCache().get(key);
if (dynaClass == null) {
dynaClass = new WrapDynaClass(beanClass, propUtils);
getClassesCache().put(key, dynaClass);
}
return (dynaClass);
}
// ------------------------------------------------------ Protected Methods
/**
* Returns the {@code PropertyUtilsBean} instance associated with this class. This
* bean is used for introspection.
*
* @return the associated {@code PropertyUtilsBean} instance
* @since 1.9
*/
protected PropertyUtilsBean getPropertyUtilsBean() {
return propertyUtilsBean;
}
/**
* 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 =
getPropertyUtilsBean().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++;
}
}
/**
* A class representing the combined key for the cache of {@code WrapDynaClass}
* instances. A single key consists of a bean class and an instance of
* {@code PropertyUtilsBean}. Instances are immutable.
*/
private static class CacheKey {
/** The bean class. */
private final Class beanClass;
/** The instance of PropertyUtilsBean. */
private final PropertyUtilsBean propUtils;
/**
* Creates a new instance of {@code CacheKey}.
*
* @param beanCls the bean class
* @param pu the instance of {@code PropertyUtilsBean}
*/
public CacheKey(Class beanCls, PropertyUtilsBean pu) {
beanClass = beanCls;
propUtils = pu;
}
@Override
public int hashCode() {
int factor = 31;
int result = 17;
result = factor * beanClass.hashCode() + result;
result = factor * propUtils.hashCode() + result;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof CacheKey)) {
return false;
}
CacheKey c = (CacheKey) obj;
return beanClass.equals(c.beanClass) && propUtils.equals(c.propUtils);
}
}
}