跳转至

Java泛型擦除与解决办法

约 1433 个字 145 行代码 预计阅读时间 7 分钟

泛型擦除介绍

在Java中的泛型中提到,泛型在编译时会被统一替换,这个机制称为擦除机制。之所以这样设计,是为了兼容早期没有泛型的JDK版本(即裸类型),所以泛型基本只存在于编译期,编译之后大部分泛型信息都会被擦除

例如下面的代码:

1
2
3
4
5
6
7
List<String> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();

System.out.println(list1.getClass() == list2.getClass());

输出结果:
true

在运行时,list1和list2的类型都是ArrayList,并不存在ArrayList<String>和ArrayList<Integer>的区别

Note

准确来说,泛型参数会被擦除为它的上界。没有指定上界时擦除为Object,如果指定了上界,例如<T extends Comparable<T>>,则T会被擦除为Comparable

所以泛型擦除本身并不是一个需要「解决」的问题,它是Java泛型的设计机制。实际开发中真正需要解决的是:当运行时确实需要知道T是什么类型时,如何绕过类型擦除

解决方案

显式传入Class<T>

这是最简单也最常用的方式,即在泛型方法中额外传入一个Class<T>类型的参数,例如:

1
2
3
4
5
6
public <T> T create(Class<T> clazz) throws Exception {
    return clazz.getDeclaredConstructor().newInstance();
}

// 调用
User user = create(User.class);

虽然T被擦除了,但是User.class是一个真实存在的运行时对象,所以类型信息就通过这个对象保留了下来。实际项目中最常见的就是JSON反序列化:

1
2
3
4
5
6
public <T> T parse(String json, Class<T> clazz) throws JsonProcessingException {
    return objectMapper.readValue(json, clazz);
}

// 调用
User user = parse(json, User.class);

这种方式适合User、Order这种简单类型,但是遇到List<User>、Map<String, User>这种本身带泛型的类型就不够用了,因为只能写List.class,不能写List<User>.class

通过反射读取Type/ParameterizedType

泛型擦除并不是说所有的泛型信息都彻底消失了。准确来说,对象实例本身不会保留泛型信息,但是类、字段、方法以及继承关系中的泛型声明会保存在class文件的元数据中,可以通过反射读取

例如一个类实现了带泛型的接口:

1
2
public class UserService implements Service<User> {
}

此时就可以通过getGenericInterfaces方法获取到接口上的泛型:

1
2
3
4
5
6
7
Type[] interfaces = UserService.class.getGenericInterfaces();
ParameterizedType type = (ParameterizedType) interfaces[0];
Type[] types = type.getActualTypeArguments();
System.out.println(types[0]);

输出结果:
class com.epsda.User

同理,字段上声明的泛型也可以通过Field中的getGenericType方法获取:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public class Test {
    private List<User> users;

    public static void main(String[] args) throws Exception {
        Field field = Test.class.getDeclaredField("users");
        ParameterizedType type = (ParameterizedType) field.getGenericType();
        System.out.println(type.getActualTypeArguments()[0]);
    }
}

输出结果:
class com.epsda.User

其中,ParameterizedType表示带有泛型参数的类型,例如List<User>,通过getActualTypeArguments方法可以获取到<>中的实际类型

使用TypeReference/TypeToken

这是框架中最经典的解决方案。例如使用Jackson反序列化List<User>时,如果只传List.class,Jackson在运行时并不知道元素是User,最后只能得到元素为LinkedHashMap的集合。所以Jackson提供了TypeReference:

1
List<User> users = objectMapper.readValue(json, new TypeReference<List<User>>() {});

需要注意,new TypeReference<List<User>>() {}最后的{}不能省略,因为它实际上是创建了一个匿名子类,本质相当于:

1
2
class MyTypeReference extends TypeReference<List<User>> {
}

此时List<User>被写在了父类的泛型声明里,根据前面的结论,这部分信息会保存在class文件的元数据中,所以TypeReference内部通过getGenericSuperclass方法就可以拿到完整的List<User>类型,简化后的原理如下:

1
2
3
4
5
6
7
8
9
public abstract class TypeReference<T> {
    protected final Type type;

    protected TypeReference() {
        // getClass()获取到的是匿名子类,其父类就是TypeReference<List<User>>
        ParameterizedType superClass = (ParameterizedType) getClass().getGenericSuperclass();
        type = superClass.getActualTypeArguments()[0];
    }
}

这种「把泛型参数放到父类泛型声明中,再通过反射读取」的技巧称为Super Type Token,很多框架都采用了这种方式:

  1. Jackson:TypeReference<List<User>>
  2. Gson/Guava:TypeToken<List<User>>
  3. Spring:ParameterizedTypeReference<List<User>>

Spring中的ParameterizedTypeReference

在Spring中发送HTTP请求并接收带泛型的响应时就需要用到ParameterizedTypeReference,例如使用RestTemplate:

1
2
3
4
5
6
ResponseEntity<List<User>> response = restTemplate.exchange(
        url,
        HttpMethod.GET,
        null,
        new ParameterizedTypeReference<List<User>>() {}
);

与Jackson同理,如果这里传的是List.class,Spring并不知道List中的元素需要转换成User,最终得到的元素类型就是LinkedHashMap

WebClient中的用法也类似:

1
2
3
4
5
6
ParameterizedTypeReference<List<User>> type = new ParameterizedTypeReference<List<User>>() {};

webClient.get()
        .uri(url)
        .retrieve()
        .bodyToMono(type);

在泛型类中保存Class<T>

如果是泛型类需要知道T的具体类型,可以在构造方法中传入Class<T>并保存为成员,例如:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
public class BaseService<T> {
    private final Class<T> clazz;

    public BaseService(Class<T> clazz) {
        this.clazz = clazz;
    }

    public T create() throws Exception {
        return clazz.getDeclaredConstructor().newInstance();
    }
}
1
2
3
4
5
public class UserService extends BaseService<User> {
    public UserService() {
        super(User.class);
    }
}

这种方式虽然需要多写一个参数,但是非常稳定,不依赖继承结构

通过继承固定泛型

如果不想手动传Class<T>,可以让子类在继承时指定具体类型,再在父类中通过getGenericSuperclass方法读取,例如:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
public abstract class BaseService<T> {
    protected final Class<T> clazz;

    @SuppressWarnings("unchecked")
    public BaseService() {
        // getClass()获取到的是实际创建对象的子类
        ParameterizedType type = (ParameterizedType) getClass().getGenericSuperclass();
        clazz = (Class<T>) type.getActualTypeArguments()[0];
    }
}
1
2
public class UserService extends BaseService<User> {
}
1
2
3
4
5
6
7
8
9
public class Test {
    public static void main(String[] args) {
        UserService userService = new UserService();
        System.out.println(userService.clazz);
    }
}

输出结果:
class com.epsda.User

这种方式在DAO、Repository、ORM框架以及通用Service中比较常见,但是存在下面的问题:

  1. 子类必须在继承时指定具体类型,如果直接new一个泛型类对象,例如new ArrayList<User>(),此时没有子类,getGenericSuperclass返回的不是ParameterizedType,强制转换就会抛出ClassCastException
  2. 如果继承层次中间还有一层泛型类,例如下面的代码,此时MiddleService中的T是一个TypeVariable而不是具体类型,需要逐层解析才能拿到User

    1
    2
    3
    4
    5
    class BaseService<T> {}
    
    class MiddleService<T> extends BaseService<T> {}
    
    class UserService extends MiddleService<User> {}
    

泛型擦除导致的常见限制

不能使用new T()

例如下面的代码是不被允许的:

1
2
3
4
5
public class Box<T> {
    public T create() {
        return new T(); // 编译报错
    }
}

一方面编译器不知道T有没有无参构造方法,另一方面经过擦除后,这段代码相当于new Object(),显然和原本的意图完全不同。正确的做法是传入Class<T>,通过反射创建对象:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
public class Box<T> {
    private final Class<T> clazz;

    public Box(Class<T> clazz) {
        this.clazz = clazz;
    }

    public T create() throws Exception {
        return clazz.getDeclaredConstructor().newInstance();
    }
}

// 调用
Box<User> box = new Box<>(User.class);
User user = box.create();

不能使用instanceof T

同样因为擦除,运行时已经不知道T是什么类型,所以下面的代码也是不被允许的:

1
if (obj instanceof T) {} // 编译报错

此时可以使用Class中的isInstance方法代替:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
public class Box<T> {
    private final Class<T> clazz;

    public Box(Class<T> clazz) {
        this.clazz = clazz;
    }

    public boolean check(Object obj) {
        return clazz.isInstance(obj);
    }
}

不能创建泛型数组

在Java中的泛型中提到不能使用new T[5]创建数组,并且(T[]) new Object[5]虽然可以通过编译,但本质类型仍然是Object[],转换为具体类型的数组时会抛出ClassCastException。根本原因是数组在运行时必须知道自己的元素类型,例如String[]在运行时知道自己只能存String,而T[]经过擦除后无法确定T是什么

如果需要真正创建指定类型的数组,可以使用Array类中的newInstance方法:

1
2
3
4
5
6
7
@SuppressWarnings("unchecked")
public static <T> T[] createArray(Class<T> clazz, int length) {
    return (T[]) Array.newInstance(clazz, length);
}

// 调用
String[] arr = createArray(String.class, 10);

此时创建出来的数组本身就是String[]类型,所以不会出现ClassCastException