FieldInfo
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class FieldInfo
{
//For clarity of code I am not generating the getters and setters
//Generate them before production
public Method m_getAccessor = null;
public Method m_setAccessor = null;
public String m_name = null;
public String m_xmlName = null;
public boolean m_attribute = false;
private Class m_class = null;
private Class m_fieldType = null;
public FieldInfo(Class fieldClass, String name, String xmlName, boolean isAttribute)
throws NoSuchMethodException, NoSuchFieldException
{
m_name = name;
m_xmlName = xmlName;
m_attribute = isAttribute;
m_class = fieldClass;
m_fieldType = getFieldType(name);
m_getAccessor = getAccessorGetMethod(name);
m_setAccessor = getAccessorSetMethod(name);
}
public FieldInfo(Class fieldClass,String name, String xmlName)
throws NoSuchMethodException, NoSuchFieldException
{
this(fieldClass,name,xmlName,false);
}
public FieldInfo(Class fieldClass, String name)
throws NoSuchMethodException, NoSuchFieldException
{
this(fieldClass,name,name,false);
}
String getValueAsString(Object o)
throws InvocationTargetException, IllegalAccessException
{
Object reply = m_getAccessor.invoke(o,null);
return reply.toString();
}
private Method getAccessorGetMethod(String fieldName)
throws NoSuchMethodException
{
String firstPart = fieldName.substring(0,1);
String secondPart = fieldName.substring(1);
String getMethodName = "get" + firstPart.toUpperCase() + secondPart;
//System.out.println(getMethodName);
return m_class.getDeclaredMethod(getMethodName,null);
}
private Method getAccessorSetMethod(String fieldName)
throws NoSuchMethodException
{
String firstPart = fieldName.substring(0,1);
String secondPart = fieldName.substring(1);
String getMethodName = "set" + firstPart.toUpperCase() + secondPart;
//System.out.println(getMethodName);
Class parameters[] = new Class[1];
parameters[0] = this.m_fieldType;
return m_class.getDeclaredMethod(getMethodName,parameters);
}
private Class getFieldType(String fieldName)
throws NoSuchFieldException
{
Field field = m_class.getDeclaredField(fieldName);
Class fieldClass = field.getType();
return fieldClass;
}
private String getTypeName(String fieldName)
{
return this.m_fieldType.getName();
}
public void setValueUsingString(Object o, String fieldValue)
throws InvocationTargetException, IllegalAccessException
{
Object parameter = ReflectionUtils.getStringAsObject(m_fieldType.getName(),fieldValue);
Object paramArray[] = new Object[1];
paramArray[0] = parameter;
Object reply = m_setAccessor.invoke(o,paramArray);
}
}
BeanInfo
public class BeanInfo
{
private Class m_class;
private List m_fieldList = new ArrayList();
private List m_FieldInfoList = new ArrayList();
private Map m_FieldInfoMap = new HashMap();
private static boolean xmlMapInitialized = false;
private static Map m_xmlNameMap = new HashMap();
private String xmlNodeName = null;
/**
* @return Returns the xmlNodeName.
*/
public String getXmlNodeName() {
return xmlNodeName;
}
/**
* @param xmlNodeName The xmlNodeName to set.
*/
public void setXmlNodeName(String xmlNodeName) {
this.xmlNodeName = xmlNodeName;
}
public BeanInfo(Object bean)
throws NoSuchMethodException, NoSuchFieldException
{
this(bean.getClass());
}
public BeanInfo(Class inClass)
throws NoSuchMethodException, NoSuchFieldException
{
m_class = inClass;
Field fieldArray[] = m_class.getDeclaredFields();
for(int i=0;i<fieldArray.length;i++)
{
Field thisField = fieldArray[i];
String fieldName = thisField.getName();
if (isStatic(thisField))
{
//static field
//Go on to the next field
continue;
}
registerField(fieldName);
}
xmlNodeName = m_class.getName();
}
public Iterator getFieldNames()
{
return m_fieldList.iterator();
}
public Iterator getFieldInfos()
{
return m_FieldInfoList.iterator();
}
private void registerField(String fieldName)
throws NoSuchMethodException, NoSuchFieldException
{
m_fieldList.add(fieldName);
FieldInfo fi = new FieldInfo(m_class,fieldName);
this.m_FieldInfoMap.put(fieldName, fi);
m_FieldInfoList.add(fi);
}
public String getValueAsString(String fieldName, Object o)
throws InvocationTargetException, IllegalAccessException
{
FieldInfo fi = (FieldInfo)m_FieldInfoMap.get(fieldName);
return fi.getValueAsString(o);
}
public void registerMapping(String fieldName, String xmlName)
{
registerMapping(fieldName, xmlName, false);
}
public void registerMapping(String fieldName, String xmlName,
boolean isAttribute)
{
FieldInfo fi = (FieldInfo)m_FieldInfoMap.get(fieldName);
if (fi == null)
{
throw new RuntimeException(
"No field information found for field:" + fieldName);
}
fi.m_xmlName=xmlName;
fi.m_attribute = isAttribute;
}
public void unRegisterMapping(String fieldName)
{
FieldInfo fi = (FieldInfo)m_FieldInfoMap.get(fieldName);
if (fi == null)
{
throw new RuntimeException(
"No field information found for field:" + fieldName);
}
m_FieldInfoMap.remove(fi);
}
public FieldInfo getFieldInfo(String xmlName)
{
initializeXmlMap();
FieldInfo fi = (FieldInfo)m_xmlNameMap.get(xmlName);
return fi;
}
private void initializeXmlMap()
{
if (xmlMapInitialized == true) return;
Iterator fieldInfos = getFieldInfos();
while(fieldInfos.hasNext())
{
FieldInfo fi = (FieldInfo)fieldInfos.next();
String xmlName = fi.m_xmlName;
m_xmlNameMap.put(xmlName,fi);
}
}
public String convertToString(Object o)
{
//Make sure the types are right
String myClassName = m_class.getName();
String inClassName = o.getClass().getName();
if (!(myClassName.equals(inClassName)))
{
throw new RuntimeException(
"Unexpected classname. Expecting "
+ myClassName
+ " but got "
+ inClassName);
}
//Get a buffer
StringBuffer sbuf = new StringBuffer();
//Print the header
//good to go
//Get all public fields
Iterator fieldInfos = this.getFieldInfos();
while(fieldInfos.hasNext())
{
FieldInfo fi = (FieldInfo)fieldInfos.next();
String fieldName = fi.m_name;
String fieldXmlName = fi.m_xmlName;
String value = "";
try
{
value = fi.getValueAsString(o);
}
catch(Exception x)
{
x.printStackTrace();
value="Exception. The message is:" + x.getMessage();
}
sbuf.append("\n" + fieldName + "='" + value + "'");
}
return sbuf.toString();
}
public void optimize()
{
initializeXmlMap();
}
private boolean isStatic(Field field)
{
int modifier = field.getModifiers();
return Modifier.isStatic(modifier);
}
}//eof-class
ReflectionUtils
public class ReflectionUtils
{
//This can be further optimized using functors
//For now this will do
public static Object getStringAsObject(String typeName, String value)
{
if (typeName.equals("java.lang.String"))
{
return value;
}
if (typeName.equals("int"))
{
return getStringAsInteger(value);
}
if (typeName.equals("java.util.Calendar"))
{
return getStringAsCalendar(value);
}
if (typeName.equals("long"))
{
return getStringAsLong(value);
}
if (typeName.equals("double"))
{
return getStringAsDouble(value);
}
if (typeName.equals("float"))
{
return getStringAsFloat(value);
}
throw new RuntimeException("Unrecognized type encountered:"
+ typeName);
}
public static Integer getStringAsInteger(String value)
{
return new Integer(Integer.parseInt(value));
}
public static Long getStringAsLong(String value)
{
return new Long(Long.parseLong(value));
}
public static Double getStringAsDouble(String value)
{
return new Double(Double.parseDouble(value));
}
public static Float getStringAsFloat(String value)
{
return new Float(Float.parseFloat(value));
}
public static Calendar getStringAsCalendar(String value)
{
try
{
Calendar cal = Calendar.getInstance();
cal.setTime(ReflectionUtils.someDateTimeFormatter.parse(value));
return cal;
}
catch(ParseException x)
{
RuntimeException rt =
new RuntimeException("Could not parse a timestamp:" + value, x);
throw rt;
}
}
public static String getValueAsString(Object o)
{
if (o instanceof Calendar)
{
//do this
Calendar cal = (Calendar)o;
//format the date and return
}
return o.toString();
}
}//eof-class
