所用到的类
- java.lang.Class
- java.lang.reflect.Constructor
- java.lang.reflect.Field
- java.lang.reflect.Method
- java.lang.reflect.Modifier
作用：
- 当一个类被加载以后，Java虚拟机就会自动产生一个Class对象。通过这个Class对象我们就能获得加载到虚拟机当中这个Class对象对应的方法、成员以及构造方法的声明和定义等信息。
Class相关
三种获取Class对象的方法
可以根据类的状态使用不同的方法
public class MyClass {
}
方式一：
Class<?> clazz = MyClass.class;
方式二：
Class<?> clazz = null;
try {
clazz = Class.forName("com.xx.cn.MyClass");//当类没有加载到内存可使用这种方式
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
方式三：
MyClass myClass = new MyClass();
Class<?> clazz = myClass.getClass();
获取父类
public Class<? super T> getSuperclass();
获取内部类
/**
* 获取类中本身定义的公共、私有、保护的内部类
*/
public Class<?>[] getDeclaredClasses();
/**
* 获取类本身和其父类定义的公共、私有、保护的内部类
*/
public Class<?>[] getClasses();
获取定义它的外部类
/**
* 获取定义它的外部类，如果为匿名内部类则返回null
*/
public Class<?> getDeclaringClass();
/**
* 获取定义它的外部类，匿名内部类同样有效
*/
public Class<?> getEnclosingClass();
Field相关
通过Class获取Field
/**
* 获取类本身的所有字段，包括公有、保护、私有
*/
public native Field[] getDeclaredFields();
/**
* 获取类本身和其所有父类的公有和保护字段
*/
public Field[] getFields();
/**
* 获取类本身的指定字段，包括公有、保护、私有
* @param name 字段名
*/
public native Field getDeclaredField(String name) throws NoSuchFieldException;
/**
* 获取类本身和其所有父类指定的公有和保护字段
* @param name 字段名
*/
public Field getField(String name) throws NoSuchFieldException;
Field的相关属性
/**
* 获取字段的作用域：public、protected、private、abstract、static、final ...
*/
Modifier.toString(field.getModifiers());
/**
* 获取字段的类型，配合getSimpleName()使用：int、long、String ...
*/
field.getType().getSimpleName();
/**
* 获取字段名称
*/
field.getName();
对Field设置值
public native Object get(Object object) throws IllegalAccessException, IllegalArgumentException;
public native boolean getBoolean(Object object) throws IllegalAccessException, IllegalArgumentException;
public native byte getByte(Object object) throws IllegalAccessException, IllegalArgumentException;
public native char getChar(Object object) throws IllegalAccessException, IllegalArgumentException;
public native double getDouble(Object object) throws IllegalAccessException, IllegalArgumentException;
public native float getFloat(Object object) throws IllegalAccessException, IllegalArgumentException;
public native int getInt(Object object) throws IllegalAccessException, IllegalArgumentException;
public native long getLong(Object object) throws IllegalAccessException, IllegalArgumentException;
public native short getShort(Object object) throws IllegalAccessException, IllegalArgumentException;
public native void set(Object object, Object value) throws IllegalAccessException, IllegalArgumentException;
public native void setBoolean(Object object, boolean value) throws IllegalAccessException, IllegalArgumentException;
public native void setByte(Object object, byte value) throws IllegalAccessException, IllegalArgumentException;
public native void setChar(Object object, char value) throws IllegalAccessException, IllegalArgumentException;
public native void setDouble(Object object, double value) throws IllegalAccessException, IllegalArgumentException;
public native void setFloat(Object object, float value) throws IllegalAccessException, IllegalArgumentException;
public native void setInt(Object object, int value) throws IllegalAccessException, IllegalArgumentException;
public native void setLong(Object object, long value) throws IllegalAccessException, IllegalArgumentException;
public native void setShort(Object object, short value) throws IllegalAccessException, IllegalArgumentException;
- 每个方法里头都有一个Object参数，对于非静态字段来说，它必须设置为具体的实例，而对于静态字段来说它没有实际意义，可设为null；
- 对于私有(private)字段，在进行访问的时候需要先调用 field.setAccessible(true)，而公有、保护字段可直接进行访问；
其实联系下我们平时对访问权限的控制还是很好理解的，静态变量和具体实例无关，私有变量外部不能访问。
使用方式：
MyClass myClass = new MyClass();
Class<?> cls = myClass.getClass();
// 获取私有域
Field field = cls.getDeclaredField("myPrivateInt");
// 如果为静态变量可按以下调用
field.setAccessible(true);
field.getInt(null);
field.setInt(null, 33);
// 如果为非静态变量则必须按以下调用
field.setAccessible(true);
field.getInt(myClass);
field.setInt(myClass, 33);
Method相关
通过Class获取Method
/**
* 获取类本身的所有方法，包括公有、保护、私有
*/
public Method[] getDeclaredMethods();
/**
* 获取类本身和其所有父类的公有和保护方法
*/
public Method[] getMethods();
/**
* 获取类本身的指定方法，包括公有、保护、私有
* @param name 方法名
* @param parameterTypes 参数类型
*/
public Method getDeclaredMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException;
/**
* 获取类本身和其所有父类指定的公有和保护方法
* @param name 方法名
* @param parameterTypes 参数类型
*/
public Method getMethod(String name, Class<?>... parameterTypes) throws NoSuchMethodException;
通过Class获取构造方法
/**
* 获取类本身的所有构造方法，包括公有、保护、私有
*/
public Constructor<?>[] getDeclaredConstructors();
/**
* 获取类本身非私有构造方法
*/
public Constructor<?>[] getConstructors();
/**
* 获取类本身指定的构造方法
* @param parameterTypes 参数类型
*/
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) throws NoSuchMethodException;
/**
* 获取类本身指定的非私有构造方法
* @param parameterTypes 参数类型
*/
public Constructor<T> getConstructor(Class<?>... parameterTypes) throws NoSuchMethodException;
Method的常用属性，构造方法没有返回值属性
/**
* 获取方法的作用域：public、protected、private、abstract、static、final ...
*/
Modifier.toString(method.getModifiers());
/**
* 获取方法的返回值类型，配合getSimpleName()使用：int、long、String ...
*/
method.getReturnType().getSimpleName();
/**
* 获取方法名称
*/
method.getName();
/**
* 获取方法参数
*/
Class<?>[] parameterTypes = method.getParameterTypes();
/**
* 获取方法声明所在类
*/
method.getDeclaringClass();
执行方法
/**
* 执行方法
*/
public native Object invoke(Object receiver, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException;
/**
* 执行构造方法
*/
public native T newInstance(Object... args) throws InstantiationException,IllegalAccessException, IllegalArgumentException, InvocationTargetException;
static内部类和非static内部类区别
public class ExampleUnitTest {
@Test
public void testDumpClassInfo() throws Exception {
/**
* ------ Constructor ------>
private com.example.administrator.mydemo.utils.Outer$Inner(com.example.administrator.mydemo.utils.Outer)
private com.example.administrator.mydemo.utils.Outer$Inner(com.example.administrator.mydemo.utils.Outer,java.lang.String)
------ Field ------>
private java.lang.String com.example.administrator.mydemo.utils.Outer$Inner.innerField
final com.example.administrator.mydemo.utils.Outer com.example.administrator.mydemo.utils.Outer$Inner.this$0
------ Method ------>
private void com.example.administrator.mydemo.utils.Outer$Inner.innerMethod()
*/
String Inner_classInfo = dumpClass("com.example.administrator.mydemo.utils.Outer$Inner");
System.out.print(Inner_classInfo);
/**
* ------ Constructor ------>
private com.example.administrator.mydemo.utils.Outer$StaticInner()
private com.example.administrator.mydemo.utils.Outer$StaticInner(java.lang.String)
------ Field ------>
private java.lang.String com.example.administrator.mydemo.utils.Outer$StaticInner.innerField
private static java.lang.String com.example.administrator.mydemo.utils.Outer$StaticInner.innerStaticField
------ Method ------>
private void com.example.administrator.mydemo.utils.Outer$StaticInner.innerMethod()
private static void com.example.administrator.mydemo.utils.Outer$StaticInner.innerStaticMethod()
*/
String StaticInner_classInfo = dumpClass("com.example.administrator.mydemo.utils.Outer$StaticInner");
System.out.print(StaticInner_classInfo);
}
/**
* 获取类的所有 构造函数，属性，方法
*
* @param className 类名
* @return
*/
public static String dumpClass(String className) {
StringBuffer sb = new StringBuffer();
Class<?> clazz;
try {
clazz = Class.forName(className);
} catch (ClassNotFoundException e) {
e.printStackTrace();
return "";
}
Constructor<?>[] cs = clazz.getDeclaredConstructors();//
sb.append("------ Constructor ------> ").append("\n");
for (Constructor<?> c : cs) {
sb.append(c.toString()).append("\n");
}
sb.append("------ Field ------>").append("\n");
Field[] fs = clazz.getDeclaredFields();
for (Field f : fs) {
sb.append(f.toString()).append("\n");
}
sb.append("------ Method ------>").append("\n");
Method[] ms = clazz.getDeclaredMethods();
for (Method m : ms) {
sb.append(m.toString()).append("\n");
}
return sb.toString();
}
}
结果
static内部类的默认构造函数：
private com.example.administrator.mydemo.utils.Outer$StaticInner()非static内部类的默认构造函数：
private com.example.administrator.mydemo.utils.Outer$Inner(com.example.administrator.mydemo.utils.Outer),多了一个参数com.example.administrator.mydemo.utils.Outer,也就是说非static内部类保持了外部类的引用。从属性，我们也会发现多了一个final属性
final com.example.administrator.mydemo.utils.Outer com.example.administrator.mydemo.utils.Outer$Inner.this$0，这正是用于存储外部类的属性值。
工具类
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/**
* 反射工具类，提供一些Java基本的反射功能
*/
public class ReflectUtils {
public static final Class<?>[] EMPTY_PARAM_TYPES = new Class<?>[0];
public static final Object[] EMPTY_PARAMS = new Object[0];
/* ************************************************** 字段相关的方法 ******************************************************* */
/**
* 从指定的类中获取指定的字段
*
* @param sourceClass 指定的类
* @param fieldName 要获取的字段的名字
* @param isFindDeclaredField 是否查找Declared字段
* @param isUpwardFind 是否向上去其父类中寻找
* @return
*/
public static Field getField(Class<?> sourceClass, String fieldName, boolean isFindDeclaredField, boolean isUpwardFind) {
Field field = null;
try {
field = isFindDeclaredField ? sourceClass.getDeclaredField(fieldName) : sourceClass.getField(fieldName);
} catch (NoSuchFieldException e1) {
if (isUpwardFind) {
Class<?> classs = sourceClass.getSuperclass();
while (field == null && classs != null) {
try {
field = isFindDeclaredField ? classs.getDeclaredField(fieldName) : classs.getField(fieldName);
} catch (NoSuchFieldException e11) {
classs = classs.getSuperclass();
}
}
}
}
return field;
}
/**
* 从指定的类中获取指定的字段，默认获取Declared类型的字段、向上查找
*
* @param sourceClass 指定的类
* @param fieldName 要获取的字段的名字
* @return
*/
public static Field getField(Class<?> sourceClass, String fieldName) {
return getField(sourceClass, fieldName, true, true);
}
/**
* 获取给定类的所有字段
*
* @param sourceClass 给定的类
* @param isGetDeclaredField 是否需要获取Declared字段
* @param isGetParentField 是否需要把其父类中的字段也取出
* @param isGetAllParentField 是否需要把所有父类中的字段全取出
* @param isDESCGet 在最终获取的列表里，父类的字段是否需要排在子类的前面。只有需要把其父类中的字段也取出时此参数才有效
* @return 给定类的所有字段
*/
public static List<Field> getFields(Class<?> sourceClass, boolean isGetDeclaredField, boolean isGetParentField, boolean isGetAllParentField, boolean isDESCGet) {
List<Field> fieldList = new ArrayList<Field>();
//如果需要从父类中获取
if (isGetParentField) {
//获取当前类的所有父类
List<Class<?>> classList = null;
if (isGetAllParentField) {
classList = getSuperClasss(sourceClass, true);
} else {
classList = new ArrayList<Class<?>>(2);
classList.add(sourceClass);
Class<?> superClass = sourceClass.getSuperclass();
if (superClass != null) {
classList.add(superClass);
}
}
//如果是降序获取
if (isDESCGet) {
for (int w = classList.size() - 1; w > -1; w--) {
for (Field field : isGetDeclaredField ? classList.get(w).getDeclaredFields() : classList.get(w).getFields()) {
fieldList.add(field);
}
}
} else {
for (int w = 0; w < classList.size(); w++) {
for (Field field : isGetDeclaredField ? classList.get(w).getDeclaredFields() : classList.get(w).getFields()) {
fieldList.add(field);
}
}
}
} else {
for (Field field : isGetDeclaredField ? sourceClass.getDeclaredFields() : sourceClass.getFields()) {
fieldList.add(field);
}
}
return fieldList;
}
/**
* 获取给定类的所有字段
*
* @param sourceClass 给定的类
* @return 给定类的所有字段
*/
public static List<Field> getFields(Class<?> sourceClass) {
return getFields(sourceClass, true, true, true, true);
}
/**
* 设置给定的对象中给定名称的字段的值
*
* @param object 给定的对象
* @param fieldName 要设置的字段的名称
* @param newValue 要设置的字段的值
* @param isFindDeclaredField 是否查找Declared字段
* @param isUpwardFind 如果在当前类中找不到的话，是否取其父类中查找
* @return 设置是否成功。false：字段不存在或新的值与字段的类型不一样，导致转型失败
*/
public static boolean setField(Object object, String fieldName, Object newValue, boolean isFindDeclaredField, boolean isUpwardFind) {
boolean result = false;
Field field = getField(object.getClass(), fieldName, isFindDeclaredField, isUpwardFind);
if (field != null) {
try {
field.setAccessible(true);
field.set(object, newValue);
result = true;
} catch (IllegalAccessException e) {
e.printStackTrace();
result = false;
}
}
return result;
}
/* ************************************************** 方法相关的方法 ******************************************************* */
/**
* 从指定的类中获取指定的方法
*
* @param sourceClass 给定的类
* @param isFindDeclaredMethod 是否查找Declared字段
* @param isUpwardFind 是否向上去其父类中寻找
* @param methodName 要获取的方法的名字
* @param methodParameterTypes 方法参数类型
* @return 给定的类中给定名称以及给定参数类型的方法
*/
public static Method getMethod(Class<?> sourceClass, boolean isFindDeclaredMethod, boolean isUpwardFind, String methodName, Class<?>... methodParameterTypes) {
Method method = null;
try {
method = isFindDeclaredMethod ? sourceClass.getDeclaredMethod(methodName, methodParameterTypes) : sourceClass.getMethod(methodName, methodParameterTypes);
} catch (NoSuchMethodException e1) {
if (isUpwardFind) {
Class<?> classs = sourceClass.getSuperclass();
while (method == null && classs != null) {
try {
method = isFindDeclaredMethod ? classs.getDeclaredMethod(methodName, methodParameterTypes) : classs.getMethod(methodName, methodParameterTypes);
} catch (NoSuchMethodException e11) {
classs = classs.getSuperclass();
}
}
}
}
return method;
}
/**
* 从指定的类中获取指定的方法，默认获取Declared类型的方法、向上查找
*
* @param sourceClass 指定的类
* @param methodName 方法名
* @param methodParameterTypes 方法参数类型
* @return
*/
public static Method getMethod(Class<?> sourceClass, String methodName, Class<?>... methodParameterTypes) {
return getMethod(sourceClass, true, true, methodName, methodParameterTypes);
}
/**
* 从指定的类中获取指定名称的不带任何参数的方法，默认获取Declared类型的方法并且向上查找
*
* @param sourceClass 指定的类
* @param methodName 方法名
* @return
*/
public static Method getMethod(Class<?> sourceClass, String methodName) {
return getMethod(sourceClass, methodName, EMPTY_PARAM_TYPES);
}
/**
* 获取给定类的所有方法
*
* @param clas 给定的类
* @param isGetDeclaredMethod 是否需要获取Declared方法
* @param isFromSuperClassGet 是否需要把其父类中的方法也取出
* @param isDESCGet 在最终获取的列表里，父类的方法是否需要排在子类的前面。只有需要把其父类中的方法也取出时此参数才有效
* @return 给定类的所有方法
*/
public static List<Method> getMethods(Class<?> clas, boolean isGetDeclaredMethod, boolean isFromSuperClassGet, boolean isDESCGet) {
List<Method> methodList = new ArrayList<Method>();
//如果需要从父类中获取
if (isFromSuperClassGet) {
//获取当前类的所有父类
List<Class<?>> classList = getSuperClasss(clas, true);
//如果是降序获取
if (isDESCGet) {
for (int w = classList.size() - 1; w > -1; w--) {
for (Method method : isGetDeclaredMethod ? classList.get(w).getDeclaredMethods() : classList.get(w).getMethods()) {
methodList.add(method);
}
}
} else {
for (int w = 0; w < classList.size(); w++) {
for (Method method : isGetDeclaredMethod ? classList.get(w).getDeclaredMethods() : classList.get(w).getMethods()) {
methodList.add(method);
}
}
}
} else {
for (Method method : isGetDeclaredMethod ? clas.getDeclaredMethods() : clas.getMethods()) {
methodList.add(method);
}
}
return methodList;
}
/**
* 获取给定类的所有方法
*
* @param sourceClass 给定的类
* @return 给定类的所有方法
*/
public static List<Method> getMethods(Class<?> sourceClass) {
return getMethods(sourceClass, true, true, true);
}
/**
* 获取给定的类中指定参数类型的ValuOf方法
*
* @param sourceClass 给定的类
* @param methodParameterTypes 方法参数类型
* @return 给定的类中给定名称的字段的GET方法
*/
public static Method getValueOfMethod(Class<?> sourceClass, Class<?>... methodParameterTypes) {
return getMethod(sourceClass, true, true, "valueOf", methodParameterTypes);
}
/**
* 调用不带参数的方法
*
* @param method
* @param object
* @return
* @throws Exception
*/
public static Object invokeMethod(Method method, Object object) throws
Exception {
return method.invoke(object, EMPTY_PARAMS);
}
/* ************************************************** 构造函数相关的方法 ******************************************************* */
/**
* 获取给定的类中给定参数类型的构造函数
*
* @param sourceClass 给定的类
* @param isFindDeclaredConstructor 是否查找Declared构造函数
* @param isUpwardFind 是否向上去其父类中寻找
* @param constructorParameterTypes 构造函数的参数类型
* @return 给定的类中给定参数类型的构造函数
*/
public static Constructor<?> getConstructor(Class<?> sourceClass, boolean isFindDeclaredConstructor, boolean isUpwardFind, Class<?>... constructorParameterTypes) {
Constructor<?> method = null;
try {
method = isFindDeclaredConstructor ? sourceClass.getDeclaredConstructor(constructorParameterTypes) : sourceClass.getConstructor(constructorParameterTypes);
} catch (NoSuchMethodException e1) {
if (isUpwardFind) {
Class<?> classs = sourceClass.getSuperclass();
while (method == null && classs != null) {
try {
method = isFindDeclaredConstructor ? sourceClass.getDeclaredConstructor(constructorParameterTypes) : sourceClass.getConstructor(constructorParameterTypes);
} catch (NoSuchMethodException e11) {
classs = classs.getSuperclass();
}
}
}
}
return method;
}
/**
* 获取给定的类中所有的构造函数
*
* @param sourceClass 给定的类
* @param isFindDeclaredConstructor 是否需要获取Declared构造函数
* @param isFromSuperClassGet 是否需要把其父类中的构造函数也取出
* @param isDESCGet 在最终获取的列表里，父类的构造函数是否需要排在子类的前面。只有需要把其父类中的构造函数也取出时此参数才有效
* @return 给定的类中所有的构造函数
*/
public static List<Constructor<?>> getConstructors(Class<?> sourceClass, boolean isFindDeclaredConstructor, boolean isFromSuperClassGet, boolean isDESCGet) {
List<Constructor<?>> constructorList = new ArrayList<Constructor<?>>();
//如果需要从父类中获取
if (isFromSuperClassGet) {
//获取当前类的所有父类
List<Class<?>> classList = getSuperClasss(sourceClass, true);
//如果是降序获取
if (isDESCGet) {
for (int w = classList.size() - 1; w > -1; w--) {
for (Constructor<?> constructor : isFindDeclaredConstructor ? classList.get(w).getDeclaredConstructors() : classList.get(w).getConstructors()) {
constructorList.add(constructor);
}
}
} else {
for (int w = 0; w < classList.size(); w++) {
for (Constructor<?> constructor : isFindDeclaredConstructor ? classList.get(w).getDeclaredConstructors() : classList.get(w).getConstructors()) {
constructorList.add(constructor);
}
}
}
} else {
for (Constructor<?> constructor : isFindDeclaredConstructor ? sourceClass.getDeclaredConstructors() : sourceClass.getConstructors()) {
constructorList.add(constructor);
}
}
return constructorList;
}
/* ************************************************** 父类相关的方法 ******************************************************* */
/**
* 获取给定的类所有的父类
*
* @param sourceClass 给定的类
* @param isAddCurrentClass 是否将当年类放在最终返回的父类列表的首位
* @return 给定的类所有的父类
*/
public static List<Class<?>> getSuperClasss(Class<?> sourceClass, boolean isAddCurrentClass) {
List<Class<?>> classList = new ArrayList<Class<?>>();
Class<?> classs;
if (isAddCurrentClass) {
classs = sourceClass;
} else {
classs = sourceClass.getSuperclass();
}
while (classs != null) {
classList.add(classs);
classs = classs.getSuperclass();
}
return classList;
}
/* ************************************************** 其它的辅助方法 ******************************************************* */
/**
* 获取给定的类的名字
*
* @param sourceClass 给定的类
* @return 给定的类的名字
*/
public static String getClassName(Class<?> sourceClass) {
String classPath = sourceClass.getName();
return classPath.substring(classPath.lastIndexOf('.') + 1);
}
@SuppressWarnings("unchecked")
public static <T> T getObjectByFieldName(Object object, String fieldName, Class<T> clas) {
if (object != null && !TextUtils.isEmpty(fieldName) && clas != null) {
try {
Field field = ReflectUtils.getField(object.getClass(), fieldName, true, true);
if (field != null) {
field.setAccessible(true);
return (T) field.get(object);
} else {
return null;
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
} else {
return null;
}
}
/**
* 判断给定字段是否是type类型的数组
*
* @param field
* @param type
* @return
*/
public static final boolean isArrayByType(Field field, Class<?> type) {
Class<?> fieldType = field.getType();
return fieldType.isArray() && type.isAssignableFrom(fieldType.getComponentType());
}
/**
* 判断给定字段是否是type类型的collectionType集合，例如collectionType=List.class，type=Date.class就是要判断给定字段是否是Date类型的List
*
* @param field
* @param collectionType
* @param type
* @return
*/
@SuppressWarnings("rawtypes")
public static final boolean isCollectionByType(Field field, Class<? extends Collection> collectionType, Class<?> type) {
Class<?> fieldType = field.getType();
if (collectionType.isAssignableFrom(fieldType)) {
Class<?>
first = (Class<?>) ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0];
return type.isAssignableFrom(first);
} else {
return false;
}
}
}
