Implementation of DynaClass for
* DynaActionForm classes that allow developers to define
* ActionForms without having to individually code all of the classes.
* NOTE - This class is only used in the internal
* implementation of dynamic action form beans. Applications never need
* to consult this documentation.
createDynaActionFormClass() method.
*
* @param config The FormBeanConfig instance describing the properties
* of the bean to be created
*
* @exception IllegalArgumentException if the bean implementation class
* specified in the configuration is not DynaActionForm (or a subclass
* of DynaActionForm)
*/
private DynaActionFormClass(FormBeanConfig config) {
introspect(config);
}
// ----------------------------------------------------- Instance Variables
/**
* The DynaActionForm implementation Class which
* we will use to create new bean instances.
*/
protected transient Class beanClass = null;
/**
* The form bean configuration information for this class.
*/
protected FormBeanConfig config = null;
/**
* The "dynamic class name" for this DynaClass.
*/
protected String name = null;
/**
* 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
/**
* The set of DynaActionFormClass instances that have
* ever been created, keyed by the form bean name.
*/
protected transient static HashMap dynaClasses = new HashMap();
/**
* The lockable object we can synchronize on, even if dynaClasses
* is null,
*/
protected static String lock = "";
// ------------------------------------------------------ DynaClass Methods
/**
* Return the name of this DynaClass (analogous to the
* getName() method of java.lang.ClassDynaClass implementation class to support
* different dynamic classes, with different sets of properties.
*/
public String getName() {
return (this.name);
}
/**
* Return a property descriptor for the specified property, if it exists;
* otherwise, return null.
*
* @param name Name of the dynamic property for which a descriptor
* is requested
*
* @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));
}
/**
* Return an array of DynaPropertys for the properties
* currently defined in this DynaClass. If no properties are defined, a
* zero-length array will be returned.
FIXME - Should we really be implementing
* getBeanInfo() instead, which returns property descriptors
* and a bunch of other stuff?
Instantiate and return a new {@link DynaActionForm} instance,
* associated with this DynaActionFormClass. The
* properties of the returned {@link DynaActionForm} will have been
* initialized to the default values specified in the form bean
* configuration information.
DynaActionFormClass
* instance for the specified form bean configuration instance.
*
* @param config The FormBeanConfig instance describing the properties
* of the bean to be created
*
* @exception IllegalArgumentException if the bean implementation class
* specified in the configuration is not DynaActionForm (or a subclass
* of DynaActionForm)
*/
public static DynaActionFormClass
createDynaActionFormClass(FormBeanConfig config) {
synchronized (lock) {
if (dynaClasses == null) {
dynaClasses = new HashMap();
}
ModuleConfig moduleConfig = config.getModuleConfig();
String key = config.getName();
if (moduleConfig != null) {
key += moduleConfig.getPrefix();
}
DynaActionFormClass dynaClass =
(DynaActionFormClass) dynaClasses.get(key);
if (dynaClass == null) {
dynaClass = new DynaActionFormClass(config);
dynaClasses.put(key, dynaClass);
}
return (dynaClass);
}
}
// ------------------------------------------------------ Protected Methods
/**
* Return the implementation class we are using to construct new
* instances, re-introspecting our {@link FormBeanConfig} if necessary
* (that is, after being deserialized, since beanClass is
* marked transient.
*/
protected Class getBeanClass() {
if (beanClass == null) {
introspect(config);
}
return (beanClass);
}
/**
* Introspect our form bean configuration to identify the supported
* properties.
*
* @param config The FormBeanConfig instance describing the properties
* of the bean to be created
*
* @exception IllegalArgumentException if the bean implementation class
* specified in the configuration is not DynaActionForm (or a subclass
* of DynaActionForm)
*/
protected void introspect(FormBeanConfig config) {
this.config = config;
// Validate the ActionFormBean implementation class
try {
beanClass = RequestUtils.applicationClass(config.getType());
} catch (Throwable t) {
throw new IllegalArgumentException
("Cannot instantiate ActionFormBean class '" +
config.getType() + "': " + t);
}
if (!DynaActionForm.class.isAssignableFrom(beanClass)) {
throw new IllegalArgumentException
("Class '" + config.getType() + "' is not a subclass of " +
"'org.apache.struts.action.DynaActionForm'");
}
// Set the name we will know ourselves by from the form bean name
this.name = config.getName();
// Look up the property descriptors for this bean class
FormPropertyConfig descriptors[] = config.findFormPropertyConfigs();
if (descriptors == null) {
descriptors = new FormPropertyConfig[0];
}
// Create corresponding dynamic property definitions
properties = new DynaProperty[descriptors.length];
for (int i = 0; i < descriptors.length; i++) {
properties[i] =
new DynaProperty(descriptors[i].getName(),
descriptors[i].getTypeClass());
propertiesMap.put(properties[i].getName(),
properties[i]);
}
}
}