Java中的动态代理是什么？如何实现？

Java中的动态代理是一种设计模式，它允许你在运行时创建一个接口的代理对象。动态代理主要用于实现AOP（面向切面编程），拦截方法调用等场景。Java提供了两种主要的方式来实现动态代理：

1. 基于接口的代理（JDK动态代理）
2. 基于类的代理（CGLIB动态代理）

1. 基于接口的代理（JDK动态代理）

实现步骤：

1. 定义接口：

   • 首先需要定义一个接口，这个接口将会由代理类实现。

2. 创建代理类：

   • 使用java.lang.reflect.Proxy类来创建代理类。代理类会实现上述定义的接口，并且会在方法调用时调用我们提供的InvocationHandler。

3. 实现InvocationHandler接口：

   • 定义一个类实现InvocationHandler接口，并重写invoke方法。这个方法会在代理对象的方法被调用时触发。

示例代码：

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

interface Service {
    void doSomething();
}

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

class MyInvocationHandler implements InvocationHandler {
    private final 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;
    }
}

public class DynamicProxyExample {
    public static void main(String[] args) {
        Service service = new ServiceImpl();

        // 创建代理对象
        Service proxy = (Service) Proxy.newProxyInstance(
                Service.class.getClassLoader(),
                new Class[]{Service.class},
                new MyInvocationHandler(service)
        );

        // 调用代理对象的方法
        proxy.doSomething();
    }
}

2. 基于类的代理（CGLIB动态代理）

CGLIB是一个高性能、轻量级的代码生成库，它允许你在运行时动态生成类。CGLIB动态代理适用于无法访问目标类源代码的情况，或者当目标类没有实现任何接口时。

实现步骤：

1. 添加依赖：

   • 如果使用Maven或Gradle，需要添加CGLIB的依赖。

2. 创建代理类：

   • 使用org.springframework.cglib.proxy.Enhancer来创建代理类。

3. 实现MethodInterceptor接口：

   • 定义一个类实现MethodInterceptor接口，并重写intercept方法。

示例代码：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibDynamicProxyExample {
    interface Service {
        void doSomething();
    }

    static class ServiceImpl implements Service {
        @Override
        public void doSomething() {
            System.out.println("Doing something...");
        }
    }

    static 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;
        }
    }

    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(ServiceImpl.class);
        enhancer.setCallback(new MyMethodInterceptor());

        Service proxy = (Service) enhancer.create();

        proxy.doSomething();
    }
}

总结：

• JDK动态代理适用于目标对象实现了接口的情况。
• CGLIB动态代理适用于目标对象没有实现接口的情况，或者需要代理私有方法的情况。

这两种代理方式各有优劣，根据你的应用场景选择合适的方法。如果你的应用使用了Spring框架，Spring也提供了对这两种代理的支持。