动态代理作为一种在运行时创建代理类和其对象的技术，在Java中被广泛应用于AOP（面向切面编程）、RPC框架、ORM框架、事务管理、权限控制、日志记录等多个领域。它允许我们在不修改原有类代码的情况下，对其方法进行增强或拦截。
本文将围绕核心关键词“动态代理步骤”，详细剖析JDK动态代理和CGLIB动态代理两种主要实现方式的具体步骤，帮助您深入理解其背后的原理和操作流程。
JDK动态代理步骤详解
JDK动态代理是Java原生支持的代理方式，它依赖于接口。其核心在于利用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来生成代理对象。
步骤一：定义业务接口
首先，你需要定义一个或多个接口，声明你的业务方法。这是JDK动态代理的基础，因为它只能为实现了接口的类创建代理。
示例： public interface UserService { void addUser(String name); String getUser(int id); }步骤二：实现业务接口的目标类
创建一个或多个类来实现上述定义的业务接口。这些是实际执行业务逻辑的“目标”类或“被代理”类。它们是代理对象最终会调用的真实业务逻辑的载体。
示例： public class UserServiceImpl implements UserService { @Override public void addUser(String name) { System.out.println("Adding user: " + name); } @Override public String getUser(int id) { System.out.println("Getting user with ID: " + id); return "User" + id; } }步骤三：创建自定义的InvocationHandler实现类
这是JDK动态代理的核心。你需要创建一个实现了InvocationHandler接口的类，并重写其invoke方法。这个invoke方法是所有被代理方法被调用时都会执行的逻辑。
在invoke方法中，你可以执行前置处理、后置处理、异常处理等增强逻辑，然后通过method.invoke(target, args)调用目标对象（被代理对象）的原始方法。
invoke方法参数解释： Object proxy：代理对象本身。在invoke方法内部，通常不直接使用它，以避免循环调用。 Method method：当前被调用的方法对象。通过它可以获取方法名、参数类型、返回值类型等信息。 Object[] args：被调用方法的参数数组。 示例： import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.util.Arrays; public class LogInvocationHandler implements InvocationHandler { private Object target; // 被代理的目标对象 public LogInvocationHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("--- JDK Proxy: Before method: " + method.getName() + ", args: " + Arrays.toString(args) + " ---"); // 调用目标对象的原始方法 Object result = method.invoke(target, args); System.out.println("--- JDK Proxy: After method: " + method.getName() + ", result: " + result + " ---"); return result; // 返回原始方法的执行结果 } }步骤四：使用Proxy类创建代理实例
通过java.lang.reflect.Proxy类的静态方法newProxyInstance()来创建代理对象。这个方法是实现动态代理的关键，它负责在运行时动态生成代理类的字节码并加载到JVM中。
newProxyInstance方法参数解释： ClassLoader loader：指定类加载器，用于加载生成的代理类。通常使用目标对象的类加载器（target.getClass().getClassLoader()）。 Class[] interfaces：一个接口数组，指定代理类需要实现的接口。代理对象会实现这里列出的所有接口，并且只能调用这些接口中定义的方法。 InvocationHandler h：之前创建的InvocationHandler实例。当代理对象的方法被调用时，所有的调用都会被转发到这个处理器的invoke方法。 示例： import java.lang.reflect.Proxy; public class JdkProxyDemo { public static void main(String[] args) { // 1. 创建目标对象 UserService target = new UserServiceImpl(); // 2. 创建InvocationHandler实例，传入目标对象 InvocationHandler handler = new LogInvocationHandler(target); // 3. 使用Proxy.newProxyInstance()创建代理对象 // 注意：代理对象会被强制转换为UserService接口类型 UserService proxy = (UserService) Proxy.newProxyInstance( target.getClass().getClassLoader(), // 类加载器 new Class[]{UserService.class}, // 代理需要实现的接口数组 handler // InvocationHandler实例 ); // 4. 通过代理对象调用方法 System.out.println("--- Calling addUser via JDK Proxy ---"); proxy.addUser("Alice"); System.out.println(" --- Calling getUser via JDK Proxy ---"); String user = proxy.getUser(101); System.out.println("Retrieved user: " + user); } }步骤五：通过代理对象执行业务方法
现在，你可以像使用普通对象一样使用这个代理对象。当你调用代理对象的方法时，实际执行的是InvocationHandler的invoke方法。在invoke方法中，你可以决定是否调用原始目标对象的方法，以及在调用前后添加额外逻辑，从而实现了方法的增强或拦截。
CGLIB动态代理步骤详解
CGLIB（Code Generation Library）是一个强大的高性能代码生成库，它可以在运行时扩展Java类和实现Java接口。与JDK动态代理不同，CGLIB通过继承目标类的方式创建代理，因此它不需要目标类实现任何接口。CGLIB通常用于没有接口的类的代理场景。
CGLIB动态代理的核心是net.sf.cglib.proxy.Enhancer类和net.sf.cglib.proxy.MethodInterceptor接口。
步骤一：定义业务类（目标类）
与JDK动态代理不同，CGLIB可以直接代理普通类，不需要实现接口。但需要注意的是，目标类及其方法不能是final的，因为CGLIB通过继承来实现代理（final类不能被继承，final方法不能被重写）。
示例： public class ProductService { public void addProduct(String name) { System.out.println("Adding product: " + name); } public String getProduct(int id) { System.out.println("Getting product with ID: " + id); return "Product" + id; } }步骤二：创建自定义的MethodInterceptor实现类
你需要创建一个实现了MethodInterceptor接口的类，并重写其intercept方法。这个intercept方法是所有被代理方法被调用时都会执行的逻辑，类似于JDK动态代理的InvocationHandler。
在intercept方法中，你可以加入自己的增强逻辑，然后通过methodProxy.invokeSuper(obj, args)调用父类（即原始目标类）的对应方法。注意，这里不是直接调用method.invoke(target, args)。
intercept方法参数解释： Object obj：CGLIB生成的代理对象本身。 Method method：被拦截的方法对象。 Object[] args：被拦截方法的参数数组。 MethodProxy proxy：用于调用原始方法（父类方法）的对象，通常使用proxy.invokeSuper(obj, args)。 示例： import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; import java.lang.reflect.Method; import java.util.Arrays; public class LogMethodInterceptor implements MethodInterceptor { @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("--- CGLIB Proxy: Before method: " + method.getName() + ", args: " + Arrays.toString(args) + " ---"); // 调用目标对象的原始方法（父类方法） Object result = proxy.invokeSuper(obj, args); // 注意这里是invokeSuper System.out.println("--- CGLIB Proxy: After method: " + method.getName() + ", result: " + result + " ---"); return result; // 返回原始方法的执行结果 } }步骤三：使用Enhancer类创建代理实例
CGLIB通过net.sf.cglib.proxy.Enhancer类来生成代理对象。你需要设置目标类的超类和回调函数。Enhancer类负责生成代理类的字节码，并实例化代理对象。
Enhancer类使用步骤： 创建Enhancer实例。 设置被代理的类（目标类）作为其父类：enhancer.setSuperclass(TargetClass.class)。 设置回调函数（MethodInterceptor实例）：enhancer.setCallback(new MyMethodInterceptor())。 通过enhancer.create()方法创建代理对象。 示例： import net.sf.cglib.proxy.Enhancer; public class CglibProxyDemo { public static void main(String[] args) { // 1. 创建Enhancer实例 Enhancer enhancer = new Enhancer(); // 2. 设置目标类作为父类（ProductService是ProductServiceProxy的父类） enhancer.setSuperclass(ProductService.class); // 3. 设置回调函数（MethodInterceptor） enhancer.setCallback(new LogMethodInterceptor()); // 4. 创建代理对象 ProductService proxy = (ProductService) enhancer.create(); // 5. 通过代理对象调用方法 System.out.println("--- Calling addProduct via CGLIB Proxy ---"); proxy.addProduct("Laptop"); System.out.println(" --- Calling getProduct via CGLIB Proxy ---"); String product = proxy.getProduct(202); System.out.println("Retrieved product: " + product); } }步骤四：通过代理对象执行业务方法
与JDK动态代理类似，现在你可以直接调用CGLIB生成的代理对象的方法，其内部会触发MethodInterceptor的intercept方法，实现方法增强。CGLIB生成的代理类是目标类的子类，因此可以直接进行类型转换和方法调用。
JDK动态代理与CGLIB动态代理的简单比较
虽然两者都实现了动态代理的功能，但在实现原理和适用场景上有所不同：
JDK动态代理： 依赖于接口，只能为实现了接口的类创建代理。其生成的是一个实现了所有被代理接口的代理类，与目标类处于同一层级。如果目标类没有实现接口，则无法使用JDK动态代理。 CGLIB动态代理： 针对类进行代理，无需实现接口。它通过继承目标类并重写其方法来创建代理。因此，不能代理final类或final方法（因为final修饰的类或方法不能被继承或重写）。了解这些差异有助于您根据实际需求选择合适的动态代理方式。Spring AOP默认情况下优先使用JDK动态代理，当目标类没有实现接口时，则会自动切换到CGLIB动态代理。
总结
通过本文的详细介绍，您应该对“动态代理步骤”有了清晰的认识。无论是基于接口的JDK动态代理，还是基于继承的CGLIB动态代理，它们的核心思想都是在运行时生成代理对象，并在不修改原有代码的情况下，对目标方法进行拦截和增强。
掌握这些动态代理步骤，将使您能够更灵活地运用动态代理技术，解决软件开发中的多种复杂问题，特别是在框架设计和中间件开发中，动态代理是不可或缺的关键技术之一。理解其背后的机制，有助于您更好地调试和优化基于动态代理的应用程序。