java通过反射获取类名、属性名称
getMethods()：获取当前类及所有继承的、父类的public修饰的方法，仅包括public。
getDeclaredMethods()：获取当前类的所有方法，包括public/private/protected/default修饰的方法。
getFields()：获得某个类的所有的公共（public）的字段，包括父类中的字段。
getDeclaredFields()：获得某个类的所有声明的字段，即包括public、private和proteced，但是不包括父类的申明字段。
getAnnotation()方法可用于获取指定类型的注释，若不存在则返回null。
Field[] fields = tClass.getDeclaredFields();
List headers = new ArrayList<>();
for (Field field: fields) {
ExcelProperty property = field.getAnnotation(ExcelProperty.class);
if (property != null) {
String[] s = property.value();
if (s.length > 0) {
headers.add(s[0]);
}
}
}
String[] strings = new String[headers.size()];
headers.toArray(strings);
return strings;
} 定义反射工具类
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* 方法类
*/
public class ReflectionUtils {
/**
* 循环向上转型
* @param object 子类对象
* @param methodName 父类中的方法名
* @param parameterTypes 父类中的方法参数类型
* @return 父类中的方法对象
*/
public static Method getDeclaredMethod(Object object, String methodName, Class... parameterTypes){
Method method = null;
for(Class clazz = object.getClass(); clazz != Object.class; clazz = clazz.getSuperclass()){
try {
method = clazz.getDeclaredMethod(methodName, parameterTypes);
return method;
} catch (NoSuchMethodException e) {
//不需要处理
//不断向父类查询是否有某个方法
}
}
return null;
}
/**
* 直接调用对象方法，而忽略修饰符(private, protected, default)
* @param object 子类对象
* @param methodName 父类的方法名
* @param parameterTypes 父类的方法参数类型
* @param parameters 父类的方法参数
* @return 父类中方法的执行结果
*/
public static Object invokeMethod(Object object, String methodName, Class[] parameterTypes,
Object[] parameters){
//根据对象、方法名和对应的方法参数，通过取Method对象
Method method = getDeclaredMethod(object, methodName, parameterTypes);
//控制Java对方法进行检查，主要针对私有方法而言
method.setAccessible(true);
try {
if(null != method) {
//调用object的method所代表的方法，其方法的参数是parameters
return method.invoke(object, parameters);
}
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return null;
}
/**
* 循环向上转型, 获
* @param object : 子类对象
* @param fieldName : 父类中
* @return 父类中
* */
public static Field getDeclaredField(Object object, String fieldName){
Field field = null;
Class clazz = object.getClass();
for(;clazz != Object.class; clazz = clazz.getSuperclass()){
try {
field = clazz.getDeclaredField(fieldName);
return field;
} catch (NoSuchFieldException e) {
//不需要处理
//不断向父类查询是否有某个字段
}
}
return null;
}
/**
* 直接设置对象的属性值，忽略private/protected修饰符
* @param object 子类对象
* @param fieldName 父类中的字段名
* @param value 将要设置的值
*/
public static void setFieldValue(Object object, String fieldName, Object value){
//根据对象和属性名通过取Field对象
Field field = getDeclaredField(object, fieldName);
//控制Java对其的检查
field.setAccessible(true);
//将object中field所代表的的值设置为value
try {
field.set(object, value);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
/**
* 直接读的属性值, 忽略 private/protected 修饰符, 也
* @param object : 子类对象
* @param fieldName : 父类中
* @return : 父类中 */
public static Object getFieldValue(Object object, String fieldName){
//根据对象和属性名通过取Field对象
Field field = getDeclaredField(object, fieldName);
field.setAccessible(true);
try {
return field.get(object);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return null;
}
}定义父类的属性和方法
//父类
public class Parent {
public String publicField = "1";
String defaultField = "2";
protected String protectedField = "3";
private String privateField = "4";
public void publicMethod(String name) {
System.out.println("publicMethod...");
}
void defaultMethod() {
System.out.println("defaultMethod...");
}
protected void protectedMethod() {
System.out.println("protectedMethod...");
}
private void privateMethod() {
System.out.println("privateMethod...");
}
}
//子类
public class Son extends Parent{
}测试反射
import org.junit.Test;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectionUtilsTest {
/**
* 测试获取父类的方法实例
*/
@Test
public void testGetDeclaredMethod(){
Object obj = new Son();
//public方法
Method publicMethod = ReflectionUtils.getDeclaredMethod(obj, "publicMethod", String.class);
System.out.println(publicMethod.getName());
//default方法
Method defaultMethod = ReflectionUtils.getDeclaredMethod(obj, "defaultMethod") ;
System.out.println(defaultMethod.getName());
//protected方法
Method protectedMethod = ReflectionUtils.getDeclaredMethod(obj, "protectedMethod") ;
System.out.println(protectedMethod.getName());
//私有方法
Method privateMethod = ReflectionUtils.getDeclaredMethod(obj, "privateMethod") ;
System.out.println(privateMethod.getName());
}
/**
* 调用父类的方法
*/
@Test
public void testInvokeMethod(){
Object obj = new Son();
//调用
ReflectionUtils.invokeMethod(obj, "publicMethod", String.class, "2342");
//调用
ReflectionUtils.invokeMethod(obj, "defaultMethod", null , null) ;
//调用
ReflectionUtils.invokeMethod(obj, "protectedMethod", null , null) ;
//调用
ReflectionUtils.invokeMethod(obj, "privateMethod", null , null) ;
}
/**
* 测试获父类的各个属性名
*/
@Test
public void testGetDeclaredField() {
Object obj = new Son() ;
//获DeclaredField
Field publicField = ReflectionUtils.getDeclaredField(obj, "publicField") ;
System.out.println(publicField.getName());
//获DeclaredField
Field defaultField = ReflectionUtils.getDeclaredField(obj, "defaultField") ;
System.out.println(defaultField.getName());
//获DeclaredField
Field protectedField = ReflectionUtils.getDeclaredField(obj, "protectedField") ;
System.out.println(protectedField.getName());
//获DeclaredField
Field privateField = ReflectionUtils.getDeclaredField(obj, "privateField") ;
System.out.println(privateField.getName());
}
//设置属性值
@Test
public void testSetFieldValue() {
Object obj = new Son() ;
System.out.println("原来的各个属性的值: ");
System.out.println("publicField = " + ReflectionUtils.getFieldValue(obj, "publicField"));
System.out.println("defaultField = " + ReflectionUtils.getFieldValue(obj, "defaultField"));
System.out.println("protectedField = " + ReflectionUtils.getFieldValue(obj, "protectedField"));
System.out.println("privateField = " + ReflectionUtils.getFieldValue(obj, "privateField"));
ReflectionUtils.setFieldValue(obj, "publicField", "a") ;
ReflectionUtils.setFieldValue(obj, "defaultField", "b") ;
ReflectionUtils.setFieldValue(obj, "protectedField", "c") ;
ReflectionUtils.setFieldValue(obj, "privateField", "d") ;
System.out.println("***********************************************************");
System.out.println("将属性值改变后的各个属性值: ");
System.out.println("publicField = " + ReflectionUtils.getFieldValue(obj, "publicField"));
System.out.println("defaultField = " + ReflectionUtils.getFieldValue(obj, "defaultField"));
System.out.println("protectedField = " + ReflectionUtils.getFieldValue(obj, "protectedField"));
System.out.println("privateField = " + ReflectionUtils.getFieldValue(obj, "privateField"));
}
/**
* 获取属性值
*/
@Test
public void testGetFieldValue() {
Object obj = new Son() ;
System.out.println("publicField = " + ReflectionUtils.getFieldValue(obj, "publicField"));
System.out.println("defaultField = " + ReflectionUtils.getFieldValue(obj, "defaultField"));
System.out.println("protectedField = " + ReflectionUtils.getFieldValue(obj, "protectedField"));
System.out.println("privateField = " + ReflectionUtils.getFieldValue(obj, "privateField"));
}
}spring提供的ReflectionUtils
spring提供的ReflectionUtils可以简化项目中反射代码的复杂性。源码位置：org.springframework.util.ReflectionUtils
在项目中如果使用最原始的方法来开发反射的功能的话肯能会比较复杂，需要处理一大堆异常以及访问权限等问题
获取方法
Method method = ReflectUtil.getMethod(obj.getClass(), methodName);obj 是bean对象，getMethod方法有多个重载，可以声明参数
执行方法
ReflectionUtils.invokeMethod(method, obj, args);method方法实体，obj bean实体，args参数
mybatisplus提供的ReflectionKit
plus提供的ReflectionUtils可以简化项目中反射代码的复杂性。源码位置：com.baomidou.mybatisplus.toolkit.ReflectionKit
C c = new C();
c.setSex("女");
c.setName("妹纸");
c.setAge(18);
Assertions.assertEquals(c.getSex(), ReflectionKit.getMethodValue(c.getClass(), c, "sex"));
Assertions.assertEquals(c.getAge(), ReflectionKit.getMethodValue(c, "age"));
Map map = ReflectionKit.getFieldMap(c.class)
for (String key: map.keySet()) {
ReflectionKit.getMethodValue(c, key);
}