org.jboss.seam.util.Reflections Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jboss-seam Show documentation
Show all versions of jboss-seam Show documentation
Seam core module for Seam framework integrated with JSF2
//$Id: Reflections.java 9572 2008-11-15 22:33:10Z [email protected] $
package org.jboss.seam.util;
import java.beans.Introspector;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
public class Reflections {
public static Object invoke(Method method, Object target, Object... args) throws Exception {
try {
return method.invoke(target, args);
} catch (IllegalArgumentException iae) {
String message = "Could not invoke method by reflection: " + toString(method);
if (args != null && args.length > 0) {
message += " with parameters: (" + Strings.toClassNameString(", ", args) + ')';
}
message += " on: " + target.getClass().getName();
throw new IllegalArgumentException(message, iae);
} catch (InvocationTargetException ite) {
if (ite.getCause() instanceof Exception) {
throw (Exception) ite.getCause();
} else {
throw ite;
}
}
}
public static Object get(Field field, Object target) throws Exception {
boolean accessible = field.isAccessible();
try {
field.setAccessible(true);
return field.get(target);
} catch (IllegalArgumentException iae) {
String message = "Could not get field value by reflection: " + toString(field) + " on: " + target.getClass().getName();
throw new IllegalArgumentException(message, iae);
} finally {
field.setAccessible(accessible);
}
}
public static void set(Field field, Object target, Object value) throws Exception {
try {
field.set(target, value);
} catch (IllegalArgumentException iae) {
// target may be null if field is static so use field.getDeclaringClass() instead
StringBuilder message = new StringBuilder();
message.append("Could not set field value by reflection: ")
.append(toString(field))
.append(" on: ")
.append(field.getDeclaringClass().getName());
if (value == null) {
message.append(" with null value");
} else {
message.append(" with value: ").append(value.getClass());
}
throw new IllegalArgumentException(message.toString(), iae);
}
}
public static Object getAndWrap(Field field, Object target) {
boolean accessible = field.isAccessible();
try {
field.setAccessible(true);
return get(field, target);
} catch (Exception e) {
if (e instanceof RuntimeException) {
throw (RuntimeException) e;
} else {
throw new IllegalArgumentException("exception setting: " + field.getName(), e);
}
} finally {
field.setAccessible(accessible);
}
}
public static void setAndWrap(Field field, Object target, Object value) {
boolean accessible = field.isAccessible();
try {
field.setAccessible(true);
set(field, target, value);
} catch (Exception e) {
if (e instanceof RuntimeException) {
throw (RuntimeException) e;
} else {
throw new IllegalArgumentException("exception setting: " + field.getName(), e);
}
} finally {
field.setAccessible(accessible);
}
}
public static Object invokeAndWrap(Method method, Object target, Object... args) {
try {
return invoke(method, target, args);
} catch (Exception e) {
if (e instanceof RuntimeException) {
throw (RuntimeException) e;
} else {
throw new RuntimeException("exception invoking: " + method.getName(), e);
}
}
}
public static String toString(Method method) {
return Strings.unqualify(method.getDeclaringClass().getName()) + '.' + method.getName() + '('
+ Strings.toString(", ", method.getParameterTypes()) + ')';
}
public static String toString(Member member) {
return Strings.unqualify(member.getDeclaringClass().getName()) + '.' + member.getName();
}
public static Class classForName(String name) throws ClassNotFoundException {
try {
return Thread.currentThread().getContextClassLoader().loadClass(name);
} catch (Exception e) {
return Class.forName(name);
}
}
/**
* Return's true if the class can be loaded using Reflections.classForName()
*/
public static boolean isClassAvailable(String name) {
try {
classForName(name);
} catch (ClassNotFoundException e) {
return false;
}
return true;
}
public static Class getCollectionElementType(Type collectionType) {
if (!(collectionType instanceof ParameterizedType)) {
throw new IllegalArgumentException("collection type not parameterized");
}
Type[] typeArguments = ((ParameterizedType) collectionType).getActualTypeArguments();
if (typeArguments.length == 0) {
throw new IllegalArgumentException("no type arguments for collection type");
}
Type typeArgument = typeArguments.length == 1 ? typeArguments[0] : typeArguments[1]; //handle Maps
if (typeArgument instanceof ParameterizedType) {
typeArgument = ((ParameterizedType) typeArgument).getRawType();
}
if (!(typeArgument instanceof Class)) {
throw new IllegalArgumentException("type argument not a class");
}
return (Class) typeArgument;
}
public static Class getMapKeyType(Type collectionType) {
if (!(collectionType instanceof ParameterizedType)) {
throw new IllegalArgumentException("collection type not parameterized");
}
Type[] typeArguments = ((ParameterizedType) collectionType).getActualTypeArguments();
if (typeArguments.length == 0) {
throw new IllegalArgumentException("no type arguments for collection type");
}
Type typeArgument = typeArguments[0];
if (!(typeArgument instanceof Class)) {
throw new IllegalArgumentException("type argument not a class");
}
return (Class) typeArgument;
}
public static Method getSetterMethod(Class clazz, String name) {
Method[] methods = clazz.getMethods();
for (Method method : methods) {
String methodName = method.getName();
if (methodName.startsWith("set") && method.getParameterTypes().length == 1) {
if (Introspector.decapitalize(methodName.substring(3)).equals(name)) {
return method;
}
}
}
throw new IllegalArgumentException("no such setter method: " + clazz.getName() + '.' + name);
}
public static Method getGetterMethod(Class clazz, String name) {
Method[] methods = clazz.getMethods();
for (Method method : methods) {
String methodName = method.getName();
if (method.getParameterTypes().length == 0) {
if (methodName.startsWith("get")) {
if (Introspector.decapitalize(methodName.substring(3)).equals(name)) {
return method;
}
} else if (methodName.startsWith("is")) {
if (Introspector.decapitalize(methodName.substring(2)).equals(name)) {
return method;
}
}
}
}
throw new IllegalArgumentException("no such getter method: " + clazz.getName() + '.' + name);
}
/**
* Get all the getter methods annotated with the given annotation. Returns an empty list if
* none are found
*/
public static List getGetterMethods(Class clazz, Class annotation) {
List methods = new ArrayList();
for (Method method : clazz.getMethods()) {
if (method.isAnnotationPresent(annotation)) {
methods.add(method);
}
}
return methods;
}
public static Field getField(Class clazz, String name) {
for (Class superClass = clazz; superClass != Object.class; superClass = superClass.getSuperclass()) {
try {
return superClass.getDeclaredField(name);
} catch (NoSuchFieldException ignored) {
//
}
}
throw new IllegalArgumentException("no such field: " + clazz.getName() + '.' + name);
}
/**
* Get all the fields which are annotated with the given annotation. Returns an empty list
* if none are found
*/
public static List getFields(Class clazz, Class annotation) {
List fields = new ArrayList();
for (Class superClass = clazz; superClass != Object.class; superClass = superClass.getSuperclass()) {
for (Field field : superClass.getDeclaredFields()) {
if (field.isAnnotationPresent(annotation)) {
fields.add(field);
}
}
}
return fields;
}
public static Method getMethod(Annotation annotation, String name) {
try {
return annotation.annotationType().getMethod(name);
} catch (NoSuchMethodException nsme) {
return null;
}
}
public static Method getMethod(Class clazz, String name) {
for (Class superClass = clazz; superClass != Object.class; superClass = superClass.getSuperclass()) {
try {
return superClass.getDeclaredMethod(name);
} catch (NoSuchMethodException ignored) {
//
}
}
throw new IllegalArgumentException("no such method: " + clazz.getName() + '.' + name);
}
/**
* Check to see if clazz is an instance of name
*/
public static boolean isInstanceOf(Class clazz, String name) {
if (name == null) {
throw new IllegalArgumentException("name cannot be null");
}
for (Class c = clazz; c != Object.class; c = c.getSuperclass()) {
if (instanceOf(c, name)) {
return true;
}
}
return false;
}
private static boolean instanceOf(Class clazz, String name) {
if (name.equals(clazz.getName())) {
return true;
} else {
boolean found = false;
Class[] interfaces = clazz.getInterfaces();
for (int i = 0; i < interfaces.length && !found; i++) {
found = instanceOf(interfaces[i], name);
}
return found;
}
}
}