该楼层疑似违规已被系统折叠 隐藏此楼查看此楼
 
Java反射机制提供了一种强大的应用程序接口来帮助我们在运行时检测和执行对象上的操作。该机制允许程序员审视一个未知对象，并且获得它的属性，例如对象上的方法，JavaBean的属性以及继承关系等。
 
Java中有两种类型的值，一种是类类型，它把对象的属性定义在一个类中。类类型是面向对象结构的基本组成部分。第二种类型的值是基本数据类型。反射类型通常用于类类型，但是，其实它也可以很方便应用到Java的基本类型上。
 
Java中的基本类型继承自基于C的语法，其中包括boolean、byte、short、int、long、float、double、char等类型。
 
每一个基本类型都与一个java类相关联。这些类封装在java.lang.package中，这个package默认导入所有的java源代码文件。
 
在java.lang包的基本数据类型包装类中,不是像定义对象那样用类(class)而是用一些特殊的常量来表示基本数据的类型(type).例如,是常量Interger.TYPE而不是类Integer表示int类型,是Byte.TYPE常量表示了byte类型.这种方式使得为一个未知的JavaBean创建通用的组件成为可能.
 
下面是一个例子片断，其作用是根据一个传来的HttpServletRequest中设置JavaBean中的值。
 
// thrown
 
Exceptions are left out for ease of reading...
 
Object bean = ....
 
BeanInfo bi = Introspector.getBeanInfo(bean.getClass( ));
 
PropertyDescriptor[ ] pds = bi.getPropertyDescriptors( );
 
for(int i=0; i String name = pds[i].getName( );
 
String value = request.getParameter(name);
 
if(value != null) {
 
Method method = pds[i].getWriteMethod(
 
);
 
value = convert(value,
 
method.getParameterType( )[0]);
 
method.invoke(bean, new Object[
 
] { value } );
 
}
 
}
 
Convert方法中缺少的代码定义如下：
 
public Object
 
convert(Object value, Class type) {
 
String name = type.getName( );
 
if( "java.lang.String.equals(name) ) {
 
return value.toString();
 
} else
 
if( "java.lang.Long".equals(name) || (type ==
 
Long.TYPE) ) {
 
return convertToLong(value);
 
} else
 
if( "java.lang.Integer".equals(name) || (type
 
== Integer.TYPE) ) {
 
return convertToInteger(value);
 
} else
 
.....
 
}

VO
 
@Data
public class Data {
    private List<AA> sysDataDictList;
    private List<BB> sysDataDictDtlList;
}
 
获取AA、BB
 
getDeclaredFields只会获取本类的字段，而getFields只会获取本类和父类中公有的字段
getFields只能获取public的字段，包括父类的，getDeclaredFields只能获取自己声明的各种字段，包括public，protected，private。
要获取父类里的方法，通过 getSuperclass 获取父类的类型，然后再从父类的类型里 getDeclaredFields
 
Field[] fields = Data.class.getDeclaredFields();
for (Field field : fields) {
   String fieldType = getFieldsType(field);
}

private String getFieldsType(Field field) {
    field.setAccessible(true);
    Class<?> curFieldType = field.getType();
    if (curFieldType.equals(List.class)) {
        Type genericType = field.getGenericType();
        if (genericType instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) genericType;
            Class<?> actualType = (Class<?>) pt.getActualTypeArguments()[0];
            return actualType.getSimpleName();
        }
    }
    return field.getName();
}
 
接口图
 
 hutool反射工具https://hutool.cn/docs/#/
 

 
一句话概括就是使用反射可以赋予jvm动态编译的能力，否则类的元数据信息只能用静态编译的方式实现，例如热加载，Tomcat的classloader等等都没法支持
 
Java中编译类型有两种：
 
静态编译：在编译时确定类型，绑定对象即通过。
 
动态编译：运行时确定类型，绑定对象。动态编译最大限度地发挥了Java的灵活性，体现了多态的应用，可以减低类之间的耦合性。
 
Java反射是Java被视为动态(或准动态)语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers(诸如public、static等)、superclass(例如Object)、实现之interfaces(例如Cloneable)，也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。
 
Reflection可以在运行时加载、探知、使用编译期间完全未知的classes。即Java程序可以加载一个运行时才得知名称的class，获取其完整构造，并生成其对象实体、或对其fields设值、或唤起其methods。
 
反射(reflection)允许静态语言在运行时(runtime)检查、修改程序的结构与行为。
 
在静态语言中，使用一个变量时，必须知道它的类型。在Java中，变量的类型信息在编译时都保存到了class文件中，这样在运行时才能保证准确无误；换句话说，程序在运行时的行为都是固定的。如果想在运行时改变，就需要反射这东西了。
 
实现Java反射机制的类都位于java.lang.reflect包中：
 
1、Class类：代表一个类
 
2、Field类：代表类的成员变量(类的属性)
 
3、Method类：代表类的方法
 
4、Constructor类：代表类的构造方法
 
5、Array类：提供了动态创建数组，以及访问数组的元素的静态方法
 
* 对于修改静态常量类型是需要小心
 
对于基本类型的静态常量，JAVA在编译的时候就会把代码中对此常量中引用的地方替换成相应常量值
 
* 参考阅读
 
http://www.imooc.com/learn/199
 
https://blog.csdn.net/u010832551/article/details/74202467
 
http://wiki.jikexueyuan.com/project/java-reflection/jave-guide.html
 
JAVA中的糕富帅技术——反射(一)
 
前言 突然发现好久没写博客了,前面写的都是关于Android的东西,今天心血来潮突然有一种冲动想写一篇基于JAVA技术的博客,别问我为什么?有钱.任性! 今天就来谈谈反射机制:学过JAVA的人不一定懂 ...
 
java中复制对象通过反射或序列化
 
在使用缓存读取数据后修改发现缓存被修改.于是找了下复制对象的方法. 关于对象克隆 按我的理解,对象是包含引用+数据.通常变量复制都是将引用传递过去.比如: Person p1 = new Person ...
 
Java中通过Class的反射来获取方法
 
本文转自:http://z3sm2012.iteye.com/blog/1933227 今天在程序中用到java反射机制时,遇到的问题记录一下:我当时遇到的问题是,我用反射getMethod()调用类 ...
 
java中的泛型与反射
 
在java开发中,大多数情况是多人开发,那么如何在没有API的情况下,快速的理解到别人开发的一些类的详细信息呢? 比如函数名,类名,返回参数等等 我们可以定义一个反射机制的类,通过此类来打印此你想要操 ...
 
Java中关于OOM的场景及解决方法

 
public class Person{
 
}importjava.lang.reflect.ParameterizedType;importjava.lang.reflect.Type;public class Student extends Person{public static voidmain(String[] args) {
 
Student st=newStudent();
 
Class clazz=st.getClass();//getSuperclass()获得该类的父类
 
System.out.println(clazz.getSuperclass());//getGenericSuperclass()获得带有泛型的父类//Type是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。
 
Type type=clazz.getGenericSuperclass();
 
System.out.println(type);//ParameterizedType参数化类型，即泛型
 
ParameterizedType p=(ParameterizedType)type;//getActualTypeArguments获取参数化类型的数组，泛型可能有多个
 
Class c=(Class) p.getActualTypeArguments()[0];
 
System.out.println(c);
 
}
 
}
 
打印结果：classcom.test.Person
 
com.test.Person
 
class com.test.Student
 
在Java反射技术的应用中，取得一个类的成员、方法和构造函数相对比较容易，但是要想取得其中包含的泛型类型则相对困难一些。先看一个简单的例子，然后详细说明每个步骤的作用。
 
public class Demo {
 
private List list1;
 
private List> listSet;
 
public Set fun1(Map map){return null;}
 
public static void getFieldGenericType() {
 
try {
 
Class clazz = Demo.class;
 
Field field = clazz.getDeclaredField("list1");
 
Type type = field.getGenericType(); //取得field的type
 
ParameterizedTypeImpl parameterizedType = (ParameterizedTypeImpl) type; //强转成具体的实现类
 
Type[] genericTypes = parameterizedType.getActualTypeArguments(); //取得包含的泛型类型
 
System.out.println(genericTypes[0]);
 
} catch (NoSuchFieldException e) {
 
e.printStackTrace();
 
}
 
}
 
public static void main(String[] args) {
 
getFieldGenericType();
 
}
 
}
 
上面的代码可以正确的打印出Demo类的成员list1的泛型类型Integer。代码中的第一步通过getGenericType()方法获得一个Type类型。这个Type其实就代表了List，Type的实现类可以是Class，也可以是ParameterizedTypeImpl。如果field的类型是泛型则通过getGenericType()取到的就是ParameterizedTypeImpl，如果是普通的类则取到的就是Class。我们在编译器取到的Class是没有泛型信息的，通过field的getType方法取到的信息只能是List，而不是List，所以我们才用上面的方法获取泛型的类型；第二步将Type强转成了ParameterizedTypeImpl类型，这里偷了个懒，因为知道真实的类型所以没有判断type的具体实现类，开发时千万不能这样写；第四步从ParameterizedTypeImpl中取得到了所有的泛型类型。ParameterizedTypeImpl也就是参数化的type，我们要获得的泛型类型相当于type的参数，有几个泛型类型，则getActualTypeArguments()会返回几个Type参数。
 
刚才说到Class是Type的子类，而通过getActualTypeArguments()获取到的又是一个Type数组，好像陷入到了无限的循环当中。没错，在真实的代码中也确实存在着泛型类型的嵌套使用，例如上面代码中的第二个域listSet。有了刚才的基础，获取多少层的嵌套泛型也可以解析出来。解析listSet中泛型信息的代码如下：
 
public static void getFieldGenericType1() {
 
try {
 
Class clazz = Demo.class;
 
Field field = clazz.getDeclaredField("listSet");
 
Type type = field.getGenericType(); //取得field的type
 
ParameterizedTypeImpl parameterizedType = (ParameterizedTypeImpl) type; //强转成具体的实现类
 
Type[] genericTypes = parameterizedType.getActualTypeArguments(); //取得包含的泛型类型
 
ParameterizedTypeImpl setType = (ParameterizedTypeImpl) genericTypes[0];//再次将代表Set的Type强转成ParameterizedTypeImpl
 
Type[] setTypeArguments = setType.getActualTypeArguments();
 
System.out.println(setTypeArguments[0]);
 
} catch (NoSuchFieldException e) {
 
e.printStackTrace();
 
}
 
}
 
同样的道理，获取方法中的泛型信息也不在话下
 
public static void getMethodGenericType() {
 
try {
 
Class clazz = Demo.class;
 
Method method = clazz.getMethod("fun1", Map.class);
 
Type type = method.getGenericReturnType();
 
ParameterizedTypeImpl parameterizedType = (ParameterizedTypeImpl) type;
 
Type[] genericTypes = parameterizedType.getActualTypeArguments();
 
System.out.println("return generic type " + genericTypes[0]);
 
Type mapType = method.getGenericParameterTypes()[0];
 
ParameterizedTypeImpl mapParamType = (ParameterizedTypeImpl) mapType;//再次将代表Set的Type强转成ParameterizedTypeImpl
 
Type[] mapArgs = mapParamType.getActualTypeArguments();
 
System.out.println("method param first generic type " + mapArgs[0]);
 
} catch (Exception e) {
 
e.printStackTrace();
 
}
 
}
 
上面展示了解析成员和方法中泛型信息的方法，但是对于一个普通的变量可以在运行期解析出他的泛型信息吗？答案是不可以的，因为对于一个普通的变量我们只能拿到的他的Class信息，而刚刚也已经说到Class是没有泛型信息的。如果要获取到泛型的信息，首先要获取到ParameterizedTypeImpl才可以。
 
————————————————
 
版权声明：本文为CSDN博主「hongxingxiaonan」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
 
原文链接：https://blog.csdn.net/hongxingxiaonan/article/details/49202613
 
public class Person{
 
}
 
import java.lang.reflect.ParameterizedType;
 
import java.lang.reflect.Type;
 
public class Student extends Person{
 
public static void main(String[] args){
 
Student st=new Student();
 
Class clazz=st.getClass();
 
//getSuperclass()获得该类的父类
 
System.out.println(clazz.getSuperclass());
 
//getGenericSuperclass()获得带有泛型的父类
 
//Type是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。
 
Type type=clazz.getGenericSuperclass();
 
System.out.println(type);
 
//ParameterizedType参数化类型，即泛型
 
ParameterizedType p=(ParameterizedType)type;
 
//getActualTypeArguments获取参数化类型的数组，泛型可能有多个
 
Class c=(Class) p.getActualTypeArguments()[0];
 
System.out.println(c);
 
}
 
}
 
打印结果：
 
class com.test.Person
 
com.test.Person
 
class com.test.Student