智能助手AI深度解析：Java动态代理从原理到实战全掌握（2026-04-09）

public interface UserService {

    void addUser(String username);
    void deleteUser(String username);
}

public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String username) {
        System.out.println("开始执行：addUser");   // 侵入式日志
        System.out.println("添加用户：" + username);
        System.out.println("结束执行：addUser");
    }

    @Override
    public void deleteUser(String username) {
        System.out.println("开始执行：deleteUser"); // 同样的代码重复
        System.out.println("删除用户：" + username);
        System.out.println("结束执行：deleteUser");
    }
}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// Step 1：定义接口（JDK动态代理必需）
public interface HelloService {
    String sayHello(String name);
}

// Step 2：目标实现类
public class HelloServiceImpl implements HelloService {
    @Override
    public String sayHello(String name) {
        System.out.println("执行业务逻辑：Hello, " + name);
        return "Hello, " + name;
    }
}

// Step 3：实现InvocationHandler，定义增强逻辑
public class LogInvocationHandler implements InvocationHandler {
    private final Object target;  // 持有真实对象引用

    public LogInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("[前置增强] 开始执行方法：" + method.getName());
        long start = System.currentTimeMillis();

        // 通过反射调用目标对象的真实方法 ⬅️ 关键步骤
        Object result = method.invoke(target, args);

        long end = System.currentTimeMillis();
        System.out.println("[后置增强] 方法执行完成，耗时：" + (end - start) + "ms");
        return result;
    }
}

// Step 4：创建代理对象并调用
public class JdkProxyDemo {
    public static void main(String[] args) {
        // 真实对象
        HelloService realService = new HelloServiceImpl();

        // 创建InvocationHandler
        InvocationHandler handler = new LogInvocationHandler(realService);

        // 生成代理对象 ⬅️ 核心API
        HelloService proxy = (HelloService) Proxy.newProxyInstance(
            realService.getClass().getClassLoader(),  // 类加载器
            realService.getClass().getInterfaces(),   // 需要实现的接口数组
            handler                                    // 调用处理器
        );

        // 调用代理对象的方法（实际会走invoke()）
        String result = proxy.sayHello("World");
        System.out.println("返回结果：" + result);
    }
}

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

// 目标类：无需实现接口 ⬅️ CGLIB的关键差异
public class NormalService {
    public String process(String input) {
        System.out.println("执行业务逻辑：" + input);
        return "Processed: " + input;
    }
}

// 实现MethodInterceptor
public class LogMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("[CGLIB前置增强] 开始执行：" + method.getName());
        long start = System.currentTimeMillis();

        // 调用父类（目标类）的方法 ⬅️ CGLIB通过继承实现
        Object result = proxy.invokeSuper(obj, args);

        long end = System.currentTimeMillis();
        System.out.println("[CGLIB后置增强] 执行完成，耗时：" + (end - start) + "ms");
        return result;
    }
}

// 创建代理
public class CglibProxyDemo {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(NormalService.class);  // 设置父类
        enhancer.setCallback(new LogMethodInterceptor());

        NormalService proxy = (NormalService) enhancer.create();
        String result = proxy.process("CGLIB Test");
        System.out.println("返回结果：" + result);
    }
}