Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
package org.infinispan.commons.util;
import static org.infinispan.commons.logging.Log.CONTAINER;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.logging.Log;
import org.infinispan.commons.logging.LogFactory;
/**
* Basic reflection utilities to enhance what the JDK provides.
*
* @author Manik Surtani ([email protected])
* @since 4.0
*/
public class ReflectionUtil {
private static final Log log = LogFactory.getLog(ReflectionUtil.class);
private static final String[] EMPTY_STRING_ARRAY = {};
private static final Class[] primitives = {int.class, byte.class, short.class, long.class,
float.class, double.class, boolean.class, char.class};
private static final Class[] primitiveArrays = {int[].class, byte[].class, short[].class, long[].class,
float[].class, double[].class, boolean[].class, char[].class};
public static final Class[] EMPTY_CLASS_ARRAY = new Class[0];
/**
* Returns a set of Methods that contain the given method annotation. This includes all public, protected, package
* and private methods, as well as those of superclasses. Note that this does *not* include overridden methods.
*
* @param c class to inspect
* @param annotationType the type of annotation to look for
* @return List of Method objects that require injection.
*/
public static List getAllMethods(Class c, Class annotationType) {
List annotated = new ArrayList<>();
inspectRecursively(c, annotated, annotationType);
return annotated;
}
/**
* Returns a set of Methods that contain the given method annotation. This includes all public, protected, package
* and private methods, but not those of superclasses and interfaces.
*
* @param c class to inspect
* @param annotationType the type of annotation to look for
* @return List of Method objects that require injection.
*/
public static List getAllMethodsShallow(Class c, Class annotationType) {
List annotated = new ArrayList<>();
for (Method m : c.getDeclaredMethods()) {
if (m.isAnnotationPresent(annotationType))
annotated.add(m);
}
return annotated;
}
public static List getAllFields(Class c, Class annotationType) {
List annotated = new LinkedList<>();
inspectFieldsRecursively(c, annotated, annotationType);
return annotated;
}
private static void getAnnotatedFieldHelper(List list, Class c, Class annotationType) {
Field[] declaredFields = c.getDeclaredFields();
for (Field field : declaredFields) {
if (field.isAnnotationPresent(annotationType)) {
list.add(field);
}
}
}
public static List getAnnotatedFields(Class c, Class annotationType) {
List fields = new ArrayList<>(4);
// Class could be null in the case of an interface
for (;c != null && !c.equals(Object.class); c = c.getSuperclass()) {
getAnnotatedFieldHelper(fields, c, annotationType);
}
return fields;
}
public static Method findMethod(Class type, String methodName) {
try {
return type.getDeclaredMethod(methodName);
} catch (NoSuchMethodException e) {
if (type.equals(Object.class) || type.isInterface()) {
throw new CacheException(e);
}
return findMethod(type.getSuperclass(), methodName);
}
}
public static Method findMethod(Class type, String methodName, Class... parameters) {
try {
return type.getDeclaredMethod(methodName, parameters);
} catch (NoSuchMethodException e) {
if (type.equals(Object.class) || type.isInterface()) {
throw new CacheException(e);
}
return findMethod(type.getSuperclass(), methodName, parameters);
}
}
/**
* Inspects a class and its superclasses (all the way to {@link Object} for method instances that contain a given
* annotation. This even identifies private, package and protected methods, not just public ones.
*/
private static void inspectRecursively(Class c, List s, Class annotationType) {
for (Method m : c.getDeclaredMethods()) {
// don't bother if this method has already been overridden by a subclass
if (notFound(m, s) && m.isAnnotationPresent(annotationType)) {
s.add(m);
}
}
if (!c.equals(Object.class)) {
if (!c.isInterface()) {
inspectRecursively(c.getSuperclass(), s, annotationType);
}
for (Class ifc : c.getInterfaces()) inspectRecursively(ifc, s, annotationType);
}
}
private static void inspectFieldsRecursively(Class c, List s, Class annotationType) {
if (c == null || c.isInterface()) {
return;
}
for (Field f : c.getDeclaredFields()) {
if (f.isAnnotationPresent(annotationType)) {
s.add(f);
}
}
if (!c.equals(Object.class)) {
inspectFieldsRecursively(c.getSuperclass(), s, annotationType);
}
}
/**
* Tests whether a method has already been found, i.e., overridden.
*
* @param m method to inspect
* @param s collection of methods found
* @return true a method with the same signature already exists.
*/
private static boolean notFound(Method m, Collection s) {
for (Method found : s) {
if (m.getName().equals(found.getName()) &&
Arrays.equals(m.getParameterTypes(), found.getParameterTypes()))
return false;
}
return true;
}
private static Field findFieldRecursively(Class c, String fieldName) {
Field f = null;
try {
f = c.getDeclaredField(fieldName);
} catch (NoSuchFieldException e) {
if (!c.equals(Object.class)) f = findFieldRecursively(c.getSuperclass(), fieldName);
}
return f;
}
/**
* Invokes a method using reflection, in an accessible manner (by using {@link Method#setAccessible(boolean)}
*
* @param instance instance on which to execute the method
* @param method method to execute
* @param parameters parameters
*/
public static Object invokeAccessibly(Object instance, Method method, Object... parameters) {
method.setAccessible(true);
return invokeMethod(instance, method, parameters);
}
public static Object invokeMethod(Object instance, Method method, Object[] parameters) {
try {
return method.invoke(instance, parameters);
} catch (InvocationTargetException e) {
Throwable cause = e.getCause() != null ? e.getCause() : e;
throw new CacheException("Unable to invoke method " + method + " on object of type " + (instance == null ? "null" : instance
.getClass().getSimpleName()) +
(parameters != null ? " with parameters " + Arrays.asList(parameters) : ""), cause);
} catch (Exception e) {
throw new CacheException("Unable to invoke method " + method + " on object of type " + (instance == null ? "null" : instance
.getClass().getSimpleName()) +
(parameters != null ? " with parameters " + Arrays.asList(parameters) : ""), e);
}
}
public static void setAccessibly(Object instance, Field field, Object value) {
field.setAccessible(true);
setField(instance, field, value);
}
public static void setField(Object instance, Field field, Object value) {
try {
field.set(instance, value);
} catch (Exception e) {
throw new CacheException("Unable to set field " + field.getName() + " on object of type " +
(instance == null ? "null" : instance.getClass().getName()) + " to " + value, e);
}
}
public static Method findGetterForField(Class c, String fieldName) {
Method retval = findGetterForFieldUsingReflection(c, fieldName);
if (retval == null) {
if (!c.equals(Object.class)) {
if (!c.isInterface()) {
retval = findGetterForField(c.getSuperclass(), fieldName);
if (retval == null) {
for (Class ifc : c.getInterfaces()) {
retval = findGetterForField(ifc, fieldName);
if (retval != null) break;
}
}
}
}
}
return retval;
}
private static Method findGetterForFieldUsingReflection(Class c, String fieldName) {
for (Method m : c.getDeclaredMethods()) {
String name = m.getName();
String s = null;
if (name.startsWith("get")) {
s = name.substring(3);
} else if (name.startsWith("is")) {
s = name.substring(2);
}
if (s != null && s.equalsIgnoreCase(fieldName)) {
return m;
}
}
return null;
}
public static Method findSetterForField(Class c, String fieldName) {
if (c == Object.class) {
return null;
}
for (Method m : c.getDeclaredMethods()) {
String name = m.getName();
String s = null;
if (name.startsWith("set")) {
s = name.substring(3);
}
if (s != null && s.equalsIgnoreCase(fieldName)) {
return m;
}
}
// Try parent class until we run out
return findSetterForField(c.getSuperclass(), fieldName);
}
public static String extractFieldName(String setterOrGetter) {
String field = null;
if (setterOrGetter.startsWith("set") || setterOrGetter.startsWith("get"))
field = setterOrGetter.substring(3);
else if (setterOrGetter.startsWith("is"))
field = setterOrGetter.substring(2);
if (field != null && field.length() > 1) {
StringBuilder sb = new StringBuilder();
sb.append(Character.toLowerCase(field.charAt(0)));
if (field.length() > 2) sb.append(field.substring(1));
return sb.toString();
}
return null;
}
/**
* Retrieves the value of a field of an object instance via reflection
*
* @param instance to inspect
* @param fieldName name of field to retrieve
* @return a value
*/
public static Object getValue(Object instance, String fieldName) {
Field f = findFieldRecursively(instance.getClass(), fieldName);
if (f == null) throw new CacheException("Could not find field named '" + fieldName + "' on instance " + instance);
try {
f.setAccessible(true);
return f.get(instance);
} catch (IllegalAccessException iae) {
throw new CacheException("Cannot access field " + f, iae);
}
}
/**
* Inspects the class passed in for the class level annotation specified. If the annotation is not available, this
* method recursively inspects superclasses and interfaces until it finds the required annotation.
*
* Returns null if the annotation cannot be found.
*
* @param clazz class to inspect
* @param ann annotation to search for. Must be a class-level annotation.
* @return the annotation instance, or null
*/
public static T getAnnotation(Class clazz, Class ann) {
while (true) {
// first check class
T a = clazz.getAnnotation(ann);
if (a != null) return a;
// check interfaces
if (!clazz.isInterface()) {
Class[] interfaces = clazz.getInterfaces();
for (Class inter : interfaces) {
a = getAnnotation(inter, ann);
if (a != null) return a;
}
}
// check superclasses
Class superclass = clazz.getSuperclass();
if (superclass == null) return null; // no where else to look
clazz = superclass;
}
}
/**
* Tests whether an annotation is present on a class. The order tested is:
The class itself
All
* implemented interfaces
Any superclasses
*
* @param clazz class to test
* @param annotation annotation to look for
* @return true if the annotation is found, false otherwise
*/
public static boolean isAnnotationPresent(Class clazz, Class annotation) {
return getAnnotation(clazz, annotation) != null;
}
public static Class[] toClassArray(String[] typeList, ClassLoader classLoader) throws ClassNotFoundException {
if (typeList == null) return EMPTY_CLASS_ARRAY;
Class[] retval = new Class[typeList.length];
int i = 0;
for (String s : typeList) retval[i++] = getClassForName(s, classLoader);
return retval;
}
public static Class getClassForName(String name, ClassLoader cl) throws ClassNotFoundException {
try {
return Util.loadClassStrict(name, cl);
} catch (ClassNotFoundException cnfe) {
// Could be a primitive - let's check
for (Class primitive : primitives) if (name.equals(primitive.getName())) return primitive;
for (Class primitive : primitiveArrays) if (name.equals(primitive.getName())) return primitive;
}
throw new ClassNotFoundException("Class " + name + " cannot be found");
}
public static String[] toStringArray(Class[] classes) {
if (classes == null)
return EMPTY_STRING_ARRAY;
else {
String[] classNames = new String[classes.length];
for (int i=0; i objectClass) {
try {
return objectClass.getDeclaredField(fieldName);
} catch (NoSuchFieldException e) {
if (!objectClass.equals(Object.class)) {
return getField(fieldName, objectClass.getSuperclass());
} else {
return null;
}
}
}
public static T unwrap(Object obj, Class clazz) {
if (clazz != null && clazz.isAssignableFrom(obj.getClass()))
return clazz.cast(obj);
throw CONTAINER.unableToUnwrap(obj, clazz);
}
public static T unwrapAny(Class clazz, Object... objs) {
if (clazz != null) {
for (Object o : objs) {
if (clazz.isAssignableFrom(o.getClass()))
return clazz.cast(o);
}
}
throw CONTAINER.unableToUnwrapAny(Arrays.toString(objs), clazz);
}
public static int getIntAccessibly(Field f, Object instance) {
try {
f.setAccessible(true);
return f.getInt(instance);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
