Java基础注解与反射之框架背后的魔法

// 你写的
@Override
public String toString() { ... }
// @Override 本身什么都不做
// 是编译器读取到它后，帮你检查父类是否有这个方法

// 编译期注解（给编译器看的）
@Override          // 检查是否正确重写了父类方法
@Deprecated        // 标记已过时，IDE 会划删除线提醒
@SuppressWarnings("unchecked")  // 抑制编译器警告
// 函数式接口标记
@FunctionalInterface  // 检查接口是否只有一个抽象方法
// Java 8+
@Deprecated(since = "9", forRemoval = true)  // 标记将在未来版本移除

// @Target：注解可以贴在哪里
@Target(ElementType.METHOD)           // 只能贴在方法上
@Target({ElementType.TYPE, ElementType.METHOD})  // 类或方法
// 常用值：TYPE(类/接口), METHOD, FIELD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE
// @Retention：注解保留到什么阶段
@Retention(RetentionPolicy.SOURCE)    // 只在源码中，编译后丢弃（如 @Override）
@Retention(RetentionPolicy.CLASS)     // 保留到 class 文件，但运行时不可读（默认）
@Retention(RetentionPolicy.RUNTIME)   // 保留到运行时，可以通过反射读取（框架都用这个）
// @Documented：是否出现在 Javadoc 中
@Documented
// @Inherited：子类是否继承父类的注解
@Inherited

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogExecution {
    String value() default "";       // 注解属性，有默认值
    boolean logArgs() default true;  // 是否记录参数
}
// 使用
public class UserService {
    @LogExecution(value = "查询用户", logArgs = false)
    public User getUser(String id) {
        return db.findById(id);
    }
    @LogExecution("删除用户")  // 只有一个属性名为 value 时，可以省略 "value ="
    public void deleteUser(String id) {
        db.delete(id);
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ApiConfig {
    String url();
    int timeout() default 3000;
    String[] headers() default {};          // 数组类型
    RequestMethod method() default RequestMethod.GET;  // 枚举类型
}
@ApiConfig(
    url = "/api/users",
    timeout = 5000,
    headers = {"Content-Type: application/json", "Accept: */*"},
    method = RequestMethod.POST
)
public class UserApi { ... }

// 你写的
public @interface LogExecution {
    String value() default "";
}
// 编译器实际生成的
public interface LogExecution extends java.lang.annotation.Annotation {
    String value();  // 接口只能有方法，不能有实例字段，所以属性只能用方法表达
}

@LogExecution("查询用户")     // value() 返回 "查询用户"
@LogExecution                 // value() 返回 ""（默认值）

// 方式 1：Class.forName（运行时才知道类名，最常用于框架）
Class<?> clazz = Class.forName("com.example.User");
// Class<?> 表示"某个类的 Class 对象，但编译期不确定是哪个类"
// <?> 是通配符，告诉编译器"类型不确定是故意的"
// 方式 2：类名.class（编译期就确定了类型）
Class<User> clazz = User.class;
// 方式 3：对象.getClass()（从已有对象获取）
User user = new User("Alice");
Class<?> clazz = user.getClass();

// 正常写法：编译期就确定了类型
User user = new User("Alice");
String name = user.getName();
// 反射写法：运行时动态操作
// 第一步：获取 Class 对象（"我要操作 User 这个类"）
Class<?> clazz = Class.forName("com.example.User");
// 第二步：获取构造方法（"找到参数是 String 的构造方法"）
Constructor<?> constructor = clazz.getDeclaredConstructor(String.class);
// 第三步：创建对象（"用这个构造方法 new 一个对象，传入 Alice"）
Object user = constructor.newInstance("Alice");
// 等价于 new User("Alice")，但编译期不需要知道 User 类的存在
// 第四步：获取方法（"找到叫 getName 的方法"）
Method method = clazz.getMethod("getName");
// 第五步：调用方法（"在 user 对象上调用 getName()"）
String name = (String) method.invoke(user);
// 等价于 user.getName()，但返回的是 Object，需要强转

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)  // 必须是 RUNTIME，否则反射读不到
public @interface LogExecution {
    String value() default "";
    boolean logArgs() default true;
}
public class UserService {
    @LogExecution(value = "查询用户", logArgs = false)
    public User getUser(String id) {
        return db.findById(id);
    }
}

// 第一步：获取 Class 对象
Class<?> clazz = UserService.class;
// 第二步：获取方法
Method method = clazz.getMethod("getUser", String.class);
// 第三步：检查方法上有没有 @LogExecution 注解
if (method.isAnnotationPresent(LogExecution.class)) {
    // 第四步：获取注解对象
    LogExecution anno = method.getAnnotation(LogExecution.class);
    // 第五步：读取注解里的数据（调用注解的"方法"，返回你传入的值）
    String value = anno.value();       // "查询用户"
    boolean logArgs = anno.logArgs();  // false
    System.out.println("操作: " + value);
    System.out.println("记录参数: " + logArgs);
}

Class<?> clazz = Class.forName("com.example.User");
clazz.getName();          // "com.example.User"（全名，带包名）
clazz.getSimpleName();    // "User"（只有类名）
clazz.getSuperclass();    // Object.class（父类是谁）
clazz.getInterfaces();    // 实现了哪些接口

// 拿到所有字段
Field[] fields = clazz.getDeclaredFields();
for (Field f : fields) {
    System.out.println(f.getName() + " → " + f.getType().getSimpleName());
}
// 输出：
// name → String
// age → int

// 拿到所有方法
Method[] methods = clazz.getDeclaredMethods();
for (Method m : methods) {
    System.out.println(m.getName());
}
// 输出：
// getName
// setName
// getAge
// setAge

Constructor<?>[] constructors = clazz.getDeclaredConstructors();
for (Constructor<?> c : constructors) {
    System.out.println(c);
}
// 输出：
// public com.example.User()
// public com.example.User(String, int)

public class User {
    private String name;
    private int age;
    public User() { }                              // 无参构造（public）
    public User(String name, int age) {            // 有参构造（public）
        this.name = name;
        this.age = age;
    }
    private User(String name) {                    // 单参构造（private）
        this.name = name;
        this.age = 0;
    }
}

Class<?> clazz = User.class;
// 获取 public 的无参构造
Constructor<?> c1 = clazz.getConstructor();
// 获取 public 的有参构造（通过参数类型区分）
Constructor<?> c2 = clazz.getConstructor(String.class, int.class);
// 获取 private 构造方法（getConstructor 只能拿 public 的，拿不到 private）
// 需要用 getDeclaredConstructor
Constructor<?> c3 = clazz.getDeclaredConstructor(String.class);

// public 构造方法：直接 newInstance
Constructor<?> c1 = clazz.getConstructor();
Object user1 = c1.newInstance();                     // 等价于 new User()
Constructor<?> c2 = clazz.getConstructor(String.class, int.class);
Object user2 = c2.newInstance("Alice", 25);          // 等价于 new User("Alice", 25)
// private 构造方法：必须先 setAccessible(true) 打开权限
Constructor<?> c3 = clazz.getDeclaredConstructor(String.class);
c3.setAccessible(true);                              // 不写这行会抛 IllegalAccessException
Object user3 = c3.newInstance("Bob");                // 等价于 new User("Bob")

// 接上一节，用无参构造创建一个空的 User 对象
Class<?> clazz = User.class;
Object user = clazz.getConstructor().newInstance();  // new User()

// public 字段：用 getField
Field f1 = clazz.getField("publicField");
// private 字段：用 getDeclaredField
Field nameField = clazz.getDeclaredField("name");
Field ageField = clazz.getDeclaredField("age");

// private 字段必须先打开权限
nameField.setAccessible(true);
ageField.setAccessible(true);
// set(对象, 值)：等价于 user.name = "Alice"（但 private 正常写不了）
nameField.set(user, "Alice");
ageField.set(user, 25);

// get(对象)：等价于 user.name
// 注意：name 是 private 的，只有通过反射 + setAccessible(true) 才能读，直接写 user.name 编译报错
String name = (String) nameField.get(user);   // "Alice"
int age = (int) ageField.get(user);           // 25

nameField.getType();              // class java.lang.String
nameField.getType().getSimpleName();  // "String"
ageField.getType();               // int

Class<?> clazz = User.class;
Object user = clazz.getConstructor(String.class, int.class).newInstance("Alice", 25);
// public 方法：用 getMethod
Method getName = clazz.getMethod("getName");               // 无参方法
Method setName = clazz.getMethod("setName", String.class); // 有参方法，传参数类型区分重载
// private 方法：用 getDeclaredMethod
Method secret = clazz.getDeclaredMethod("secretMethod");

Method getName = clazz.getMethod("getName");
// invoke(对象)：在 user 对象上调用 getName()
// 等价于 user.getName()，返回值是 Object，需要强转
String name = (String) getName.invoke(user);   // "Alice"

Method setName = clazz.getMethod("setName", String.class);
// invoke(对象, 参数...)：在 user 对象上调用 setName("Bob")
// 等价于 user.setName("Bob")
setName.invoke(user, "Bob");

Method secret = clazz.getDeclaredMethod("secretMethod");
secret.setAccessible(true);   // 和字段一样，private 方法必须先打开权限
secret.invoke(user);           // 等价于 user.secretMethod()

// 假设 User 类有一个 static 方法：public static User create(String name)
Method create = clazz.getMethod("create", String.class);
// static 方法不属于某个对象，所以第一个参数传 null
Object newUser = create.invoke(null, "Charlie");
// 等价于 User.create("Charlie")

public class Animal {
    public String species;        // public 字段
    private int lifespan;         // private 字段
    public void eat() { }        // public 方法
}
public class Dog extends Animal {
    public String breed;          // Dog 自己的 public 字段
    private String nickname;      // Dog 自己的 private 字段
    public void bark() { }       // Dog 自己的 public 方法
}

Class<?> clazz = Dog.class;
// getFields()：所有 public，包括从父类继承的
clazz.getFields();
// → [breed, species]
//    Dog 自己的 + 从 Animal 继承的 public 字段
//    看不到 private 的 nickname 和 lifespan
// getDeclaredFields()：Dog 自己声明的所有字段，不管 public 还是 private
clazz.getDeclaredFields();
// → [breed, nickname]
//    只有 Dog 自己的，看不到父类 Animal 的任何字段
//    但 private 的 nickname 也能拿到

public class LogProcessor {
    public static void processLogs(Object target) throws Exception {
        Class<?> clazz = target.getClass();
        for (Method method : clazz.getDeclaredMethods()) {
            // 检查方法上是否有 @LogExecution 注解
            if (method.isAnnotationPresent(LogExecution.class)) {
                LogExecution log = method.getAnnotation(LogExecution.class);
                System.out.println("[LOG] 发现注解方法：" + method.getName());
                System.out.println("[LOG] 描述：" + log.value());
                System.out.println("[LOG] 记录参数：" + log.logArgs());
            }
        }
    }
}
// 使用
LogProcessor.processLogs(new UserService());
// [LOG] 发现注解方法：getUser
// [LOG] 描述：查询用户
// [LOG] 记录参数：false
// [LOG] 发现注解方法：deleteUser
// [LOG] 描述：删除用户
// [LOG] 记录参数：true

public class UserController {
    // 自己创建依赖，写死了，想换实现就要改代码
    private UserService userService = new UserService();
}

public class UserController {
    // 只声明"我需要一个 UserService"，不自己 new
    @Autowired
    private UserService userService;
    // Spring 在运行时通过反射找到这个字段，帮你创建 UserService 并赋值进去
}

Spring 启动时扫描所有类
  → 发现 UserController 有一个字段标了 @Autowired
  → 通过反射读取注解：field.isAnnotationPresent(Autowired.class)
  → 通过反射打开权限：field.setAccessible(true)
  → 通过反射注入对象：field.set(controller, new UserService())

// 定义注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyInject { }
// 服务类
public class UserRepository {
    public String find(String id) { return "User:" + id; }
}
public class UserService {
    @MyInject
    private UserRepository repo;  // 期望被自动注入
    public String getUser(String id) { return repo.find(id); }
}
// 简易容器：扫描 @MyInject 字段并注入实例
public class SimpleContainer {
    public static <T> T createBean(Class<T> clazz) throws Exception {
        T instance = clazz.getDeclaredConstructor().newInstance();
        for (Field field : clazz.getDeclaredFields()) {
            if (field.isAnnotationPresent(MyInject.class)) {
                // 根据字段类型创建依赖对象
                Object dependency = field.getType().getDeclaredConstructor().newInstance();
                field.setAccessible(true);
                field.set(instance, dependency);
                System.out.println("注入 " + field.getType().getSimpleName()
                    + " → " + clazz.getSimpleName() + "." + field.getName());
            }
        }
        return instance;
    }
}
// 使用
UserService service = SimpleContainer.createBean(UserService.class);
System.out.println(service.getUser("001"));
// 注入 UserRepository → UserService.repo
// User:001

// 注解：控制 JSON 字段名
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface JsonField {
    String value() default "";  // 自定义字段名，空则用原始字段名
}
public class User {
    @JsonField("user_name")
    private String name;
    @JsonField
    private int age;
    private String password;  // 没有注解，不序列化
    public User(String name, int age, String password) {
        this.name = name;
        this.age = age;
        this.password = password;
    }
}
// 序列化器
public class SimpleJsonSerializer {
    public static String toJson(Object obj) throws Exception {
        Class<?> clazz = obj.getClass();
        StringBuilder sb = new StringBuilder("{");
        boolean first = true;
        for (Field field : clazz.getDeclaredFields()) {
            if (!field.isAnnotationPresent(JsonField.class)) continue;
            field.setAccessible(true);
            JsonField annotation = field.getAnnotation(JsonField.class);
            // 确定 JSON 字段名
            String key = annotation.value().isEmpty() ? field.getName() : annotation.value();
            Object value = field.get(obj);
            if (!first) sb.append(",");
            sb.append("\"").append(key).append("\":");
            if (value instanceof String) {
                sb.append("\"").append(value).append("\"");
            } else {
                sb.append(value);
            }
            first = false;
        }
        sb.append("}");
        return sb.toString();
    }
}
// 使用
User user = new User("Alice", 25, "secret123");
System.out.println(SimpleJsonSerializer.toJson(user));
// {"user_name":"Alice","age":25}
// password 没有 @JsonField，被跳过了

// 直接调用 vs 反射调用，性能差距大约 10-50 倍
// 原因：反射需要绕过编译期优化，进行安全检查、参数包装等
// 优化方式 1：缓存 Method / Field 对象，避免重复查找
private static final Method GET_NAME;
static {
    try {
        GET_NAME = User.class.getMethod("getName");
    } catch (NoSuchMethodException e) {
        throw new RuntimeException(e);
    }
}
// 优化方式 2：setAccessible(true) 跳过访问检查，略微提升性能
method.setAccessible(true);
// 优化方式 3：Java 7+ 的 MethodHandle（性能接近直接调用）
MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodHandle handle = lookup.findVirtual(User.class, "getName",
    MethodType.methodType(String.class));
String name = (String) handle.invoke(user);

你在写框架或通用工具，需要处理未知类型？
├── 是 → 用反射（Spring、Jackson、MyBatis 都是这么干的）
└── 否 → 不要用反射
    你在做代码生成、动态代理、注解处理？
    ├── 是 → 用反射
    └── 否 → 几乎不需要反射，用正常的面向对象就好

Constructor<?> c = clazz.getDeclaredConstructor(String.class, int.class);
c.setAccessible(true);                    // private 才需要
Object user = c.newInstance("Alice", 25); // 等价于 new User("Alice", 25)

Field f = clazz.getDeclaredField("name");
f.setAccessible(true);
f.set(user, "Alice");                     // 等价于 user.name = "Alice"
String name = (String) f.get(user);       // 等价于 user.name

Method m = clazz.getMethod("setName", String.class);
m.invoke(user, "Bob");                    // 等价于 user.setName("Bob")

if (method.isAnnotationPresent(LogExecution.class)) {
    LogExecution anno = method.getAnnotation(LogExecution.class);
    String value = anno.value();           // 读取注解属性
}

不用代理：
  调用方 → 目标对象.方法()
用代理：
  调用方 → 代理对象.方法()
                ↓
           执行额外逻辑（记日志、开事务、权限检查...）
                ↓
           目标对象.方法()（真正的业务逻辑）
                ↓
           执行额外逻辑（记耗时、提交事务...）
                ↓
           返回结果给调用方

public class UserServiceImpl implements UserService {
    public String getUser(String id) {
        System.out.println("[LOG] getUser 开始");    // 重复代码
        String result = "User:" + id;
        System.out.println("[LOG] getUser 结束");    // 重复代码
        return result;
    }
    public void deleteUser(String id) {
        System.out.println("[LOG] deleteUser 开始"); // 又是重复代码
        System.out.println("删除 " + id);
        System.out.println("[LOG] deleteUser 结束"); // 又是重复代码
    }
}
// 每个方法都要手动加日志，100 个方法就要写 200 行重复代码
// 而且日志逻辑和业务逻辑混在一起，违反单一职责

// 接口：定义有哪些方法
public interface UserService {
    String getUser(String id);
    void deleteUser(String id);
}
// 实现类：纯业务逻辑，不掺杂日志代码
public class UserServiceImpl implements UserService {
    public String getUser(String id) { return "User:" + id; }
    public void deleteUser(String id) { System.out.println("删除 " + id); }
}

public class LoggingHandler implements InvocationHandler {
    private final Object target;  // 被代理的真实对象
    public LoggingHandler(Object target) {
        this.target = target;
    }
    // proxy：代理对象本身（一般不用）
    // method：正在被调用的方法（反射的 Method 对象）
    // args：调用时传的参数
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // ===== 前置逻辑 =====
        System.out.println("[BEFORE] " + method.getName());
        // ===== 调用真实对象的方法 =====
        Object result = method.invoke(target, args);  // 反射调用 target 的同名方法
        // ===== 后置逻辑 =====
        System.out.println("[AFTER] " + method.getName());
        return result;
    }
}

UserService real = new UserServiceImpl();
UserService proxy = (UserService) Proxy.newProxyInstance(
    UserService.class.getClassLoader(),   // 类加载器（固定写法）
    new Class[]{UserService.class},       // 代理哪些接口（接口数组）
    new LoggingHandler(real)              // 用哪个 Handler 处理
);

// JVM 自动生成的代理类（伪代码，帮助理解）
public class $Proxy0 implements UserService {
    private InvocationHandler handler;  // 就是你传入的 LoggingHandler
    // 构造方法：接收 handler
    public $Proxy0(InvocationHandler handler) {
        this.handler = handler;
    }
    // 实现接口的 getUser 方法
    @Override
    public String getUser(String id) {
        // 不写任何业务逻辑！
        // 直接把"调用了什么方法、传了什么参数"全部转发给 handler.invoke()
        Method method = UserService.class.getMethod("getUser", String.class);
        return (String) handler.invoke(this, method, new Object[]{id});
    }
    // 实现接口的 deleteUser 方法
    @Override
    public void deleteUser(String id) {
        // 同样，转发给 handler.invoke()
        Method method = UserService.class.getMethod("deleteUser", String.class);
        handler.invoke(this, method, new Object[]{id});
    }
}

你写：proxy.getUser("001")
  → 实际调用的是 $Proxy0.getUser("001")（JVM 生成的代理类）
  → $Proxy0 什么都不做，转发给 handler.invoke(proxy, getUser方法, ["001"])
  → 你写的 LoggingHandler.invoke() 开始执行：
      1. 打印 [BEFORE] getUser
      2. method.invoke(target, args)  ← 这里才调用真实对象 UserServiceImpl.getUser("001")
      3. 打印 [AFTER] getUser
      4. 返回结果 "User:001"
  → 结果返回给调用方

proxy.getUser("001");
// [BEFORE] getUser
// [AFTER] getUser
proxy.deleteUser("002");
// [BEFORE] deleteUser
// 删除 002
// [AFTER] deleteUser

// Spring AOP 的 @Transactional 底层就是动态代理
@Transactional
public void transfer(String from, String to, double amount) {
    // Spring 生成代理对象，在方法前后自动开启/提交/回滚事务
    // 你写的代码里完全不需要 begin / commit / rollback
}

public class OrderService {
    public void createOrder() {
        this.bindCoupon();  // this 是真实对象，不是代理对象，不走代理逻辑
    }
    @Transactional
    public void bindCoupon() {
        // 事务不生效！因为是 this 直接调用，没经过代理
    }
}