Java反射技术工具类
一、概述
在上一节详细介绍了Java的反射技术。例如：如何根据字符串获取一个Class对象，如何操作Method、Constructor、Filed等等。这一节针对上一节的内容做一个工具类的封装，让反射技术用起来更方便。
二、工具里：工具类中包含了所有必须的项，非常简单也非常的实用。
package com.yw.reflectlib;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* Java反射工具类
* create by yangwei
* on 2020-02-07 17:28
*/
public class ReflectUtil {
private ReflectUtil() {
}
private static ReflectUtil instance;
public static ReflectUtil getInstance() {
synchronized (ReflectUtil.class) {
if (instance == null) {
instance = new ReflectUtil();
}
}
return instance;
}
/**
* 创建一个无参的构造函数
*
* @param className 类全名
* @return
*/
public Object createObject(String className) {
Class[] classes = new Class[]{};
Object[] objects = new Object[]{};
return createObject(className, classes, objects);
}
/**
* 创建一个无惨的构造函数
*
* @param clazz 类对象
* @return
*/
public Object createObject(Class clazz) {
Class[] classes = new Class[]{};
Object[] objects = new Object[]{};
return createObject(clazz, classes, objects);
}
/**
* 创建构造函数只有一个参数的对象
*
* @param className
* @param paramType
* @param paramValue
* @return
*/
public Object createObject(String className, Class paramType, Object paramValue) {
Class[] classes = new Class[]{paramType};
Object[] objects = new Object[]{paramValue};
return createObject(className, classes, objects);
}
/**
* 创建构造函数只有一个参数的对象
*
* @param clazz
* @param paramType
* @param paramValue
* @return
*/
public Object createObject(Class clazz, Class paramType, Object paramValue) {
Class[] classes = new Class[]{paramType};
Object[] objects = new Object[]{paramValue};
return createObject(clazz, classes, objects);
}
/**
* 创建一个多参数的对象
*
* @param className 类全名
* @param paramsTypes 构造函数参数
* @param paramsValues 默认构造函数要传的值
* @return
*/
public Object createObject(String className, Class[] paramsTypes, Object[] paramsValues) {
try {
Class clazz = Class.forName(className);
Constructor constructor = clazz.getDeclaredConstructor(paramsTypes);
constructor.setAccessible(true);
return constructor.newInstance(paramsValues);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 创建一个多参数的的对象
*
* @param clazz 类对象
* @param paramsTypes 构造函数参数集合
* @param paramsValues 构造函数参数值
* @return
*/
public Object createObject(Class clazz, Class[] paramsTypes, Object[] paramsValues) {
try {
Constructor constructor = clazz.getDeclaredConstructor(paramsTypes);
constructor.setAccessible(true);
Object object = constructor.newInstance(paramsValues);
return object;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/*以下是执行方法****/
/**
* 执行类的方法
*
* @param obj 方法所在的类对象
* @param methodName 方法名称
* @param paramsTypes 方法参数
* @param paramsValues 方法参数值
* @return
*/
public Object invokeMethod(Object obj, String methodName, Class[] paramsTypes, Object[] paramsValues) {
if (obj == null)
return null;
try {
Method method = obj.getClass().getDeclaredMethod(methodName, paramsTypes);
method.setAccessible(true);
method.invoke(obj, paramsValues);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 执行只有一个参数的方法
*
* @param obj
* @param methodName
* @param paramType
* @param paramValue
* @return
*/
public Object invokeMethod(Object obj, String methodName, Class paramType, Object paramValue) {
Class[] classes = new Class[]{paramType};
Object[] objects = new Object[]{paramValue};
return invokeMethod(obj, methodName, classes, objects);
}
/**
* 执行一个无惨的方法
*
* @param obj
* @param methodName
* @return
*/
public Object invokeMethod(Object obj, String methodName) {
Class[] classes = new Class[]{};
Object[] objects = new Object[]{};
return invokeMethod(obj, methodName, classes, objects);
}
/**
* 执行一个多参数的静态方法
*
* @param className 类全名
* @param methodName 方法名
* @param paramsTypes 方法参数
* @param paramsValues 方法参数值
* @return
*/
public Object invokeStaticMethod(String className, String methodName, Class[] paramsTypes, Object[] paramsValues) {
try {
Class clazz = Class.forName(className);
Method method = clazz.getDeclaredMethod(methodName, paramsTypes);
method.setAccessible(true);
return method.invoke(null, paramsValues);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 执行一个无惨的静态方法
*
* @param className
* @param methodName
* @return
*/
public Object invokeStaticMethod(String className, String methodName) {
Class[] classes = new Class[]{};
Object[] objects = new Object[]{};
return invokeStaticMethod(className, methodName, classes, objects);
}
/**
* 执行一个参数的静态方法
*
* @param className
* @param methodName
* @param paramType
* @param paramValue
* @return
*/
public Object invokeStaticMethod(String className, String methodName, Class paramType, Object paramValue) {
Class[] classes = new Class[]{paramType};
Object[] objects = new Object[]{paramValue};
return invokeStaticMethod(className, methodName, classes, objects);
}
/**
* 执行一个多参数的静态方法
*
* @param methodName 方法名
* @param paramsTypes 方法参数
* @param paramsValues 方法参数值
* @return
*/
public Object invokeStaticMethod(Class clazz, String methodName, Class[] paramsTypes, Object[] paramsValues) {
try {
Method method = clazz.getDeclaredMethod(methodName, paramsTypes);
method.setAccessible(true);
return method.invoke(null, paramsValues);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 执行一个无惨的静态方法
*
* @param methodName
* @return
*/
public Object invokeStaticMethod(Class clazz, String methodName) {
Class[] classes = new Class[]{};
Object[] objects = new Object[]{};
return invokeStaticMethod(clazz, methodName, classes, objects);
}
/**
* 执行一个参数的静态方法
*
* @param methodName
* @param paramType
* @param paramValue
* @return
*/
public Object invokeStaticMethod(Class clazz, String methodName, Class paramType, Object paramValue) {
Class[] classes = new Class[]{paramType};
Object[] objects = new Object[]{paramValue};
return invokeStaticMethod(clazz, methodName, classes, objects);
}
/**
* 获取Field的值
*
* @param clazz 类的class
* @param obj 类的实例对象
* @param fieldName 属性名称
* @return
*/
public Object getField(Class clazz, Object obj, String fieldName) {
try {
Field field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
return field.get(obj);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 获取属性值
*
* @param obj
* @param fieldName
* @return
*/
public Object getField(Object obj, String fieldName) {
return getField(obj.getClass(), fieldName);
}
public Object getField(String className, Object obj, String fieldName) {
try {
Class clazz = Class.forName(className);
return getField(clazz, obj, fieldName);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 设置属性的值
*
* @param clazz 类对象
* @param obj 类实例对象
* @param fieldName 属性名称
* @param fieldValue 属性值
* @return
*/
public void setField(Class clazz, Object obj, String fieldName, Object fieldValue) {
try {
Field field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, fieldValue);
} catch (Exception e) {
e.printStackTrace();
}
}
public void setField(String className, Object obj, String fieldName, Object fieldValue) {
try {
Class clazz = Class.forName(className);
Field field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, fieldValue);
} catch (Exception e) {
e.printStackTrace();
}
}
public void setField(Object obj, String fieldName, Object fieldValue) {
setField(obj.getClass(), fieldName, fieldValue);
}
/**
* 获取静态属性
*
* @param className
* @param filedName
* @return
*/
public Object getStaticField(String className, String filedName) {
return getField(className, null, filedName);
}
/**
* 设置静态属性
*
* @param clazz
* @param filedName
* @return
*/
public Object getStaticField(Class clazz, String filedName) {
return getField(clazz, null, filedName);
}
/**
* 设置静态属性
*
* @param classname
* @param filedName
* @param filedVaule
*/
public void setStaticField(String classname, String filedName, Object filedVaule) {
setField(classname, null, filedName, filedVaule);
}
/**
* 获取静态属性
*
* @param clazz
* @param filedName
* @param filedVaule
*/
public void setStaticField(Class clazz, String filedName, Object filedVaule) {
setField(clazz, null, filedName, filedVaule);
}
}
总结：大家看过工具类后会发现，反射经过封装后操作起来还是很简单的，只需要调用单例类，然后写入指定的参数就能得到想要的内容。
下一节将介绍如何对泛型进行反射，敬请期待。
