Java 泛型与反射深度实战

// 泛型只存在于编译期
List<String> strs = new ArrayList<>();
List<Integer> ints = new ArrayList<>();
System.out.println(strs.getClass() == ints.getClass()); // true，都是 ArrayList

// 运行时无法判断列表元素类型
// if (list instanceof List<String>) —— 编译错误！

public static <T> T identity(T value) {
    return value;
}
// 擦除后等价于：
public static Object identity(Object value) {
    return value;
}

class Base {
    Object pick(Object o) { return o; }
}
class Sub extends Base {
    // 这里用了泛型，T 擦除成 Object，本应和父类签名一致
    @Override
    public String pick(Object o) {   // 实际覆盖的是父类方法
        return String.valueOf(o);
    }
    // 编译器自动生成桥方法：
    // public Object pick(Object o) { return this.pick(o); }  // 桥方法返回类型更宽
}

public <T> T create(Class<T> clazz) throws Exception {
    return clazz.getDeclaredConstructor().newInstance();  // 通过 Class 反射创建
}

// Producer：集合提供元素给你读 → 用 extends
public static void copy(List<? extends Number> src,
                        List<? super Number> dest) {
    for (Number n : src) {   // src 是 Producer，读为 Number
        dest.add(n);         // dest 是 Consumer，写入 Number
    }
}

// 数组协变：运行时才报错
Object[] objs = new String[10];
objs[0] = 42;  // ArrayStoreException（运行时）

// 泛型不协变：编译期就拦截
// List<Object> list = new ArrayList<String>();  // 编译错误！
// 但要 List<? extends Object> list = ...;       // 合法

// 经典技巧：保留父类泛型参数
class StringListHolder extends ArrayList<String> {}

ParameterizedType type = (ParameterizedType)
        StringListHolder.class.getGenericSuperclass();
Type arg = type.getActualTypeArguments()[0];
System.out.println(arg);  // class java.lang.String

// 泛型方法取回类型变量
Method m = MyClass.class.getMethod("build");
for (TypeVariable<?> tv : m.getTypeParameters()) {
    System.out.println(tv.getName());          // T
    System.out.println(Arrays.toString(tv.getBounds())); // class java.lang.Object
}

Class<?> clazz = Class.forName("com.example.User");
Class<?> clazz2 = User.class;
Class<?> clazz3 = userInstance.getClass();

Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(true);          // 突破 private（JDK 高版本需留意模块限制）
nameField.set(user, "新名字");

Method getter = clazz.getDeclaredMethod("getName");
Object result = getter.invoke(user);

// JDK Proxy：必须面向接口
interface Greeter { String greet(String name); }

Greeter proxy = (Greeter) Proxy.newProxyInstance(
        Greeter.class.getClassLoader(),
        new Class<?>[]{Greeter.class},
        (p, method, args) -> {
            System.out.println("[before] 调用 " + method.getName());
            Object result = method.invoke(new GreeterImpl(), args);
            System.out.println("[after] 返回 " + result);
            return result;
        });

// Spring 中 CGLIB 是默认策略（Spring Boot 默认 enableCglibProxy）
// @EnableAspectJAutoProxy 或 Spring Boot 自动配置时
// 只要目标类不是 final，无接口也能被代理

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)   // 运行时可见，反射可读
@Documented
public @interface Audited {
    String value() default "";
    boolean sensitive() default false;
}

// lombok、mapstruct、AutoService 等都依赖 APT
@SupportedAnnotationTypes("com.example.Audited")
public class AuditedProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations,
                           RoundEnvironment roundEnv) {
        for (Element e : roundEnv.getElementsAnnotatedWith(Audited.class)) {
            // 在编译期生成新的源文件/辅助类
            JavaFileObject file = processingEnv.getFiler()
                .createSourceFile("AuditHelper_Gen");
            // ...
        }
        return true;
    }
}

# 1. 缓存 Method/Field，不要每次 getDeclaredXxx
# 2. 用 MethodHandle（invokeExact）替代反射 invoke，性能接近直接调用

// MethodHandle：更贴近 JVM 底层，可被 JIT 优化
MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodHandle handle = lookup.findVirtual(User.class, "getName",
        MethodType.methodType(String.class));
String name = (String) handle.invokeExact(user);