180530-反射获取泛型类的实际参数

文章链接：https://liuyueyi.github.io/hexblog/2018/05/30/180530-通过反射获取泛型类的实际参数/

反射获取泛型类的实际参数

泛型用得还是比较多的，那么如何获取泛型类上实际的参数类型呢？

比如一个接口为

public interface IBolt<T, K> {
}

现在给一个IBolt的具体实现类，可以获取到实际的参数类型么？下面几种case可以怎么获取实际的IBolt中的T和K类型呢？

// 实现接口方式
public class ABolt implements IBolt<String, Boolean>{}
public class AFBolt<T> implements IBolt<String, T> {}
public interface EBolt<T> extends IBolt<String, T> {}
public class AEBolt implements EBolt<Boolean> {}
public interface RBolt extends IBolt<String, Boolean>{}
public class ARBolt implements RBolt{}

// 继承抽象类方式
public abstract class AbsBolt<T,K> implements IBolt<T,K> {}
public class BBolt extends AbsBolt<String, Boolean> {}
public abstract class EAbsBolt<T> implements IBolt<String, T> {}
public class BEBolt extends EAbsBolt<Boolean> {}

I. 基本姿势

首先拿最简单的两个case来进行分析，一个是 ABolt, 一个是BBolt，根据这两个类信息来获取对应的泛型类型；

1. 接口实现方式获取

主要借助的就是右边这个方法：java.lang.Class#getGenericInterfaces

a. 简单对比

  1. Type[] getGenericInterfaces

以Type的形式返回本类直接实现的接口.这样就包含了泛型参数信息

  1. Class[] getInterfaces

返回本类直接实现的接口.不包含泛型参数信息

b. 编码实现

一个基础的实现方式如下

@Test
public void testGetTypes() {
    Type[] types = ABolt.class.getGenericInterfaces();
    ParameterizedType ptype;
    for (Type type: types) {
        if (!(type instanceof ParameterizedType)) { // 非泛型类型，直接丢掉
            continue;
        }

        ptype = (ParameterizedType) type;
        if (IBolt.class.equals(ptype.getRawType())) {
            // 如果正好是我们需要获取的IBolt对象，则直接获取
            Type[] parTypes = ptype.getActualTypeArguments();
            for (Type par: parTypes) {
                System.out.println(par.getTypeName());
            }
        }
    }
}

简单分析上面实现:

  • 首先是获取所有的接口信息，遍历接口，
  • 如果这个接口是支持泛型的，则返回的type应该是ParameterizedType类型
  • 获取原始类信息（主要目的是为了和目标类进行对比 IBolt.class.equals(ptype.getRawType())）
  • 获取泛型类型 ptype.getActualTypeArguments()

输出结果如下:

java.lang.String
java.lang.Boolean

上面这个实现针对ABolt还可以，但是换成 AEBolt 之后，即非直接实现目标接口的情况下，发现什么都获取不到，因为 IBolt.class.equals(ptype.getRawType()) 这个条件不会满足，稍稍改一下，改成只要是IBolt的子类即可

@Test
public void testGetTypes() {
    Type[] types = AEBolt.class.getGenericInterfaces();
    ParameterizedType ptype;
    for (Type type: types) {
        if (!(type instanceof ParameterizedType)) { // 非泛型类型，直接丢掉
            continue;
        }

        ptype = (ParameterizedType) type;
        if (ptype.getRawType() instanceof Class && IBolt.class.isAssignableFrom((Class<?>) ptype.getRawType())) {
            // 如果正好是我们需要获取的IBolt对象，则直接获取
            Type[] parTypes = ptype.getActualTypeArguments();
            for (Type par: parTypes) {
                System.out.println(par.getTypeName());
            }
        }
    }
}

此时输出为如下，实际上只是EBolt上的泛型类型，与我们期望的输出 (String, Boolean) 不符，后面再说

java.lang.Boolean

2. 抽象类继承方式获取

抽象类与接口的主要区别在于类是单继承的，所以改成用 java.lang.Class#getGenericSuperclass 获取

a. 简单对比

  1. Type getGenericSuperclass()

返回父类的基本类信息，包含泛型参数信息

  1. Class<? super T> getSuperclass();

返回父类信息，不包含泛型

b. 代码实现

同上面的差不多，针对BBolt的实现，可以这么来

@Test
public void testGetAbsTypes() {
    Class basicClz = BBolt.class;
    Type type;
    ParameterizedType ptype;
    while (true) {
        if (Object.class.equals(basicClz)) {
            break;
        }

        type = basicClz.getGenericSuperclass();
        if (!(type instanceof ParameterizedType)) {
            basicClz = basicClz.getSuperclass();
            continue;
        }

        ptype = (ParameterizedType) type;
        if (ptype.getRawType() instanceof Class && IBolt.class.isAssignableFrom((Class<?>) ptype.getRawType())) {
            Type[] parTypes = ptype.getActualTypeArguments();
            for (Type par : parTypes) {
                System.out.println(par.getTypeName());
            }
            break;
        } else {
            basicClz = basicClz.getSuperclass();
        }
    }
}

针对上面代码简单进行分析，步骤如下：

  • 获取父类（包含泛型）信息
  • 如果父类没有泛型信息，则继续往上获取父类信息
  • 包含泛型信息之后，判断这个类是否为我们预期的目标类 IBolt.class.isAssignableFrom((Class<?>) ptype.getRawType())
  • 如果是，则直接获取参数信息

输出结果如下:

java.lang.String
java.lang.Boolean

当然上面依然是存在和上面一样的问题，对于BEBolt这个类，输出的就和我们预期的不同，其输出只会有 EAbsBolt<Boolean> 上的信息，即到获取EAbsBolt这一层时，就结束了

java.lang.Boolean

如果我们将上面的判定当前类是否为Ibolt.class，会输出什么呢？

  • 什么都没有，因为Ibolt是接口，而获取父类是获取不到接口信息的，所以判定永远走不进去

II. 进阶实现

上面的基础实现中，都存在一些问题，特别是但继承结构比较复杂，深度较大时，其中又穿插着泛型类，导致不太好获取精确的类型信息，下面进行尝试探索，不保证可以成功

1. 接口实现方式

主要的目标就是能正常的分析AEBolt这个case，尝试思路如下：

  • 层层往上，直到目标接口，然后获取参数类型

改进后的实现如下

@Test
public void testGetTypes() {
//        Class basicClz = ARBolt.class;
    Class basicClz = AEBolt.class;
    Type[] types;
    ParameterizedType ptype;
    types = basicClz.getGenericInterfaces();
    boolean loop = false;
    while (true) {
        if (types.length == 0) {
            break;
        }

        for (Type type : types) {
            if (type instanceof Class) {
                if (IBolt.class.isAssignableFrom((Class<?>) type)) {
                    // 即表示有一个继承了IBolt的接口，完成了IBolt的泛型参数定义
                    // 如: public interface ARBolt extends IBolt<String, Boolean>
                    types = ((Class) type).getGenericInterfaces();
                    loop = true;
                    break;
                } else { // 不是预期的类，直接pass掉
                    continue;
                }
            }

            ptype = (ParameterizedType) type;
            if (ptype.getRawType() instanceof Class) {
                if (!IBolt.class.isAssignableFrom((Class<?>) ptype.getRawType())) {
                    continue;
                }

                if (IBolt.class.equals(ptype.getRawType())) {
                    // 如果正好是我们需要获取的IBolt对象，则直接获取
                    Type[] parTypes = ptype.getActualTypeArguments();
                    for (Type par : parTypes) {
                        System.out.println(par.getTypeName());
                    }
                    return;
                } else { // 需要根据父类来获取参数信息，重新进入循环
                    types = ((Class) ptype.getRawType()).getGenericInterfaces();
                    loop = true;
                    break;
                }
            }
        }

        if (!loop) {
            break;
        }
    }
}

上面的实现相比较之前的负责不少，首先来看针对 AEBolt 而言，输出为

java.lang.String
T

如果改成 ARBolt, 即RBolt这个接口在继承IBolt接口的同时，指定了参数类型，这时输出如

java.lang.String
java.lang.Boolean

也就是说这个思路是可以的，唯一的问题就是当实现目标接口的某一层接口，也是泛型时，直接定位到最底层，获取的就是T,K这种符号参数了，因为实际的类型参数信息，在上一层定义的

那么有没有办法将这个参数类型传递下去呢？

实际尝试了一下，再往下走就比较复杂了，感觉有点得不偿失，不知道是否有相关的工具类

2. 继承类方式

接口方式实现之后，继承类方式也差不多了，而且相对而言会更简单一点，因为继承是单继承的

@Test
public void testGetAbsTypes() {
    Class basicClz = BEBolt.class;
    Type type;
    ParameterizedType ptype;
    while (true) {
        if (Object.class.equals(basicClz)) {
            break;
        }

        type = basicClz.getGenericSuperclass();
        if (!(type instanceof ParameterizedType)) {
            basicClz = basicClz.getSuperclass();
            continue;
        }

        ptype = (ParameterizedType) type;

        if (Object.class.equals(basicClz.getSuperclass().getSuperclass())) { // 如果ptype的父类为Object，则直接分析这个
            Type[] parTypes = ptype.getActualTypeArguments();
            for (Type par : parTypes) {
                System.out.println(par.getTypeName());
            }
            break;
        } else {
            basicClz = basicClz.getSuperclass();
        }

    }
}

输出如下，同样有上面的问题

java.lang.String
T

III. 小结

通过反射方式，后去泛型类的参数信息，有几个有意思的知识点：

  1. 获取泛型类信息

    java.lang.Class#getGenericSuperclass
java.lang.Class#getGenericInterfaces

// 获取实际的泛型参数
java.lang.reflect.ParameterizedType#getActualTypeArguments
  2. Class判断继承关系 
    java.lang.Class#isAssignableFrom
// 父类作为调用方，子类作为参数

II. 其他

一灰灰Blog： https://liuyueyi.github.io/hexblog

一灰灰的个人博客，记录所有学习和工作中的博文，欢迎大家前去逛逛

声明

尽信书则不如，已上内容，纯属一家之言，因个人能力有限，难免有疏漏和错误之处，如发现bug或者有更好的建议，欢迎批评指正，不吝感激

扫描关注

原文地址：https://www.cnblogs.com/yihuihui/p/9127391.html

时间： 2024-11-13 11:10:51

180530-反射获取泛型类的实际参数的相关文章

反射获取泛型类、泛型方法

1 using System; 2 using System.Reflection; 3 4 namespace RFTest 5 { 6 //类ReflectionTest中定义了一个泛型函数DisplayType和泛型类MyGenericClass 7 class ReflectionTest 8 { 9 //泛型类MyGenericClass有个静态函数DisplayNestedType 10 public class MyGenericClass<T> 11 { 12 public s

C#通过反射获取类中的方法和参数个数，反射调用方法带参数

using System; using System.Reflection; namespace ConsoleApp2 { class Program { static void Main(string[] args) { //反射获取 命名空间+类名 string className = "ConsoleApp2.ClassSample"; string methodName = "test1"; //传递参数 Object[] paras = new Obje

反射获取一个方法中的参数名（不是类型）

一般来说,通过反射是很难获得参数名的,只能取到参数类型,因为在编译时,参数名有可能是会改变的,需要在编译时加入参数才不会改变. 使用注解是可以实现取类型名(或者叫注解名)的,但是要写注解,并不方便. 观察Spring mvc框架中的数据绑定,发现是可以直接把http请求中对应参数绑定到对应的参数名上的,他是怎么实现的呢? 先参考一下自动绑定的原理:Spring源码研究:数据绑定 在getMethodArgumentValues方法中,MethodParameter[] parameters =

java通过反射获取调用变量以及方法

一:反射概念 可以通过Class类获取某个类的成员变量以及方法,并且调用之. 二:通过反射获取方法.变量.构造方法 1 @Test 2 // 通过反射获取类定义的方法 3 public void testMethod() throws Exception { 4 @SuppressWarnings("rawtypes") 5 Class clazz = Class.forName("java.lang.String"); 6 Method[] m = clazz.g

反射-获取程序集的type

反射的基本概念 反射无处不在,我们天天在使用.Vs的智能提示,就是通过反射获取到类的属性.方法等.还有反编译工具也是通过反射实现. 反射:就是动态获取程序集的元数据(提供程序集的类型信息)的功能. Type类实现反射的一个重要的类,通过它我们可以获取类中的所有信息包括方法.属性等.可以动态调用类的属性.方法. 1,Type是对类的描述.如何获取Person类中的所有方法和属性? Person p = new Person(); Type tp = p.GetType();//获取当前实例的类型;

Spring中的AOP（五）——在Advice方法中获取目标方法的参数

摘要: 本文介绍使用Spring AOP编程中,在增强处理方法中获取目标方法的参数,定义切点表达式时使用args来快速获取目标方法的参数. 获取目标方法的信息 访问目标方法最简单的做法是定义增强处理方法时,将第一个参数定义为JoinPoint类型,当该增强处理方法被调用时,该JoinPoint参数就代表了织入增强处理的连接点.JoinPoint里包含了如下几个常用的方法: Object[] getArgs:返回目标方法的参数 Signature getSignature:返回目标方法的签名 Ob

Android开发之通过反射获取到Android隐藏的方法

在PackageManger中,有些方法被隐藏了,无法直接调用,需要使用反射来获取到该方法. 比如方法:getPackageSizeInfo(),通过这个方法可以获取到apk的CacheSize,CodeSize,DataSize等信息,但是该方法是隐藏的,@hide. 遇到这种情况,需要使用反射: 1 try { 2 //通过反射,获取到PackageManager隐藏的方法getPackageSizeInfo() 3 Method getPackageSizeInfo = PackageMa

Android通过反射获取资源ID

通过反射获取布局文件: protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); int id = this.getResources().getIdentifier("layout_test", "layout", this.getPackageName()); LayoutInflater inflater = LayoutInflater.f

Java自定义注解和运行时靠反射获取注解

Java注解是附加在代码中的一些元信息,用于一些工具在编译.运行时进行解析和使用,起到说明.配置的功能.注解不会也不能影响代码的实际逻辑,仅仅起到辅助性的作用.包含在 java.lang.annotation 包中. 1.元注解 元注解是指注解的注解.包括  @Retention @Target @Document @Inherited四种. 1.1.@Retention: 定义注解的保留策略 @Retention(RetentionPolicy.SOURCE)   //注解仅存在于源码中,在c