/**
* This software is provided as IS by Antilia-Soft SL.
* Copyright 2006-2007.
*/
//package com.antilia.common.util;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
public class ReflectionUtils {
public static final String NESTED_PROPERTY_SEPARATOR = ".";
public static Field getPropertyField(Class<?> beanClass,String property) throws NoSuchFieldException {
if (beanClass == null)
throw new IllegalArgumentException("beanClass cannot be null");
Field field = null;
try {
field = beanClass.getDeclaredField(property);
} catch (NoSuchFieldException e) {
if (beanClass.getSuperclass() == null)
throw e;
// look for the field in the superClass
field = getPropertyField(beanClass.getSuperclass(),property);
}
return field;
}
public static Field getField(Class<?> beanClass,String propertyPath) throws NoSuchFieldException {
if (beanClass == null)
throw new IllegalArgumentException("beanClass cannot be null");
if (propertyPath.indexOf("[") != -1)
propertyPath = propertyPath.substring(0,propertyPath.indexOf("["));
// if the property path is simple then look for it directly on the class.
if (propertyPath.indexOf(NESTED_PROPERTY_SEPARATOR) == -1) {
// look if the field is declared in this class.
return getPropertyField(beanClass,propertyPath);
} else {
// if the property is a compound one then split it and look for the first field.
// and recursively locate fields of fields.
String propertyName = propertyPath.substring(0,propertyPath.indexOf(NESTED_PROPERTY_SEPARATOR));
Field field = getField(beanClass,propertyName);
// try to locate sub-properties
return getField(getTargetType(field),propertyPath.substring(propertyPath.indexOf(NESTED_PROPERTY_SEPARATOR)+1));
}
}
public static Class<?> getTargetType(Field field) {
// Generic type, case when we have a Collection of ?
if (field.getGenericType() instanceof ParameterizedType) {
ParameterizedType type = (ParameterizedType)field.getGenericType();
if (type.getActualTypeArguments().length == 1 && type.getActualTypeArguments()[0] instanceof Class)
return (Class<?>)type.getActualTypeArguments()[0];
}
return field.getType();
}
public static Class<?> getPropertyClass(Class<?> beanClass,String propertyPath) {
try {
Field field = getField(beanClass, propertyPath);
return(getTargetType(field));
} catch (NoSuchFieldException e) {
throw new IllegalArgumentException(propertyPath+" is not a property of "+beanClass.getName());
}
}
public static boolean isFieldDeclared(Class<?> beanClass,String propertyPath) {
try {
return getField(beanClass, propertyPath) != null;
} catch(NoSuchFieldException e) {
return false;
}
}
public static Object getPropertyValue(Object bean,String propertyPath) throws NoSuchFieldException {
if (bean == null)
throw new IllegalArgumentException("bean cannot be null");
Field field = ReflectionUtils.getField(bean.getClass(), propertyPath);
field.setAccessible(true);
try {
return(field.get(bean));
} catch (IllegalAccessException e) {
return(null);
}
}
}
|
