实现动态代理主要有哪些方法？它们之间有何区别？

参考回答

问题：实现动态代理主要有哪些方法？它们之间有何区别？

动态代理可以通过多种方式实现，常见的方法主要有两种：

1. JDK 动态代理
2. CGLIB 动态代理

这两种方法各有特点，适用于不同的场景。接下来，我们将分别介绍它们的实现方式，并对比它们的区别。

详细讲解与拓展

1. JDK 动态代理

JDK 动态代理是 Java 提供的原生动态代理实现，它通过反射机制在运行时创建代理对象，并将方法调用转发给指定的目标对象。JDK 动态代理要求目标类必须实现接口。

1.1 JDK 动态代理的实现步骤

• 定义接口：首先需要定义目标类和代理类都要实现的接口。
• 实现目标类：目标类实现接口，并提供业务逻辑。
• 定义 InvocationHandler：通过实现 java.lang.reflect.InvocationHandler 接口来定义代理逻辑。
• 创建代理对象：通过 Proxy.newProxyInstance() 方法动态生成代理对象。

1.2 JDK 动态代理代码示例

// 定义接口
public interface Service {
    void performAction(String action);
}

// 目标类实现接口
public class ServiceImpl implements Service {
    @Override
    public void performAction(String action) {
        System.out.println("Performing action: " + action);
    }
}

// InvocationHandler 实现
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class ServiceInvocationHandler implements InvocationHandler {
    private Object target;

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

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

// 使用 JDK 动态代理
import java.lang.reflect.Proxy;

public class ProxyTest {
    public static void main(String[] args) {
        Service service = new ServiceImpl(); // 创建目标对象
        ServiceInvocationHandler handler = new ServiceInvocationHandler(service);

        Service proxy = (Service) Proxy.newProxyInstance(
                service.getClass().getClassLoader(),
                new Class[]{Service.class},
                handler);

        proxy.performAction("Test Action"); // 调用代理对象的方法
    }
}

1.3 JDK 动态代理的限制

• 接口限制：JDK 动态代理要求目标类必须实现接口。如果目标类没有接口，就无法使用 JDK 动态代理。
• 性能开销：由于采用了反射机制，JDK 动态代理的性能会相对较低，尤其在高频调用时。

2. CGLIB 动态代理

CGLIB (Code Generation Library) 是一个开源的 Java 类库，可以通过字节码操作生成目标类的子类，从而实现动态代理。CGLIB 不要求目标类必须实现接口，它通过继承目标类来实现代理。

2.1 CGLIB 动态代理的实现步骤

• 导入 CGLIB 库：CGLIB 库需要被引入到项目中（如 Maven 中引入依赖）。
• 定义目标类：目标类无需实现接口，可以是任意的普通类。
• 创建代理对象：通过 Enhancer 类动态生成目标类的子类。

2.2 CGLIB 动态代理代码示例

// 目标类
public class Service {
    public void performAction(String action) {
        System.out.println("Performing action: " + action);
    }
}

// CGLIB 代理实现
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibProxyTest {
    public static void main(String[] args) {
        Service service = new Service(); // 创建目标对象

        // 创建 CGLIB 代理对象
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Service.class);  // 设置父类
        enhancer.setCallback(new MethodInterceptor() { // 设置回调
            @Override
            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                System.out.println("Before method execution...");
                Object result = proxy.invokeSuper(obj, args); // 调用父类方法
                System.out.println("After method execution...");
                return result;
            }
        });

        // 创建代理对象
        Service proxy = (Service) enhancer.create();
        proxy.performAction("Test Action");  // 调用代理对象的方法
    }
}

2.3 CGLIB 动态代理的限制

• 目标类不能为final：CGLIB 是通过继承方式生成代理类的，如果目标类被声明为 final，则无法被继承，从而无法生成代理类。
• 性能问题：与 JDK 动态代理类似，CGLIB 也会带来一定的性能开销，尤其是在生成字节码时。

3. JDK 动态代理与 CGLIB 动态代理的区别

4. 总结

• JDK 动态代理：适用于目标类实现了接口的场景，代理类通过反射机制生成，代理类和目标类的关系在运行时确定，灵活性较高，但性能较差。
• CGLIB 动态代理：适用于目标类没有接口，或者需要通过继承来代理类的场景，代理类是通过字节码生成的，不需要目标类实现接口，性能比 JDK 动态代理稍高，但也有性能开销。

两者各有优缺点，选择使用哪种方式主要取决于应用场景和目标类的设计。

帅地训练营会员

打赏 收藏 海报挣佣金 推广链接