在Java的AOP（面向切面编程）领域，动态代理技术是实现横切关注点的重要手段。我们常用的动态代理方式主要有两种：JDK动态代理和CGLIB动态代理。它们各自有着不同的特点和使用场景，下面我们将深入探讨这两种代理方式的差异，并通过实例来说明它们的工作原理。

一、JDK动态代理：基于接口的代理

JDK动态代理是Java标准库中提供的一种代理方式，它要求被代理的目标对象必须实现一个或多个接口。JDK动态代理的核心在于java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。

当使用JDK动态代理时，我们首先需要定义一个InvocationHandler实现类，用于处理代理对象上的方法调用。然后，通过Proxy.newProxyInstance()方法创建代理对象。这个代理对象会实现与目标对象相同的接口，并在调用这些接口方法时，自动调用InvocationHandler的invoke()方法。

例如，假设我们有一个接口MyService和一个实现类MyServiceImpl：

public interface MyService {
    void doSomething();
}

public class MyServiceImpl implements MyService {
    @Override
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

我们可以使用JDK动态代理来创建一个代理对象：

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

public class JDKProxyExample {
    public static void main(String[] args) {
        MyService target = new MyServiceImpl();
        MyService proxy = (MyService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new MyInvocationHandler(target)
        );
        proxy.doSomething();
    }
}

class MyInvocationHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method call...");
        Object result = method.invoke(target, args);
        System.out.println("After method call...");
        return result;
    }
}

运行上述代码，你会看到在调用doSomething()方法前后，有“Before method call...”和“After method call...”的输出。

二、CGLIB动态代理：基于类的代理

CGLIB（Code Generation Library）是一个强大的、高性能的代码生成库，它可以在运行时动态地生成一个目标类的子类，并重写父类的所有方法。CGLIB通过ASM字节码操作框架来实现这一功能。

与JDK动态代理不同，CGLIB不需要目标对象实现接口。它通过继承的方式创建代理对象，并在调用目标方法时，自动调用父类的对应方法。如果目标类被标记为final，那么CGLIB也无法对其进行代理。

例如，我们可以使用CGLIB来创建一个代理对象：

import net.sf.cglib.core.CodeGenerator;
import net.sf.cglib.core.MethodGenerator;
import net.sf.cglib.core.TypeUtils;
import net.sf.cglib.proxy.Enhancer;

public class CGLIBProxyExample {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(MyServiceImpl.class);
        enhancer.setCallback(new MyMethodInterceptor());
        MyService proxy = (MyService) enhancer.create();
        proxy.doSomething();
    }
}

class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before method call...");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After method call...");
        return result;
    }
}

运行上述代码，你会看到与JDK动态代理类似的效果。

三、总结与选择

JDK动态代理和CGLIB动态代理各有优缺点。JDK动态代理基于接口，易于理解和实现，但要求目标对象必须实现接口；而CGLIB基于类，不需要接口，但无法代理final类和静态方法。

在选择动态代理方式时，我们需要根据具体的需求和场景来决定。如果目标对象实现了接口，并且我们希望代理对象也实现这些接口，那么JDK动态代理是一个不错的选择；如果目标对象没有实现接口，或者我们需要代理final类和静态方法，那么CGLIB动态代理可能更适合。