这篇博客总结了Java中通过反射获取泛型信息的方法，包括类、方法、字段的泛型。文章通过示例展示了如何使用ParameterizedType、GenericArrayType、TypeVariable和Class等接口获取不同类型的泛型信息，并提供了相关的代码示例和执行结果，帮助读者理解Java泛型反射的使用。
总结一下java中获取与泛型相关的信息的知识,不如说是使用方法.网上也有很多类似的优秀文章,这里主要做一个知识的总结.通过反射获取泛型信息的常见例子:
//bean
package testProject;
public class Person {
private String nameString = "233";
public String getNameString() {
return nameString;
}
public void setNameString(String nameString) {
this.nameString = nameString;
}
@Override
public String toString() {
return "Person [nameString=" + nameString + "]";
}
}
//基本dao
public abstract class BaseDao {
private Class clazz = null;
{
Type type = getClass().getGenericSuperclass();
if( type instanceof ParameterizedType ){
ParameterizedType pType = (ParameterizedType)type;
Type claz = pType.getActualTypeArguments()[0];
if( claz instanceof Class ){
this.clazz = (Class) claz;
}
}
}
public T getEntity() throws InstantiationException, IllegalAccessException{
return this.clazz.newInstance();
}
}
//实现
public class PersonDao extends BaseDao {
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
PersonDao pDao = new PersonDao();
System.out.println( pDao.getEntity().toString() );
}
}
//结果:Person [nameString=233]
在java的java.lang.reflect 包中有一个Type接口. 具体子类如下.
一般java中包含泛型信息的地方包括类( class MyClass )方法( public void test(T t){ } )字段( public List list,public T t),继承的父类中包含( class MyClass1 extends MyClass{} )等.
java将这些泛型信息进行了分类,包括包含泛型信息的类型,不包含泛型信息的类型,泛型数组类型,以及对泛型参数(T,V等泛型参数)信息类等.所有这些分类统一用Type接口作为抽象
class HaveGenericClass{}classNoGenericClass{}public class TypeTest{private Listlist;privateT t;privateList list1;private Listlist2;privateHaveGenericClass haveGenericClassWithoutGeneric;private HaveGenericClasshaveGenericClassWithGeneric;privateNoGenericClass noGenericClass;private int var;private List[] listTArr;private List[] listStringArr;privateList[] listArr;privateT[] tArr;private int[] intArr;privateHaveGenericClass[] haveGenericClassWithoutGenericArr;private HaveGenericClass[] haveGenericClassWithGenericArr;private HaveGenericClass[] haveGenericClassWithGenericArr2;privateNoGenericClass[] noGenericClassArr;private U genericMethod(U u,String s){returnu;
}public static voidmain(String[] args) throws NoSuchFieldException, SecurityException, NoSuchMethodException {
Field[] fields= TypeTest.class.getDeclaredFields();for( Field f: fields ){
Type t=f.getGenericType();
printType(f.getName(), t);
}
Method genericMethod= TypeTest.class.getDeclaredMethod("genericMethod",Object.class,String.class);
Type[] types=genericMethod.getGenericParameterTypes();
Parameter[] ps=genericMethod.getParameters();for(Parameter p : ps){
Type type=p.getParameterizedType();
printType(p.getName(), type);
System.out.println( p.getType() );
}
}public static voidprintType(String name, Type type){if( type instanceof Class ){
System.out.println("the type of" + name + "is : Class");
}else if( type instanceof ParameterizedType ){
System.out.println("the type of" + name + "is : ParameterizedType");
}else if( type instanceof GenericArrayType ){
System.out.println("the type of" + name + "is : GenericArrayType");
}else if( type instanceof TypeVariable ){
System.out.println("the type of" + name + "is : TypeVariable");
}
}
}
运行结果如下:
the type of list is : ParameterizedType
the type of t is : TypeVariable
the type of list1 is : Class
the type of list2 is : ParameterizedType
the type of haveGenericClassWithoutGeneric is : Class
the type of haveGenericClassWithGeneric is : ParameterizedType
the type of noGenericClass is : Class
the type of var is : Class
the type of listTArr is : GenericArrayType
the type of listStringArr is : GenericArrayType
the type of listArr is : Class
the type of tArr is : GenericArrayType
the type of intArr is : Class
the type of haveGenericClassWithoutGenericArr is : Class
the type of haveGenericClassWithGenericArr is : GenericArrayType
the type of haveGenericClassWithGenericArr2 is : GenericArrayType
the type of noGenericClassArr is : Class
the type of arg0 is : TypeVariable
class java.lang.Object
the type of arg1 is : Class
class java.lang.String
从上面的测试中可以看到,带有泛型信息的类型可以划分到ParameterizedType类型,类似( List,List等).包含泛型信息的数组则可以划分到GenericArrayType分类,其余不包含泛型信息的类型可以划分到Class类型(可以认为不包含泛型的类型也是一种参数化类型(参数化类型 举个例子就是 class person{ }这样子),只不过这种参数化类型的泛型信息为零(没有泛型信息的参数化类型)),因此Class类也实现Type接口.下面就介绍有一下这4个类的方法和如何获取(仅限我所知道的).
1.ParameterizedType
public interfaceParameterizedType extends Type {
//获取<>中的实际类型Type[] getActualTypeArguments();
//获取<>前的实际类型Type getRawType();
//如果这个类是某个类的所属,返回这个所属的类,否则返回nullType getOwnerType();
}
Type[] getActualTypeArguments();
获取<>中的实际类型,该方法只脱去最外层的<>.
class People{}public class TypeTest{private People,T>People;public static voidmain(String[] args) throws NoSuchFieldException, SecurityException, NoSuchMethodException {
Type t= TypeTest.class.getDeclaredField("People").getGenericType();
ParameterizedType pt=(ParameterizedType)t;
Type[] types=pt.getActualTypeArguments();for( int i = 0; i < types.length; i++){
printType(types[i].toString(), types[i]);
}
}public static voidprintType(String name, Type type){if( type instanceof Class ){
System.out.println("the type of" + name + "is : Class");
}else if( type instanceof ParameterizedType ){
System.out.println("the type of" + name + "is : ParameterizedType");
}else if( type instanceof GenericArrayType ){
System.out.println("the type of" + name + "is : GenericArrayType");
}else if( type instanceof TypeVariable ){
System.out.println("the type of" + name + "is : TypeVariable");
}
}
}
执行结果为
the type of class java.lang.String is : Class
the type of java.util.List is : ParameterizedType
the type of T is : TypeVariable
可以看到第二个泛型参数的类型是ParameterizedType,也真是List所对应的类型.另外第三个泛型参数的类型为TypeVariable,泛型参数(T,V等泛型参数)信息类(我是这么解释和理解的)之后会提到.
2.getRawType()
获取声明泛型的实际的类或接口,也就是<>前面的那个值
3.getOwnerType()
如果该类是内部类,那么该方法可以获取外部类,否则返回null, 举个例子
public class TypeTest{private People,T>People;private class Inner{}private Innerinner;public static voidmain(String[] args) throws NoSuchFieldException, SecurityException, NoSuchMethodException {
Type t= TypeTest.class.getDeclaredField("inner").getGenericType();
ParameterizedType pt=(ParameterizedType)t;
Type t1=pt.getOwnerType();if( t1 instanceof ParameterizedType ){
ParameterizedType pt1=(ParameterizedType)t1;
System.out.println( pt1.getRawType() );
}
}
}
结果:
class testProject.TypeTest
2.GenericArrayType
泛型数组类型,类似(List[] T[]等).
public interfaceGenericArrayType extends Type {Type getGenericComponentType();
}
返回泛型数组中元素的Type类型,即List[] 中的 List(ParameterizedTypeImpl),T[] 中的T(TypeVariableImpl),List[][]中的List[]();
public class TypeTest{private List[] lists;privateT[] ts;private List[][] listss;public static voidmain(String[] args) throws NoSuchFieldException, SecurityException, NoSuchMethodException {
Type lists= ((GenericArrayType)TypeTest.class.getDeclaredField("lists").getGenericType()).getGenericComponentType();
Type ts= ((GenericArrayType)TypeTest.class.getDeclaredField("ts").getGenericType()).getGenericComponentType();
Type listss= ((GenericArrayType)TypeTest.class.getDeclaredField("listss").getGenericType()).getGenericComponentType();
printType("lists", lists);
printType("ts",ts );
printType("listss",listss );
}public static voidprintType(String name, Type type){if( type instanceof Class ){
System.out.println("the type of" + name + "is : Class");
}else if( type instanceof ParameterizedType ){
System.out.println("the type of" + name + "is : ParameterizedType");
}else if( type instanceof GenericArrayType ){
System.out.println("the type of" + name + "is : GenericArrayType");
}else if( type instanceof TypeVariable ){
System.out.println("the type of" + name + "is : TypeVariable");
}
}
}
执行结果如下:
the type of lists is : ParameterizedType
the type of ts is : TypeVariable
the type of listss is : GenericArrayType
3.TypeVariable
泛型的类型变量,可以认为是List中的T,Map中的K,V等
3.1 getBounds()
获取类型变量上限,如果没有上限(即 class Person{},这里的类型变量T 没有上限),那么上限为Object
public class TypeTest>{//继承String,实现接口Comparable,可以用&连接多个接口private List[] lists;privateT[] ts;private List[][] listss;public static void main(String[] args) throwsNoSuchFieldException, SecurityException, NoSuchMethodException {
TypeVariable tv[]= TypeTest.class.getTypeParameters();
Type[] ts= tv[0].getBounds();for( Type t : ts ){
System.out.println( t );
}
}
}
执行结果如下:
class java.lang.String
java.lang.Comparable
3.2 getGenericDeclaration()
获取声明该类型变量的类比如( TypeTest 中的TypeTest )
public class TypeTest{private List[] lists;private List[][] listss;public static void main(String[] args) throwsNoSuchFieldException, SecurityException, NoSuchMethodException {
TypeVariable tv[]= TypeTest.class.getTypeParameters();
System.out.println( tv[0].getGenericDeclaration() );
}
}
执行结果:
class testProject.TypeTest
3.3 getName()
获取类型变量在源码中定义的名称
public class TypeTest{private List[] lists;private List[][] listss;public static void main(String[] args) throwsNoSuchFieldException, SecurityException, NoSuchMethodException {
TypeVariable tv[]= TypeTest.class.getTypeParameters();
System.out.println( tv[0].getName() );
}
}
执行结果:
T
//补充一点
泛型的声明包括在类上方法上或者构造函数上,并不能再字段上声明泛型.
在类上声明:
class Person{
private T t; //字段可以使用声明的泛型
}
在构造函数上声明:
class TypeTest{
public TypeTest(){}
}
在方法上声明:
class TypeTest{
public void test(T t){}
}
但不能直接在字段上声明, 比如
class Person{
private T t;//错误
}
这样的使用方法不正确.
由此及彼,在获取泛型变量的方式上,java提供了一个GenericDeclaration接口
public interfaceGenericDeclaration{
TypeVariable>[] getTypeParameters();
}
用于获取泛型变量,
而实现该接口的继承体现如下
其中并不包含Field类.
4.Class
Class描述类的字节码信息(即.class文件的信息),包括所描述的类的字段信息,方法信息,注解信息,也包括与泛型有关的信息. 下面只介绍和泛型有关的方法.
public final class Class extendsObjectimplements Serializable,GenericDeclaration,Type,AnnotatedElement
4.1 getTypeParameters
TypeVariable>[] getTypeParameters()
返回类上的泛型信息( 比如Person{},则返回TypeVariable数值标识泛型变量T,U ,如果没有泛型信息则数组长度为零)
class People{
}class Chinese extends People{
}public class TypeTest{public TypeTest(){
}private List[] lists;private List[][] listss;public static void main(String[] args) throwsNoSuchFieldException, SecurityException, NoSuchMethodException {
TypeVariable[] tv= People.class.getTypeParameters();
System.out.println( tv.length );for( TypeVariable t : tv ){
System.out.println( t );
}
TypeVariable[] tv1= Chinese.class.getTypeParameters();
System.out.println( tv1.length );for( TypeVariable t : tv1 ){
System.out.println( t );
}
}
}
执行结果如下:
3
T
V
S
0
4.2 getGenericSuperClass();
返回该类的父类的泛型类型 比如( class Chinese extendis People{},返回的是People,如果没有父类,返回的是Objec的Class实例 )
4.3 getGenericInterfaces();
返回该类的实现的接口们的泛型类型 比如(class Chinese extends People implements SpeakChinese,UseChopsticks{},返回的是SpeakChinese,UseChopsticks,如果没有实现的接口,返回的Type数组长度为0)
代码如下:
interface Walk{}interface SpeakChinese{}interface UseChopsticks{}class People implements Walk{
}class Chinese extends People implements SpeakChinese,UseChopsticks{
}class Mars extends People>{
}public class TypeTest{public TypeTest(){
}public static void main(String[] args) throwsNoSuchFieldException, SecurityException, NoSuchMethodException {
printType(People.class.getGenericSuperclass().toString(), People.class.getGenericSuperclass());
printType(Chinese.class.getGenericSuperclass().toString(), Chinese.class.getGenericSuperclass());
Type[] types= Chinese.class.getGenericInterfaces();
System.out.println( types.length );for(Type t: types){
printType(t.toString(), t);
}
Type[] types1= Mars.class.getGenericInterfaces();
System.out.println( types1.length );for( Type t : types1 ){
printType( t.toString(),t );
}
}public static voidprintType(String name, Type type){if( type instanceofClass ){
System.out.println("the type of " + name + " is : Class");
}else if( type instanceofParameterizedType ){
System.out.println("the type of " + name + " is : ParameterizedType");
}else if( type instanceofGenericArrayType ){
System.out.println("the type of " + name + " is : GenericArrayType");
}else if( type instanceofTypeVariable ){
System.out.println("the type of " + name + " is : TypeVariable");
}
}
}
执行结果如下:
the type of class java.lang.Object is : Class
the type of testProject.People is : ParameterizedType
2
the type of testProject.SpeakChinese is : ParameterizedType
the type of testProject.UseChopsticks is : ParameterizedType
0
以上就是4种类型的介绍.
另外 还有一个接口继承自Type接口
WildcardType
用于描述包含通配符的泛型变量的信息. 比如List extends String> 或者 List super Integer>等
public interface WildcardType extendsType{
Type[] getLowerBounds();
Type[] getUpperBounds();
}
getLowerBounds()
获取泛型变量的下界,
getUpperBounds()
获取泛型变量的上界.
public class TypeTest{private List extends String>upperBoundsList;private List super Integer>lowerBoundsList;public static void main(String[] args) throwsNoSuchFieldException, SecurityException, NoSuchMethodException {
Field upperBoundsList= TypeTest.class.getDeclaredField("upperBoundsList");
ParameterizedType pt=(ParameterizedType)upperBoundsList.getGenericType();
Type[] types=pt.getActualTypeArguments();
System.out.println( ((WildcardType)types[0]).getUpperBounds()[0] );
Field lowerBoundsList= TypeTest.class.getDeclaredField("lowerBoundsList");
ParameterizedType pt1=(ParameterizedType)lowerBoundsList.getGenericType();
Type[] types1=pt1.getActualTypeArguments();
System.out.println( ((WildcardType)types1[0]).getLowerBounds()[0] );
}
}
执行结果如下:
class java.lang.String
class java.lang.Integer
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------*/
以上为本人查阅资料参考网上文章所写,
不能保证完全正确,
也并非面面俱到.
表述方式并不是偏向于专业化(如有疑惑的地方可留言),如有错误,望指正.
参考文档:
http://tool.oschina.net/apidocs/apidoc?api=jdk_7u4
http://www.jianshu.com/p/e8eeff12c306
扫一扫
1807
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
