Java tutorial
/* Copyright (C) 2016 maik.jablonski@jease.org This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ package jfix.util; import java.io.File; import java.lang.reflect.Array; import java.lang.reflect.Field; import java.net.URISyntaxException; import java.util.ArrayList; import java.util.Collection; import java.util.Comparator; import java.util.HashSet; import java.util.List; import java.util.Set; import org.apache.commons.lang3.ArrayUtils; /** * Common utility-methods to handle reflection. */ public class Reflections { /** * Returns all fields of the referring class which might hold references to * given reference object. The reference object is used as "template object" * (and not as class) to make use of the * java.lang.reflect.Type.isInstance()-method. */ public static Set<Field> getReferringFields(Class<?> referringClazz, Object reference) { Set<Field> referringFields = new HashSet<Field>(); for (Field possibleReferringField : getFields(referringClazz)) { if (isAssignable(reference.getClass(), possibleReferringField)) { referringFields.add(possibleReferringField); } } return referringFields; } /** * Returns true if given possible referrer is referencing given reference * object in one or more of the given referring fields. */ public static boolean isReferrer(Object possibleReferrer, Set<Field> referringFields, Object reference) { try { for (Field field : referringFields) { Object fieldValue = field.get(possibleReferrer); if (fieldValue != null && (fieldValue == reference || (field.getType().isArray() && ArrayUtils.contains((Object[]) fieldValue, reference)))) { return true; } } return false; } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } /** * Returns all interfaces and superclasses implemented by a given class. */ public static Set<Class<?>> getSuperClassesAndInterfaces(Class<?> clazz) { Set<Class<?>> result = new HashSet<>(); if (clazz != null) { result.add(clazz); for (Class<?> interfaceClass : clazz.getInterfaces()) { result.addAll(getSuperClassesAndInterfaces(interfaceClass)); } result.addAll(getSuperClassesAndInterfaces(clazz.getSuperclass())); } return result; } /** * Returns all fields of a given class (including fields from superclasses). */ public static Set<Field> getFields(Class<?> clazz) { Set<Field> result = new HashSet<>(); for (Class<?> superClass : getSuperClassesAndInterfaces(clazz)) { for (Field field : superClass.getDeclaredFields()) { field.setAccessible(true); result.add(field); } } return result; } /** * Retrieves all objects of given class-type which are referred by all the * objects in given collection. */ public static Set<Object> getReferredObjects(Collection<?> objects, Class<?> objectClass) { try { Set<Object> result = new HashSet<>(); for (Object object : objects) { for (Field field : Reflections.getFields(object.getClass())) { if (isAssignable(objectClass, field)) { Object fieldValue = field.get(object); if (fieldValue != null) { if (field.getType().isArray()) { for (Object arrayElement : (Object[]) fieldValue) { result.add(arrayElement); } } else { result.add(fieldValue); } } } } } return result; } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } /** * Returns all instanceable (sub-)classes of given type in given package. */ public static <E> E[] find(Class<E> classType, Package pckage) { File directory; try { String name = "/" + pckage.getName().replace('.', '/'); directory = new File(classType.getResource(name).toURI()); } catch (URISyntaxException e) { throw new RuntimeException(e.getMessage(), e); } List<E> result = new ArrayList<>(); if (directory.exists()) { String[] files = directory.list(); for (int i = 0; i < files.length; i++) { if (files[i].endsWith(".class")) { String classname = files[i].substring(0, files[i].length() - 6); try { Object o = Class.forName(pckage.getName() + "." + classname).newInstance(); if (classType.isInstance(o)) { result.add((E) o); } } catch (ClassNotFoundException cnfex) { System.err.println(cnfex); } catch (InstantiationException iex) { } catch (IllegalAccessException iaex) { } } } } result.sort(new Comparator<Object>() { public int compare(Object o1, Object o2) { return o1.getClass().getSimpleName().compareTo(o2.getClass().getSimpleName()); } }); return result.toArray((E[]) Array.newInstance(classType, result.size())); } /** * Returns all instanceable (sub-)classes of given type contained in the * package of given type. */ public static <E> E[] find(Class<E> classType) { return find(classType, classType.getPackage()); } /** * Returns a new instance for given clazz. */ public static Object newInstance(Class<?> clazz) { try { return clazz.newInstance(); } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } } /** * Returns a new instance for given fully qualified classname. */ public static Object newInstance(String classname) { try { return Class.forName(classname).newInstance(); } catch (ReflectiveOperationException e) { throw new RuntimeException(e.getMessage(), e); } } /** * Returns true if given class can be assigned to given field (which might * be a simple field or array). */ public static boolean isAssignable(Class<?> clazz, Field field) { return clazz.isAssignableFrom(field.getType()) || (field.getType().isArray() && clazz.isAssignableFrom(field.getType().getComponentType())); } /** * Initializes all declared static string fields in given class with name of * fields. */ public static void init(Class<?> clazz) { for (Field field : clazz.getDeclaredFields()) { field.setAccessible(true); try { field.set(null, field.getName()); } catch (Exception e) { } } } }