以前就了解過Java泛型的實作是不完整的，最近在做一些代碼重構的時候遇到一些Java泛型類型擦除的問題，簡單的來說，Java泛型中所指定的類型在編譯時會将其去除，是以

List<String>

和

List

在編譯成位元組碼的時候實際上是一樣的。是以java泛型隻能做到編譯期檢查的功能，運作期間就不能保證類型安全。我最近遇到的一個問題如下:

假設有兩個bean類

/** Test. */
@Data
@NoArgsConstructor
@AllArgsConstructor
public static class Foo {
    public String name;
}

/** Test. */
@Data
@NoArgsConstructor
@AllArgsConstructor
public static class Dummy {
    public String name;
}

以及另一個對象

@NoArgsConstructor
@AllArgsConstructor
@Data
public static class Spec<T> {

    public String spec;

    public T deserializeTo() throws JsonProcessingException {
        var mapper = new ObjectMapper();
        return (T) mapper.readValue(spec, Foo.class);
    }
}

可以看到

Spec

對象中儲存了以上兩種類型json序列化後的字元串，并提供了方法将string spec 反序列化成相應的類型，比較理想的方式是在反序列化的方法中能夠擷取到參數類型 T 的實際類型，理論上運作時Spec類型是确定了，是以T也應該是确定的，但是因為類型擦除，是以實際上擷取不到他的類型。

按照以下嘗試通過

((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()

擷取泛型類型，經過測試是擷取不到的

@Test
    public void test() throws JsonProcessingException {
        var foo = new Foo("foo");
        var spec = new Spec<Foo>(mapper.writeValueAsString(foo));
        var deserialized = spec.deserializeTo();
        Assertions.assertTrue(deserialized instanceof Foo);
    }

    @NoArgsConstructor
    @AllArgsConstructor
    @Data
    public static class Spec<T> {

        public String spec;

        private Class<T> getSpecClass() {
            return (Class<T>)
                    ((ParameterizedType) getClass().getGenericSuperclass())
                            .getActualTypeArguments()[0];
        }

        public T deserializeTo() throws JsonProcessingException {
            var mapper = new ObjectMapper();
            System.out.println(spec);
            return (T) mapper.readValue(spec, getSpecClass());
        }
    }

會有以下的錯誤

java.lang.ClassCastException: class java.lang.Class cannot be cast to class java.lang.reflect.ParameterizedType (java.lang.Class and java.lang.reflect.ParameterizedType are in module java.base of loader 'bootstrap')

有兩種辦法來繞過這個問題

第一種比較簡單，就是在建立spec對象時，直接把類型的class傳進來，這樣就可以直接使用。

第二種是建立spec的子類中使用這個方法就可以擷取泛型的類型

@Data
public abstract static class AbstractSpec<T> {

    public String spec;

    public AbstractSpec(String spec) {
        this.spec = spec;
    }

    private Class<T> getSpecClass() {
        return (Class<T>)
                ((ParameterizedType) getClass().getGenericSuperclass())
                        .getActualTypeArguments()[0];
    }

    public T deserializeTo() throws JsonProcessingException {
        var mapper = new ObjectMapper();
        System.out.println(spec);
        return (T) mapper.readValue(spec, getSpecClass());
    }
}

public static class Spec extends AbstractSpec<Foo> {
    public Spec(String spec) {
        super(spec);
    }
}

@Test
public void test() throws JsonProcessingException {
    var foo = new Foo("foo");
    var spec = new Spec(mapper.writeValueAsString(foo));
    var deserialized = spec.deserializeTo();
    Assertions.assertTrue(deserialized instanceof Foo);
}

這裡spec類就可以順利的被反序列化。

這個和最開始失敗的case的差别就是新增了一個子類，主要的差别是getGenericSuperclass的傳回值有差異，非子類的情況下，擷取到的是Object。

是以理論上子類Spec的類型資訊中，實際上是儲存了父類中的類型參數資訊的，也就是例子中的Foo. 按照 https://stackoverflow.com/questions/42874197/getgenericsuperclass-in-java-how-does-it-work 的方式，可以檢視到Spec類的位元組碼中有相應的類型資訊。

$ javap -verbose ./org/apache/flink/kubernetes/operator/controller/GenericTest\$Spec.class | grep Signature
  #15 = Utf8               Signature
        Start  Length  Slot  Name   Signature
Signature: #19                          // Lorg/apache/flink/kubernetes/operator/controller/GenericTest$AbstractSpec<Lorg/apache/flink/kubernetes/operator/controller/GenericTest$Foo;>;

參考

https://www.cnblogs.com/wuqinglong/p/9456193.html

https://stackoverflow.com/questions/3403909/get-generic-type-of-class-at-runtime

https://stackoverflow.com/questions/6624113/get-type-name-for-generic-parameter-of-generic-class

https://github.com/jhalterman/typetools

本文來自部落格園，作者：Aitozi，轉載請注明原文連結：https://www.cnblogs.com/Aitozi/p/16280684.html

Java泛型類型擦除問題

參考