Java 反射类型Type的用法说明
各个方法
1. 得到class的成员变量
首先得到object的class对象
然后在class对象中用getdeclaredfields()方法来获得class的成员变量
fieldtest ft = new fieldtest(); class ftclass = ft.getclass(); field[] fields = ftclass.getdeclaredfields();
2. field的函数
field对象有很多成员方法
getname()获取名称。
getgenerictype() 返回一个type对象
gettype() 返回class对象
getgenerictype 和gettype区别:
返回类型一个是class对象一个是type接口。
如果属性是泛型，gettype（）返回属性的接口类型。getgenerictype（）还能返回参数类型。
string fieldname = field.getname(); type generictype = field.getgenerictype(); boolean isparameterizedtype = (generictype instanceof parameterizedtype); class fieldclazz = field.gettype(); string valuetypename = generictype.gettypename();
3.获取范型的type和class
获取 范型的key和value的type
type[] generictypes = ((parameterizedtype) generictype).getactualtypearguments(); type type0 = generictypes[0]; type type1 = generictypes[1];
通过google的com.google.common.reflect.typetoken.of(type1).getrawtype()方法获取map的key或者value的class类型。
class<?> clazz = com.google.common.reflect.typetoken.of(type1).getrawtype();
总代码
class fieldtest {
private string pri;
protected string pro;
public map<integer, hashmap<integer, float>> fcmap;
public fieldtest() {
}
public fieldtest(string pri, string pro, string pub) {
this.pri = pri;
this.pro = pro;
}
}
package cn.hyperchain.hvm.abi;
import java.lang.reflect.array;
import java.lang.reflect.field;
import java.lang.reflect.parameterizedtype;
import java.lang.reflect.type;
import java.util.arrays;
import java.util.hashmap;
import java.util.map;
public class test {
private static boolean checkclazzisspecific(class cclazz, class specific) {
if (cclazz == specific) return true;
class[] interfaces = cclazz.getinterfaces();
boolean result = false;
for (class inter : interfaces) {
if (result) break;
if (inter == specific) {
result = true;
break;
}
result = checkclazzisspecific(inter, specific);
}
return result;
}
public static void main(string args[]) {
fieldtest ft = new fieldtest();
class ftclass = ft.getclass();
field[] fields = ftclass.getdeclaredfields();
for (int i = 0; i < fields.length; i++) {
field field = fields[i];
string fieldname = field.getname();
type generictype = field.getgenerictype();
class fieldclass = field.getclass();
boolean isparameterizedtype = (generictype instanceof parameterizedtype);
class fieldclazz = field.gettype();
string valuetypename = generictype.gettypename();
system.out.println();
system.out.println("-------------------------------------------------");
system.out.println();
system.out.println("fieldname: " + fieldname);
system.out.println("generictype: " + generictype);
system.out.println("fieldclazz: " + fieldclazz);
system.out.println("isparameterizedtype: " + isparameterizedtype);
system.out.println("valuetypename: " + valuetypename);
if (checkclazzisspecific(fieldclazz, map.class)) {
type[] generictypes = ((parameterizedtype) generictype).getactualtypearguments();
type type0 = generictypes[0];
type type1 = generictypes[1];
string type1name = generictypes[1].gettypename();
system.out.println("type0: " + type0);
system.out.println("type1: " + type1);
system.out.println("type1name: " + type1name);
system.out.println(type1 instanceof parameterizedtype);
type type3 = ((parameterizedtype)type1).getownertype();
class type4 = type1.getclass();
//class<?> type5 = (class<?>) type1;
system.out.println("type3: " + type3);
system.out.println("type4: " + type4);
//system.out.println(type5);
class<?> clazz = com.google.common.reflect.typetoken.of(type1).getrawtype();
system.out.println("clazz: " + clazz);
}
}
}
}
class fieldtest {
private string pri;
protected string pro;
// public map<string, integer> map;
public map<integer, hashmap<integer, float>> fcmap;
public fieldtest() {
}
public fieldtest(string pri, string pro, string pub) {
this.pri = pri;
this.pro = pro;
}
}
class abc {
private string pri;
protected string pro;
public string pub;
public string[] string;
public int[] innt;
public map<string, integer> map;
public abc() {
}
public abc(string pri, string pro, string pub) {
this.pri = pri;
this.pro = pro;
this.pub = pub;
}
}
结果：
-------------------------------------------------
fieldname: pri
generictype: class java.lang.string
fieldclazz: class java.lang.string
isparameterizedtype: false
valuetypename: java.lang.string-------------------------------------------------
fieldname: pro
generictype: class java.lang.string
fieldclazz: class java.lang.string
isparameterizedtype: false
valuetypename: java.lang.string-------------------------------------------------
fieldname: fcmap
generictype: java.util.map<java.lang.integer, java.util.hashmap<java.lang.integer, java.lang.float>>
fieldclazz: interface java.util.map
isparameterizedtype: true
valuetypename: java.util.map<java.lang.integer, java.util.hashmap<java.lang.integer, java.lang.float>>
type0: class java.lang.integer
type1: java.util.hashmap<java.lang.integer, java.lang.float>
type1name: java.util.hashmap<java.lang.integer, java.lang.float>
true
type3: null
type4: class sun.reflect.generics.reflectiveobjects.parameterizedtypeimpl
clazz: class java.util.hashmapprocess finished with exit code 0
补充：java-使用反射获取类型信息
java中如何使用反射获取类型信息？
最近写了大量需要根据类属性的类型反射注入值的代码，总结了以下常用的反射技巧：
一个简单类的例子
在这个类中，有普通的string类型，有数组类型，有带泛型的list类型，有嵌套list类型，以及有多个泛型参数的简单类，这个类将作为我们后面的内容的基础。我们这一次博客解析如何使用反射获取到不同属性的类型值。
public class some{
private string name;
private integer[] numbers;
private list<string> list;
private list<list<double>> matrix;
private map<string,class> map;
//ignore getter and setter
}
分析如何获取不同属性的类型
1、普通类型
普通类型的变量直接field.gettype()即可以获取到他们的类型
public void querynametype() throws nosuchfieldexception {
field field = some.class.getdeclaredfield("name");
class<?> type = field.gettype();
assertequals(type,string.class);
}
2、数组类型
数组类型不像其他的类型可以通过isassignablefrom()函数来进行判断，他需要使用isarray() 来判断该type是否是一个数组类型，然后使用getcomponenttype() 获取他的元素的类型
public void queryarraytype() throws nosuchfieldexception {
field field = some.class.getdeclaredfield("numbers");
class<?> type = field.gettype();
//一般来说，判断是否是某种类型是可以使用isassignablefrom
// 判断是否是数组类型比较特殊，要使用isarray()这个函数
if (type.isarray()){
//获得数组的类型，使用getcomponenttype()这个方法
class<?> componenttype = type.getcomponenttype();
assertequals(componenttype,integer.class);
}
else{
throw new illegalstateexception();
}
}
3、带泛型的类型
带泛型的类型就是类似于list<string>这样的类型，我们现在的任务就是获取到string这个类型。
parameterizedtype表示参数化的类型，例如collection这样的类型。我们可以通过getgenerictype()方法获得该子类，当你的类型带有参数的时候就会返回parameterizedtype,否则会返回普通的类型(class)
那么具体是怎么操作的呢？
以获得list<t>的类型为例子
public void getlisttype() throws nosuchfieldexception {
field field = some.class.getdeclaredfield("list");
//如果类似于list<string>这样的类型就是一种generictype
//注意这是一种type类型
type type = field.getgenerictype();
if (type instanceof parameterizedtype){
//泛型参数类型
parameterizedtype parameterizedtype = (parameterizedtype)type;
type[] actualtypes = parameterizedtype.getactualtypearguments();
//因为list<string>获得第一个泛型参数,因为只有一个，我们取第一个
//如果我们有多个泛型参数，我们可以根据顺序取不同的泛型参数
assertequals(actualtypes[0],string.class);
//如果获得list这个原始类型呢？
assertequals(parameterizedtype.getrawtype(),list.class);
}else{
throw new illegalstateexception();
}
}
4、复杂的嵌套类型
假如是list<list<string>> 如何获得最里面的类型呢？
例子如下
public void getsublisttype() throws nosuchfieldexception {
//思考一下，如果我们有一个嵌套list，我们想拿到嵌套在最里面的类型，那么我们可以这么做呢？
//其实我们可以使用递归的思想去获得最里面的类型
field field = some.class.getdeclaredfield("matrix");
assertequals(getbasetype(field.getgenerictype()),double.class);
}
public static type getbasetype(type genericreturntype){
objects.requirenonnull(genericreturntype);
if (genericreturntype instanceof parameterizedtype &&
list.class.isassignablefrom((class)(((parameterizedtype) genericreturntype).getrawtype()))){
type[] actualtypearguments = ((parameterizedtype)genericreturntype).getactualtypearguments();
type type = actualtypearguments[0];
return getbasetype(type);
}else{
return genericreturntype;
}
}
5、多个泛型参数
与第三个例子相似，只需要使用actualtypes数组按顺序取即可
例子如下
public void getmaptype() throws nosuchfieldexception {
field field = some.class.getdeclaredfield("map");
type type = field.getgenerictype();
if (type instanceof parameterizedtype){
parameterizedtype parameterizedtype = (parameterizedtype)type;
type[] actualtypes = parameterizedtype.getactualtypearguments();
assertequals(actualtypes[0],string.class);
assertequals(actualtypes[1],class.class);
}else{
throw new illegalstateexception();
}
}
总结
以上总结了几种常用的使用反射获取属性类型的例子，稍加改造就可以写自己的工具类了。希望对大家有帮助^_^