Java反射与动态代理底层原理+面试考点全攻略（2026年4月9日）

// 1. 服务接口
public interface UserService {
    void addUser(String username);
    void deleteUser(int id);
}

// 2. 目标类
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String username) {
        System.out.println("添加用户：" + username);
    }
    @Override
    public void deleteUser(int id) {
        System.out.println("删除用户：" + id);
    }
}

// 3. 静态代理类
public class UserServiceStaticProxy implements UserService {
    private UserService target;  // 持有目标对象引用
    
    public UserServiceStaticProxy(UserService target) {
        this.target = target;
    }
    
    @Override
    public void addUser(String username) {
        System.out.println("[日志] 准备添加用户：" + username);
        target.addUser(username);
        System.out.println("[日志] 用户添加完成");
    }
    
    @Override
    public void deleteUser(int id) {
        System.out.println("[日志] 准备删除用户：" + id);
        target.deleteUser(id);
        System.out.println("[日志] 用户删除完成");
    }
}

// 方式1：类名.class（最安全，编译期检查）
Class<User> clazz1 = User.class;

// 方式2：对象.getClass()（已有实例时使用）
User user = new User();
Class<? extends User> clazz2 = user.getClass();

// 方式3：Class.forName("全限定名")（最灵活，运行时可配置）
// ⚠️ 需处理ClassNotFoundException
Class<?> clazz3 = Class.forName("com.example.User");

// 1. 目标接口（必须存在，JDK动态代理基于接口）
public interface UserService { void addUser(String name); }

// 2. 目标实现类
public class UserServiceImpl implements UserService { ... }

// 3. InvocationHandler：代理逻辑的核心
public class LogInvocationHandler implements InvocationHandler {
    private Object target;  // 被代理的真实对象
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用前：执行日志记录");
        Object result = method.invoke(target, args);  // 反射调用目标方法
        System.out.println("调用后：执行日志记录");
        return result;
    }
}

// 4. 创建代理对象
UserService proxy = (UserService) Proxy.newProxyInstance(
    target.getClass().getClassLoader(),  // 类加载器
    target.getClass().getInterfaces(),   // 代理要实现的接口
    new LogInvocationHandler(target)     // 代理逻辑
);

// 1. 定义接口
public interface PaymentService {
    void pay(String account, double amount);
}

// 2. 目标类
public class AlipayService implements PaymentService {
    @Override
    public void pay(String account, double amount) {
        System.out.println("向账户 " + account + " 支付 " + amount + " 元");
    }
}

// 3. 增强逻辑处理器
public class LogHandler implements InvocationHandler {
    private Object target;
    
    public LogHandler(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置增强
        System.out.println("【前置日志】即将调用方法：" + method.getName());
        System.out.println("【前置日志】参数：" + Arrays.toString(args));
        
        // 核心调用（反射）
        Object result = method.invoke(target, args);
        
        // 后置增强
        System.out.println("【后置日志】方法调用完成，返回：" + result);
        return result;
    }
}

// 4. 使用代理
public class Main {
    public static void main(String[] args) {
        PaymentService target = new AlipayService();
        PaymentService proxy = (PaymentService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new LogHandler(target)
        );
        
        proxy.pay("zhangsan@alipay", 99.99);
    }
}

【前置日志】即将调用方法：pay
【前置日志】参数：[zhangsan@alipay, 99.99]
向账户 zhangsan@alipay 支付 99.99 元
【后置日志】方法调用完成，返回：null

┌─────────────────────────────────────────────────────────┐
│                    调用方（客户端）                       │
└─────────────────────────┬───────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│              动态代理对象（$Proxy0）                      │
│  - 实现目标接口                                           │
│  - 内部持有 InvocationHandler                            │
└─────────────────────────┬───────────────────────────────┘
                          │
                          ▼
┌─────────────────────────────────────────────────────────┐
│         InvocationHandler.invoke()                       │
│  - 前置增强（日志、事务、权限等）                          │
│  - method.invoke(target, args)  ← 反射调用               │
│  - 后置增强                                               │
└─────────────────────────────────────────────────────────┘