深入探索Java泛型的本质 | HeapDump性能社区

导读

为什么泛型擦除后仍可以获取类型信息，如何获取泛型类型，Java泛型与C++、Python中的有何区别，本文将为您揭开泛型的内幕。读完该篇文章，您可以了解到1.为什么需要泛型
2.Java代码在编译后是如何保存泛型信息的
3.Java泛型与C++、Python中的有何区别
4.如何动态获取泛型类型

1、Java为什么需要泛型？

泛型最众所周知的应用就是容器类，通常而言，我们只会用容器来存储一种类型的队形，泛型的主要目的之一就是用来指定容器要持有什么类型的对象，由编译器来保证类型的正确性。

Java在泛型出现之前，只能通过Object来实现类型泛化，手动转换导致只有程序员和运行期间的JVM才知道这个Object究竟是什么类型的对象。编译期间也无法检查Object强转是否成功的，这样不可避免的在运行期抛出更多的ClassCaseException。

如果有泛型，除了可以解决以上问题，同时也可以让不同的类型对象作用于同一个方法了。

2、泛型

泛型的本质是参数化类型(Parameterized Type)，即可用通过参数指定操作的数据类型。促成泛型出现最引人注明的一个原因就是为了创造容器类。

Java中的泛型：

泛型类：参数类型用于类中；
泛型接口：参数类型用于接口中；
泛型方法：参数类型用于方法中。

本文不详细讲解泛型的使用，感兴趣的朋友可以阅读这几篇文章：

Java笔记 – 泛型泛型方法泛型接口擦除边界通配符（1）
https://www.itzhai.com/java-bi-ji-fan-xing-fan-xing-fang-fa-fan-xing-jie-kou-ca-chu-bian-jie-tong-pei-fu.html
Java笔记 – 泛型泛型方法泛型接口擦除边界通配符（2）
https://www.itzhai.com/generic-method-interface-border-wildcard-2.html
Java基础笔记 - Java中的泛型使用详细介绍
https://www.itzhai.com/java-based-notebook-java-generics-use-the-detailed.html

这里我们来探索我们的主题，Java泛型在代码编译和执行过程中的内幕，在字节码里面是怎么体现的。

3、探索Java泛型的本质

在引入了泛型之后，为了能够让虚拟机解析、反射等各种场景正确获取到参数类型，JCP组织修改了虚拟机规范，引入了 Signature 、 LocalVariableTypeTable 新属性。

3.1、LocalVariableTypeTable

这里编写一个泛型类，探索其字节码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class GenericClass<GT1> {

private GT1 param1;

public GT1 getParam1() {
return param1;
}

public void setParam1(GT1 param1) {
this.param1 = param1;
}

}

class GenericClassTest extends GenericClass<Double> {
@Override
public Double getParam1() {
System.out.println(super.getParam1());
return super.getParam1();
}
}

编译之后，使用 javap -v 命令查看 GenericClass<GT1> 的反汇编信息，我们在实例构造器中的code中，发现有LocalVariableTypeTable：

LocalVariableTypeTable Attribute是方法的实例构造器的一个可选属性，如果方法中使用到了泛型，则会出现这个属性。

更多关于 LocalVariableTypeTable 的介绍： 4.7.14. The LocalVariableTypeTable Attribute
https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.7.14

接下来我们细看下 LocalVariableTypeTable 。

3.2、Signature

LocalVariableTypeTable 里面携带了一个具有类型的Signature签名。

对比可以发现，LocalVariableTable中也有Signature，不过LocalVariableTable中并不携带泛型信息。

这个Signature正是Java编译的时候生成的，用于标识对应的类、变量或者属性等的类型的签名。

这个Signature中除了原生类型，也保存了参数化类型(即泛型)的信息。

这样，即使在编译后，泛型的类型信息被擦除了，也能通过这个Signature获取到泛型的签名信息。

在Java中，不管使用到了具体的类型或者是泛型，都需要给定一个类型签名(Signature)。以下场景都会给定类型签名：

具有通用或者具有参数化类型的超类或者超接口的类；
方法中的通用或者参数化类型的返回值或者入参，以及方法的throw子句中的类型变量；
任何类型、类型变量、或者参数化类型的字段、形式参数或者局部变量；

Signature的的命名：

使用遵循 JVM规范第4.3.1节的语法指定签名。常见的字母简写含义如下：

上面的：

Lcom/itzhai/jvm/executeengine/编译期优化/泛型/GenericClass<TGT1;>;

表示实例的类名。可以发现这个类最后面跟了一个泛型类型名称 TGT1

在使用到了泛型的代码中，因为编译时并不知道最终执行的具体类型，所以会生成这个Signature用来表示泛型。Signature目前仅在Class的反射和编译阶段会用到。

3.2.1、Signature是怎么存储的

我们得重新复习下这篇文章了：Class文件16进制数字背后的秘密，这篇文章里面，我们知道了Class文件的结构如下：

JVM规范 4.7. Attributes 的Table 4.7-C. Predefined class file attributes (by location)表中，我们可以知道，Signature属性在ClassFile，field_info，method_info都可以存在，用于代表不同主体的类型签名信息。我们上面看到的是在method_info中的Signature。我们在上图标注一下，哪些地方会存储这个Signature：

3.3、擦除了泛型之后

上面 GenericClass<GT1> 类的 getParam1() 和 setParam1() 方法编译完成后，得到的反汇编代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public GT1 getParam1();
descriptor: ()Ljava/lang/Object;
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: getfield #2 // Field param1:Ljava/lang/Object;
4: areturn
LineNumberTable:
line 15: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcom/itzhai/jvm/executeengine/编译期优化/泛型/GenericClass;
LocalVariableTypeTable:
Start Length Slot Name Signature
0 5 0 this Lcom/itzhai/jvm/executeengine/编译期优化/泛型/GenericClass<TGT1;>;
Signature: #20 // ()TGT1;

public void setParam1(GT1);
descriptor: (Ljava/lang/Object;)V
flags: ACC_PUBLIC
Code:
stack=2, locals=2, args_size=2
0: aload_0
1: aload_1
2: putfield #2 // Field param1:Ljava/lang/Object;
5: return
LineNumberTable:
line 19: 0
line 20: 5
LocalVariableTable:
Start Length Slot Name Signature
0 6 0 this Lcom/itzhai/jvm/executeengine/编译期优化/泛型/GenericClass;
0 6 1 param1 Ljava/lang/Object;
LocalVariableTypeTable:
Start Length Slot Name Signature
0 6 0 this Lcom/itzhai/jvm/executeengine/编译期优化/泛型/GenericClass<TGT1;>;
0 6 1 param1 TGT1;
Signature: #23 // (TGT1;)V

可以发现，方法中的泛型替换为了 Object，也就是进行类类型擦除，实际运行的时候，都是Object类型了。

3.4、通过反射从Signature中获取泛型信息

我们知道泛型在编译阶段编译器可以用来校验类型，一旦编译通过之后，会擦除泛型。到了运行期，泛型实际上是Object了，这个时候可以通过反射获取泛型信息。

3.4.1、获取泛型信息例子

我们尝试获取泛型：

1 2	GenericClass<Double> temp = new GenericClass<>(); System.out.println(Arrays.toString(temp.getClass().getTypeParameters()));

结果：

[GT1]

发现这里只是获取到了泛型的名称，并没有获取到实际的类型。

为什么？？？

原来 GenericClass Class文件里面只有

1	Signature: #24 // <GT1:Ljava/lang/Object;>Ljava/lang/Object;

可以看到，这里的Signature只是保留了GT1这个泛型名称，以及泛型擦除后的实际类型，并不能感知到运行期究竟创建了什么类型。

怎么才能获取到泛型的具体类型呢？

1
2
3
4
5
6
7
8
9

GenericClassTest genericClass = new GenericClassTest();
Class clazz = genericClass.getClass();
// getGenericSuperclass()获得带有泛型的父类
// Type是Java中所有类型的公共高级接口,包括原始类型、参数化类型、数组类型、类型变量和基本类型。
Type type = clazz.getGenericSuperclass();
ParameterizedType p = (ParameterizedType)type;
// getActualTypeArguments获取参数化类型的数组，泛型可能有多个
Class c = (Class) p.getActualTypeArguments()[0];
System.out.println(c);

结果：

1	class java.lang.Double

成功获取到了实际类型。

原因是 GenericClassTest 的ClassFile的attributes中包含了泛型的签名信息：

1 2	Signature: #20 // Lcom/itzhai/jvm/executeengine/编译期优化/泛型/GenericClass<Ljava/lang/Double;>; SourceFile: "GenericClass.java"

这个签名信息是编译的时候可以根据 GenericClassTest 类生成的。

4、Java泛型与C++泛型有什么区别？

下面举一个《Thinking is Java》中的例子来说明。

查看下面的一段C++的泛型代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include <iostream>
using namespace std;

template<class T> class Manipulator {
T obj;
public:
Manipulator(T x) { obj = x; }
void manipulate() { obj.f(); }
};

class HasF {
public:
void f() { cout << "HasF::f()" << endl; }
};

int main() {
HasF hf;
Manipulator<HasF> manipulator(hf);
manipulator.manipulate();
} /* Output:
HasF::f()

C++编写的泛型，当模板被实例化时，模板代码知道其模板参数的类型，C++编译器将进行检查，如果泛型对象调用了一个当前实例化对象不存在的方法，则报一个编译期错误。例如上面的manipulate里面调用了obj.f()，因为实例化的HasF存在这个方法，所以不会报错。

而Java是使用擦除实现泛型的，在没有指定边界的情况下，是不能在泛型类里面直接调用泛型对象的方法的，如下面的例子：

1
2
3
4
5
6
7
8
9
10

public class Manipulator<T> {

private T obj;
public Manipulator(T x){
obj = x;
}
public void doSomething(){
obj.f(); // 编译错误
}
}

通过没有边界的obj调用f()，编译出错了，下面指定边界，让其通过编译：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class Manipulator<T extends HasF> {

private T obj;
public Manipulator(T x){
obj = x;
}
public void doSomething(){
obj.f(); // 编译错误
}
}
class HasF{
public void f(){
System.out.println("HasF.f();");
}
}

上面的例子，把泛型类型参数擦除到了HasF，就好像在类的声明中用HasF替换了T一样。

5、Java泛型的弊端与改进思路

Java泛型中，当要在泛型类型上执行操作时，就会产生问题，因为擦除要求指定可能会用到的泛型类型的边界，以安全地调用代码中的泛型对象上的具体方法。这是对“泛化”概念的一种明显的限制，因为必须限制你的泛型类型，使他们继承自特定的类，或者特定的接口。在某些情况下，你最终可能会使用普通类或者普通接口，因为限定边界的泛型和可能会和指定类或接口没有任何区别。

某些编程语言提供的一种解决方法称为 潜在潜在机制 或 结构化类型机制 （鸭子类型机制：如果它走起来像鸭子，并且叫起来也像鸭子，那么你就可以将它当做鸭子对待。）

潜在类型机制 使得你可以横跨类继承结构，调用不属于某个公共接口的方法。因此，实际上一段代码可以声明：“我不关心你是什么类型，只要你可以speak()和sit()即可。”由于不要求具体类型，因此代码就可以更加泛化了。

两种支持潜在类型机制的语言：Python和C++。

下面一段选取自《Thinking is Java》的Python潜在类型机制的代码演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Dog:
def speak(self):
print "Arf!"
def sit(self):
print "Sitting"
def repoduce(self)
pass

class Robot:
def speak(self):
print "Click!"
def sit(self):
print "Clank!"
def repoduce(self)
pass

def perform(anything):
anything.spead()
anything.sit()

perform的anything参数只是一个标示符，它必须能够执行perform()期望它执行的操作，因此这里隐含着一个接口，但是从来都不必显示地写出这个接口——它是潜在的。perform不关心其参数的类型，因此我们可以向它传递任何对象，只要该对象支持speak()和sit()方法，否则，得到运行时异常。

Java的泛型是JDK5之后才添加的，为了兼容旧版本，因此没有任何机会可以去实现任何类型的潜在类型机制。

6、Java中对缺乏类型机制的补偿

对于潜在类型机制的一种补偿，可以使用的一种方式是反射，《Thinking is Java》提供了如下的案例，其中perform()方法就是用了潜在类型机制：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

class Mime {
public void walkAgainstTheWind() {}
public void sit() { System.out.println("Pretending to sit"); }
public void pushInvisibleWalls() {}
public String toString() { return "Mime"; }
}

class SmartDog {
public void speak() { System.out.println("Woof!"); }
public void sit() { System.out.println("Sitting"); }
public void reproduce() {}
}

class CommunicateReflectively {
public static void perform(Object speaker) {
Class<?> spkr = speaker.getClass();
try {
try {
Method speak = spkr.getMethod("speak");
speak.invoke(speaker);
} catch(NoSuchMethodException e) {
System.out.println(speaker + " cannot speak");
}
try {
Method sit = spkr.getMethod("sit");
sit.invoke(speaker);
} catch(NoSuchMethodException e) {
System.out.println(speaker + " cannot sit");
}
} catch(Exception e) {
throw new RuntimeException(speaker.toString(), e);
}
}
}

public class Chapter15_17_1 {

public static void main(String[] args) {
CommunicateReflectively.perform(new SmartDog());
CommunicateReflectively.perform(new Robot());
CommunicateReflectively.perform(new Mime());
}
}

/* Output:
Woof!
Sitting
Click!
Clank!
Mime cannot speak
Pretending to sit
*///:~

References

《Thinking in Java》

Java笔记 – 泛型泛型方法泛型接口擦除边界通配符（1）
https://www.itzhai.com/java-bi-ji-fan-xing-fan-xing-fang-fa-fan-xing-jie-kou-ca-chu-bian-jie-tong-pei-fu.html

Java笔记 – 泛型泛型方法泛型接口擦除边界通配符（2）
https://www.itzhai.com/generic-method-interface-border-wildcard-2.html?sdf

The Java® Virtual Machine Specification Java SE 8 Edition
https://docs.oracle.com/javase/specs/jvms/se8/html/index.html

欢迎关注微信公众号《Java架构杂谈》。

深入探索Java泛型的本质原创

1、Java为什么需要泛型？

2、泛型

3、探索Java泛型的本质

3.1、LocalVariableTypeTable

3.2、Signature

3.2.1、Signature是怎么存储的

3.3、擦除了泛型之后

3.4、通过反射从Signature中获取泛型信息

3.4.1、获取泛型信息例子

4、Java泛型与C++泛型有什么区别？

5、Java泛型的弊端与改进思路

6、Java中对缺乏类型机制的补偿

References

推荐阅读

专题推荐

本月精选性能专题

本月精选线上案例

本月精选原创好文

联系我们

网媒渠道

友情链接