com.rockagen.commons.util.ClassUtil Maven / Gradle / Ivy
/*
* Copyright 2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.rockagen.commons.util;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import org.apache.commons.lang3.ClassUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Class Utils
*
* @author RA
* @since JDK1.6
* @since COMMONS.LANG3
*/
public class ClassUtil extends ClassUtils {
// ~ Instance fields ==================================================
/**
*
*/
private static final Logger log = LoggerFactory.getLogger(ClassUtil.class);
// ~ Constructors ==================================================
/**
*/
private ClassUtil() {
}
// ~ Methods ==================================================
/**
* Create new instance of specified class and type
*
* @param clazz class
* @param accessible accessible
* @param parameterTypes parameter types
* @param paramValue param value
* @param t
* @return instance
*/
public static T getInstance(Class clazz, boolean accessible,
Class[] parameterTypes, Object[] paramValue) {
if (clazz == null)
return null;
T t = null;
try {
if (parameterTypes != null && paramValue != null) {
Constructor constructor = clazz
.getDeclaredConstructor(parameterTypes);
Object[] obj = new Object[parameterTypes.length];
System.arraycopy(paramValue, 0, obj, 0, parameterTypes.length);
constructor.setAccessible(accessible);
t = constructor.newInstance(obj);
}
} catch (SecurityException e) {
log.error("{}",e.getMessage(),e);
} catch (NoSuchMethodException e) {
log.error("{}",e.getMessage(),e);
} catch (IllegalArgumentException e) {
log.error("{}",e.getMessage(),e);
} catch (InstantiationException e) {
log.error("{}",e.getMessage(),e);
} catch (IllegalAccessException e) {
log.error("{}",e.getMessage(),e);
} catch (InvocationTargetException e) {
log.error("{}",e.getMessage(),e);
}
return t;
}
/**
* Create new instance of specified class and type
*
* @param clazz class
* @param accessible accessible
* @param t
* @return instance
*/
public static T getInstance(Class clazz, boolean accessible) {
if (clazz == null)
return null;
T t = null;
try {
Constructor constructor = clazz.getDeclaredConstructor();
constructor.setAccessible(accessible);
t = constructor.newInstance();
} catch (InstantiationException e) {
log.error("{}",e.getMessage(),e);
} catch (IllegalAccessException e) {
log.error("{}",e.getMessage(),e);
} catch (SecurityException e) {
log.error("{}",e.getMessage(),e);
} catch (NoSuchMethodException e) {
log.error("{}",e.getMessage(),e);
} catch (IllegalArgumentException e) {
log.error("{}",e.getMessage(),e);
} catch (InvocationTargetException e) {
log.error("{}",e.getMessage(),e);
}
return t;
}
/**
* Create new instance of specified class and type
*
* @param clazz class
* @param t
* @return instance
*/
public static T getInstance(Class clazz) {
return getInstance(clazz, false);
}
/**
* obtain fields list of specified class If recursively is true, obtain
* fields from all class hierarchy
*
* @param clazz class
* where fields are searching
* @param recursively
* param
* @return array of fields
*/
public static Field[] getDeclaredFields(Class clazz, boolean recursively) {
List fields = new LinkedList();
Field[] declaredFields = clazz.getDeclaredFields();
Collections.addAll(fields, declaredFields);
Class superClass = clazz.getSuperclass();
if (superClass != null && recursively) {
Field[] declaredFieldsOfSuper = getDeclaredFields(superClass,
true);
if (declaredFieldsOfSuper.length > 0)
Collections.addAll(fields, declaredFieldsOfSuper);
}
return fields.toArray(new Field[fields.size()]);
}
/**
* obtain field If recursively is true, obtain fields from all class
* hierarchy
*
* @param clazz class
* where fields are searching
* @param fieldName
* field name
* @param recursively
* param
* @return list of fields
*/
public static Field getDeclaredField(Class clazz, String fieldName,
boolean recursively) {
try {
return clazz.getDeclaredField(fieldName);
} catch (NoSuchFieldException e) {
Class superClass = clazz.getSuperclass();
if (superClass != null && recursively) {
return getDeclaredField(superClass, fieldName, true);
}
} catch (SecurityException e) {
log.error("{}",e.getMessage(),e);
}
return null;
}
/**
* obtain methods list of specified class If recursively is true, obtain
* methods from all class hierarchy
*
* @param clazz class
* where fields are searching
* @param recursively
* param
* @return array of methods
*/
public static Method[] getDeclaredMethods(Class clazz,
boolean recursively) {
List methods = new LinkedList();
Method[] declaredMethods = clazz.getDeclaredMethods();
Collections.addAll(methods, declaredMethods);
Class superClass = clazz.getSuperclass();
if (superClass != null && recursively) {
Method[] declaredMethodsOfSuper = getDeclaredMethods(superClass,
true);
if (declaredMethodsOfSuper.length > 0)
Collections.addAll(methods, declaredMethodsOfSuper);
}
return methods.toArray(new Method[methods.size()]);
}
/**
* obtain method list of specified class If recursively is true, obtain
* method from all class hierarchy
*
* @param clazz class
* @param recursively recursively
* @param methodName method name
* @param parameterTypes parameter types
* @return method
*/
public static Method getDeclaredMethod(Class clazz, boolean recursively,
String methodName, Class... parameterTypes) {
try {
return clazz.getDeclaredMethod(methodName,
parameterTypes);
} catch (NoSuchMethodException e) {
Class superClass = clazz.getSuperclass();
if (superClass != null && recursively) {
return getDeclaredMethod(superClass, true, methodName,
parameterTypes);
}
} catch (SecurityException e) {
log.error("{}",e.getMessage(),e);
}
return null;
}
/**
* obtain constructor list of specified class If recursively is true, obtain
* constructor from all class hierarchy
*
*
* @param clazz class
* where fields are searching
* @param recursively
* param
* @return array of constructors
*/
public static Constructor[] getDeclaredConstructors(Class clazz,
boolean recursively) {
List> constructors = new LinkedList>();
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
Collections.addAll(constructors, declaredConstructors);
Class superClass = clazz.getSuperclass();
if (superClass != null && recursively) {
Constructor[] declaredConstructorsOfSuper = getDeclaredConstructors(
superClass, true);
if (declaredConstructorsOfSuper.length > 0)
Collections.addAll(constructors, declaredConstructorsOfSuper);
}
return constructors.toArray(new Constructor[constructors.size()]);
}
/**
* obtain constructor list of specified class If recursively is true, obtain
* constructor from all class hierarchy
*
*
* @param clazz class
* where fields are searching
* @param recursively
* param
* @param parameterTypes parameter types
* @return constructor
*/
public static Constructor getDeclaredConstructor(Class clazz,
boolean recursively, Class... parameterTypes) {
try {
return clazz
.getDeclaredConstructor(parameterTypes);
} catch (NoSuchMethodException e) {
Class superClass = clazz.getSuperclass();
if (superClass != null && recursively) {
return getDeclaredConstructor(superClass, true,
parameterTypes);
}
} catch (SecurityException e) {
log.error("{}",e.getMessage(),e);
}
return null;
}
/**
* obtain fields list of specified class and which are annotated by incoming
* annotation class If recursively is true, obtain fields from all class
* hierarchy
*
* @param clazz class
* - where fields are searching
* @param annotationClass
* - specified annotation class
* @param recursively
* param
* @return list of annotated fields
*/
public static Field[] getAnnotatedDeclaredFields(Class clazz,
Class annotationClass, boolean recursively) {
Field[] allFields = getDeclaredFields(clazz, recursively);
List annotatedFields = new LinkedList();
for (Field field : allFields) {
if (field.isAnnotationPresent(annotationClass))
annotatedFields.add(field);
}
return annotatedFields.toArray(new Field[annotatedFields.size()]);
}
/**
* obtain methods list of specified class and which are annotated by
* incoming annotation class If recursively is true, obtain methods from all
* class hierarchy
*
* @param clazz class
* - where methods are searching
* @param annotationClass
* - specified annotation class
* @param recursively
* param
* @return list of annotated methods
*/
public static Method[] getAnnotatedDeclaredMethods(Class clazz,
Class annotationClass, boolean recursively) {
Method[] allMethods = getDeclaredMethods(clazz, recursively);
List annotatedMethods = new LinkedList();
for (Method method : allMethods) {
if (method.isAnnotationPresent(annotationClass))
annotatedMethods.add(method);
}
return annotatedMethods.toArray(new Method[annotatedMethods.size()]);
}
/**
* obtain constructors list of specified class and which are annotated by
* incoming annotation class If recursively is true, obtain constructors
* from all class hierarchy
*
* @param clazz class
* - where constructors are searching
* @param annotationClass
* - specified annotation class
* @param recursively
* param
* @return list of annotated constructors
*/
public static Constructor[] getAnnotatedDeclaredConstructors(
Class clazz, Class annotationClass,
boolean recursively) {
Constructor[] allConstructors = getDeclaredConstructors(clazz,
recursively);
List> annotatedConstructors = new LinkedList>();
for (Constructor field : allConstructors) {
if (field.isAnnotationPresent(annotationClass))
annotatedConstructors.add(field);
}
return annotatedConstructors
.toArray(new Constructor[annotatedConstructors.size()]);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy