Java 泛型详解

1. 引言

Java泛型（Generics）是一种类型安全机制，允许我们在编写代码时使用参数化类型来提升程序的灵活性和安全性。本文旨在深入探讨Java泛型的相关概念、实现机制以及最佳实践。

2. 泛型的基本概念

2.1 不变性与协变逆变

• 不变性（Invariance）： 默认情况下，List<Integer>不是List<Number>的子类。这意味着不能将一个类型安全地赋值给另一个。

• 协变（Covariance）： 数组可以是协变的，即Integer[]可以看作Object[]的子类型。然而，由于泛型的擦除机制，List<Integer>不是List<Number>的子类。

• 逆变（Contravariance）： 反之，当需要将元素写入集合时，使用逆变性，如? super T表示可以接受T或其父类型作为参数。

2.2 PECS原则

PECS原则是泛型编程中解决协变与逆变问题的核心策略：

• P（Producer）Extends：当从列表中读取数据时使用extends，确保安全地遍历任何子类。
• C（Consumer）Super：向列表添加数据时使用susper T，允许将T或其父类型放入集合。

3. 泛型的实现机制

3.1 类型擦除

Java泛型是通过编译器进行“类型擦除”来实现的。即在运行时所有的泛型信息都会被移除（除了元数据），如List<String>在运行时会被视为List<Object>。

public static 
<T> void print(List<T> list) { 
    for (T t : list) {
        System.out.println(t);
    }
}

编译后，实际的代码为：

public static void print(List list) { 
    for (Object o : list) {
        System.out.println(o);
    }
}

3.2 反射与通配符类型信息

尽管运行时泛型参数被擦除，但通过反射仍然可以获取到类的泛型签名：

Method method = MyClass.class.getMethod("print", List.class); 
Type genericType = method.getGenericReturnType();
System.out.println(genericType);

4. 泛型的最佳实践与常见误区

4.1 类型参数的选择

• 尽量使用泛型来提升代码的复用性和安全性，但也要避免过度使用。

4.2 常见错误

4.2.1 使用基本类型作为泛型参数

// 错误
List
<int> list;

// 正确
List
<Integer> list;

4.2.2 创建泛型数组

// 错误
List
<String>[] array = new List<String>[10];

// 推荐
List<List<String>> list = new ArrayList<>();

4.3 反射与类型安全

使用反射时，应当尽量避免直接操作未绑定的泛型实例，以免破坏类型安全性。

5. 泛型在框架中的应用

• MyBatis：通过定义带有泛型参数的Mapper接口来实现对实体对象的操作。

public interface BaseMapper
<T> {
    T selectById(Long id);
    void insert(T entity);
}

6. 结论

Java泛型虽然在编译时提供了类型安全检查，但在运行时通过擦除机制移除了大部分泛型信息。因此，在使用泛型编程过程中需要注意类型擦除带来的限制和问题，并灵活应用PECS原则来解决协变与逆变的问题。

8.2 常见的获取方式

方式 1：解析字段或方法的泛型签名

如果泛型是定义在类的字段或方法的声明处，我们可以直接通过反射获取。

public class DataHolder {
    private List
<Integer> numbers;
    public Map<String, User> getUserMap() { return null; }
}

// 解析字段的泛型
Field field = DataHolder.class.getDeclaredField("numbers");
Type genericType = field.getGenericType();
if (genericType instanceof ParameterizedType) {
    ParameterizedType pType = (ParameterizedType) genericType;
    // 获取实际的类型参数: [class java.lang.Integer]
    Type[] actualTypes = pType.getActualTypeArguments(); 
}

// 解析方法返回值的泛型
Method method = DataHolder.class.getMethod("getUserMap");
Type returnType = method.getGenericReturnType();
if (returnType instanceof ParameterizedType) {
    ParameterizedType pType = (ParameterizedType) returnType;
    // 获取实际的类型参数: [String, User]
    Type[] actualTypes = pType.getActualTypeArguments(); 
}

方式 2：解析父类 / 接口的泛型参数

当一个子类继承了带有具体类型的泛型父类时，我们可以通过反射获取这个具体的类型。

public abstract class GenericType
<T> {
    protected final Class
<T> type;

    public GenericType() {
        Type superClass = getClass().getGenericSuperclass();
        ParameterizedType pt = (ParameterizedType) superClass;
        this.type = (Class
<T>) pt.getActualTypeArguments()[0];
    }

    public Class
<T> getType() { return type; }
}

// 子类指定具体类型
public class UserType extends GenericType
<User> {}

// 使用
UserType userType = new UserType();
System.out.println(userType.getType()); // 输出: class com.example.User

方式 3：TypeToken 模式

这是最灵活、最常用的方式，被 Gson、Guava 等框架广泛使用。

import com.google.gson.reflect.TypeToken;

// 注意：后面的 {} 很重要，它创建了一个匿名子类
Type type = new TypeToken<List<Map<String, Integer>>>() {}.getType();

System.out.println(type); 
// 输出: java.util.List<java.util.Map<java.lang.String, java.lang.Integer>>

通过这种方式，我们可以捕获任意复杂的嵌套泛型类型，完美解决了 JSON 反序列化时的泛型擦除问题。

8.3 核心反射 API 详解

要解析泛型类型，我们需要用到 java.lang.reflect 包下的 Type 体系。Type 是 Java 中所有类型的公共超接口，它有多种具体实现，分别对应不同的类型场景。

8.3.1 Type 体系总览

8.3.2 关键 API 详解

ParameterizedType（最常用）

这是我们处理泛型时最常打交道的接口，它代表带类型参数的泛型类型，例如 List<String>。

它的核心方法：

• getActualTypeArguments()：获取泛型的实际参数列表。
  • 对于 List<String> 返回 [Class<String>]
  • 对于 Map<String, Integer> 返回 [Class<String>, Class<Integer>]

// 示例：解析 List
<String>
Field field = DataHolder.class.getDeclaredField("numbers");
Type genericType = field.getGenericType();

if (genericType instanceof ParameterizedType) {
    ParameterizedType pType = (ParameterizedType) genericType;

    // 获取泛型参数: [class java.lang.Integer]
    Type[] args = pType.getActualTypeArguments(); 
    System.out.println(args[0]); // class java.lang.Integer

    // 获取原始类型: interface java.util.List
    System.out.println(pType.getRawType()); 
}

WildcardType（通配符类型）

代表通配符类型，例如 ? extends Number 或 ? super Integer。

它的核心方法：

• getUpperBounds()：获取上界，默认是 Object。
  • 对于 ? extends Number，上界是 Number
• getLowerBounds()：获取下界，默认为空数组。
  • 对于 ? super Integer，下界是 Integer

// 示例：解析 List<? extends Number>
Field field = Test.class.getDeclaredField("numbers");
ParameterizedType pType = (ParameterizedType) field.getGenericType();

WildcardType wildcard = (WildcardType) pType.getActualTypeArguments()[0];

// 上界: [class java.lang.Number]
System.out.println(Arrays.toString(wildcard.getUpperBounds()));
// 下界: []
System.out.println(Arrays.toString(wildcard.getLowerBounds()));

GenericArrayType（泛型数组）

代表元素类型是泛型的数组，例如 List<String>[] 或者 T[]。

它的核心方法：

• getGenericComponentType()：获取数组的元素类型。
  • 对于 List<String>[]，返回的是 ParameterizedType(List<String>)

TypeVariable（类型变量）

代表泛型定义中的占位符，比如 Box<T> 中的 T。

它的核心方法：

• getName()：获取变量名，例如 "T"
• getBounds()：获取变量的上界
• getGenericDeclaration()：获取声明这个变量的类 / 方法

8.3.4 获取 Type 的入口方法

我们通过以下反射方法来获取到 Type 对象：

8.3.4 实战：递归解析任意复杂泛型

对于嵌套复杂的泛型，我们通常需要使用递归来解析。

public static void parseType(Type type, int indent) {
    String prefix = "  ".repeat(indent);

    if (type instanceof Class) {
        System.out.println(prefix + "原始类型: " + ((Class<?>) type).getName());
    } 
    else if (type instanceof ParameterizedType) {
        ParameterizedType pType = (ParameterizedType) type;
        System.out.println(prefix + "参数化类型: " + pType.getRawType());

        // 递归解析每一个泛型参数
        for (Type arg : pType.getActualTypeArguments()) {
            parseType(arg, indent + 1);
        }
    }
    else if (type instanceof WildcardType) {
        WildcardType wType = (WildcardType) type;
        System.out.println(prefix + "通配符: ?");
        for (Type upper : wType.getUpperBounds()) {
            System.out.println(prefix + "  上界: " + upper);
        }
        for (Type lower : wType.getLowerBounds()) {
            System.out.println(prefix + "  下界: " + lower);
        }
    }
    else if (type instanceof GenericArrayType) {
        GenericArrayType gType = (GenericArrayType) type;
        System.out.println(prefix + "泛型数组:");
        parseType(gType.getGenericComponentType(), indent + 1);
    }
}

8.4 哪些情况无法获取？

以下情况泛型信息会被完全擦除，无法恢复：

• 局部变量 ：方法内部的 List<String> list = new ArrayList<>();
• 普通实例对象 ：List<String> list = new ArrayList<>();，通过对象本身无法获取泛型
• 泛型方法的类型参数 ：<T> T test()，运行时无法知道 T 是什么

9. 总结

Java 泛型不仅是一种语法糖，而是一套精心设计的类型系统，在向后兼容的前提下实现了编译期的类型检查功能。

• 核心价值 ：通过编译器类型检查来减少显式类型转换。
• 实现原理 ：类型擦除 + 桥接方法 + Signature 属性。
• 灵活性 ：利用通配符实现协变与逆变，遵循 PECS 原则设计 API。
• 限制根源 ：所有的限制都源于类型擦除机制。

掌握这些知识不仅能帮助你避免日常开发中的泛型问题，还能让你更好地理解像 Spring 和 MyBatis 这样的框架源码中复杂的泛型签名。

> 🔗 相关阅读：函数式编程