Java · 泛型与类型擦除

场景 1 · 通用响应包装 Result<T>: 泛型 API 设计

网关统一响应体, 泛型让调用方拿到的是具体类型而不是 Object — 类型链一旦断裂, 全下游退回强转时代:

// 统一响应: data 的类型沿调用链传播, Feign/接口代理全靠这条类型链
public class Result<T> {
    private final int code; private final String msg; private final T data;
    private Result(int code, String msg, T data) { this.code = code; this.msg = msg; this.data = data; }
    public static <T> Result<T> ok(T data)            { return new Result<>(0, "ok", data); }
    public static <T> Result<T> fail(int c, String m) { return new Result<>(c, m, null); }
    public T data() { if (code != 0) throw new BizException(code, msg); return data; }
}
Result<User> r = userClient.get(uid);   // 泛型沿代理链自动传播
r.data().getCity();                     // data() 即 User, 无强转; 非 0 自动抛

偷懒返回 Result<Object> 的接口, 就是团队里"类型黑洞"的起点。

场景 2 · 类型安全的异构容器: Class<T> 做 key

请求上下文要装各种类型的属性, Map<String, Object> 取出来全靠强转 — Class token 让 key 自带类型:

// 异构容器: key 本身就是类型令牌, 存取类型对得上编译器就满意
public class Attributes {
    private final Map<Class<?>, Object> map = new HashMap<>();
    public <T> void put(Class<T> type, T value) { map.put(type, type.cast(value)); }
    public <T> T get(Class<T> type)             { return type.cast(map.get(type)); }
}
Attributes ctx = new Attributes();
ctx.put(String.class,  "trace-9527");   // 取出来一定是 String
ctx.put(Integer.class, 42);              // type.cast 双保险: 放错立刻 CCE
String tid = ctx.get(String.class);

场景 3 · 超类型令牌: 运行时拿到 List<User>"不存在的泛型"

Jackson 的 TypeReference 人人会用, 原理是"匿名子类把泛型签名冻结进字节码" — 20 行自己造一个:

// Class<T> 表达不了 List<User>.class (被擦除); 匿名子类携带完整 Signature
List<User> users = json.readValue(body, new TypeReference<List<User>>() {});
// 原理: 匿名类的 getGenericSuperclass() 返回 ParameterizedType, 可还原 List<User>

// 造一个 (Guava TypeToken / Spring ParameterizedTypeReference 同理)
public abstract class TypeRef<T> {
    final Type type = ((ParameterizedType) getClass()
            .getGenericSuperclass()).getActualTypeArguments()[0];
}
TypeRef<Map<String, List<User>>> ref = new TypeRef<>() {};  // {} 不可省: 子类才带签名

线上反序列化成 LinkedHashMap 而不是目标类型, 十有八九是走了擦除后的 raw 通道 — 用令牌补救。

场景 4 · 自限定 Builder: 链式调用不丢类型

继承链上的 Builder, 父类方法返回父类型, 链式到子类方法直接编译错 — 自限定让每层返回"自己":

// <T extends Builder<T>>: T 被"钉"在子类上, 返回值永远是子类型 this
public abstract class Builder<T extends Builder<T>> {
    protected String id;
    @SuppressWarnings("unchecked")
    public T id(String id) { this.id = id; return (T) this; }
}
public final class OrderBuilder extends Builder<OrderBuilder> {
    private BigDecimal amount;
    public OrderBuilder amount(BigDecimal a) { this.amount = a; return this; }
}
// new OrderBuilder().id("A1").amount(TEN).build() — id() 后仍是 OrderBuilder
// 无自限定: id() 返回 Builder, 接 amount() 直接编译错; Lombok @SuperBuilder 同原理

场景 5 · 泛型 DAO 基类: 子类三行接入 CRUD

十个 repository 抄十遍 find/all — 泛型基类收拢公共逻辑, Spring Data JPA 的思路一脉相承:

// 泛型基类收拢 CRUD: 子类只声明实体与主键类型
public abstract class Dao<E, ID> {
    private final Class<E> entityClass;      // 擦除下运行时类型标准解: 构造注入 token
    protected Dao(Class<E> entityClass) { this.entityClass = entityClass; }
    public E find(ID id) { return em.find(entityClass, id); }
    public List<E> all() {
        return em.createQuery("FROM " + entityClass.getSimpleName(), entityClass)
                  .getResultList();           // 泛型让查询结果免强转
    }
}
public class UserDao extends Dao<User, Long> { public UserDao() { super(User.class); } }

场景 6 · Function<T,R> 组合: andThen/compose 拼管道

校验/转换逻辑散在五个 if 里 — 函数组合让每段独立单测, 组装处一眼看全流程:

// andThen 正向接管, compose 反向预置 — 类型像水管接头, 两端必须对上
Function<Order, User>   buyer  = Order::user;         // Order → User
Function<User, String>  city   = User::city;          // User → String
Function<Order, String> toCity = buyer.andThen(city); // Order → User → String

// 中间件链: 每段独立单测, 组装即部署 — 接头对不上编译期就红
Function<Req, Req> pipeline = trim.andThen(validate).andThen(fillDefaults);
Req processed = pipeline.apply(rawReq);

场景 7 · PECS 通用 copy: 一个签名通吃所有容器组合

要写一个能把 List<String> 拷进 List<Object> 的方法, 参数怎么声明 — JDK 的答案:

// 读用 extends, 写用 super — T 只在方法体内流动, 两端各守规矩
public static <T> void copy(List<? super T> dst, List<? extends T> src) {
    for (T t : src) dst.add(t);       // src 只读(生产 T), dst 只写(消费 T)
}
List<Object> bucket = new ArrayList<>();
List<String> names  = List.of("a", "b");
copy(bucket, names);  // List<Object> 是 String 的 super — 合法
copy(names, names);   // String 也是自己的 super — 惊喜但正确

若参数写成两个 List<T>, 第一行调用直接编译不过 — 这就是 API 灵活性的分水岭。

场景 8 · <T extends Comparable<? super T>>: 全 JDK 最讲究的边界

写通用 max 时边界怎么画, 直接决定哪些类型能用 — 逐词拆开这个教科书签名:

// T 可比较; ? super T 放行"父类实现的 Comparable" — 子类白捡比较能力
public static <T extends Comparable<? super T>> T max(List<? extends T> list) {
    T best = null;
    for (T t : list)
        if (best == null || t.compareTo(best) > 0) best = t;
    return best;
}
// 写死 <T extends Comparable<T>>: 父类实现比较器的子类直接编译不过
// 参数 List<? extends T> 同理: 让 List<Sub> 也能喂进来

场景 9 · 泛型异常的边界: catch 不能泛型, 函数式走私

线上 lambda 里层层 try/catch 包 IOException, 噪音淹没业务 — 受检异常的边界要绕过去:

// catch (T e) 不可能: 擦除后等同 catch(Exception), 泛型约束是幻觉
// 正解: 函数式包装把受检异常"走私"出去
@FunctionalInterface
interface ThrowingSupplier<T> { T get() throws Throwable; }

static <T> T unchecked(ThrowingSupplier<T> sup) {
    try { return sup.get(); }
    catch (Throwable e) { throw new RuntimeException(e); }  // 保留完整原始栈
}
User u = unchecked(() -> json.readValue(body, User.class));  // 一行搞定

场景 10 · default + 泛型: 零依赖的流式断言 DSL

测试断言库不想引依赖 — 接口 default 方法 + 泛型 static 工厂, 30 行拼出可组合的匹配器:

// 组合子在 default 方法上自由生长, 扩展零侵入
public interface Matcher<T> {
    boolean test(T value);
    default Matcher<T> and(Matcher<T> other) {
        return v -> test(v) && other.test(v);    // 组合而非继承
    }
    static <T> Matcher<T> eq(T target) { return v -> Objects.equals(v, target); }
    static <T> Matcher<T> nonNull()    { return Objects::nonNull; }
}
Matcher<Order> rule = Matcher.<Order>nonNull().and(Matcher.eq(paidOrder));

末行的 <Order> 类型见证: 链式起点没有目标类型, 必须显式帮推断一把。