Java AOP代理模式（Proxy）：Java静态代理和动态代理的区别是什么？-Spring AOP 编程思想(上)

当前位置:　首页>> 技术小册>> Spring AOP 编程思想(上)

Java AOP代理模式（Proxy）：Java静态代理和动态代理的区别是什么？

在深入探讨Spring AOP（面向切面编程）之前，理解Java中的代理模式，特别是静态代理与动态代理的区别，是至关重要的基础。代理模式是一种常用的设计模式，它允许我们为其他对象提供一种代理以控制对这个对象的访问。在Java中，代理模式主要有两种实现方式：静态代理和动态代理。这两种方式在实现细节、灵活性以及应用场景上存在显著差异。

一、静态代理

1. 定义与特点

静态代理是指代理类在程序编译时就已经确定，它通常是由程序员手动编写的。静态代理类会实现与目标对象相同的接口，并在其内部封装目标对象，通过调用目标对象的方法来实现对目标对象的增强或控制。

特点：

编译时确定：代理类的.java文件在编译时就已存在，代理关系在编译时就已确定。
手动编写：需要程序员根据目标接口手动编写代理类代码。
接口约束：目标类和代理类都需实现相同的接口。
灵活性低：当接口增加方法时，所有实现了该接口的类（包括代理类）都需要实现新方法，增加了维护成本。

2. 实现示例

假设有一个Subject接口和两个实现类RealSubject（真实对象）与StaticProxy（静态代理类）。

// Subject 接口
interface Subject {
    void request();
}
// RealSubject 真实对象
class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("Executing real request.");
    }
}
// StaticProxy 静态代理类
class StaticProxy implements Subject {
    private Subject realSubject;
    public StaticProxy(Subject realSubject) {
        this.realSubject = realSubject;
    }
    @Override
    public void request() {
        preRequest();
        realSubject.request(); // 调用真实对象的方法
        postRequest();
    }
    private void preRequest() {
        System.out.println("Before real request.");
    }
    private void postRequest() {
        System.out.println("After real request.");
    }
}
// 使用示例
public class StaticProxyDemo {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        Subject proxy = new StaticProxy(realSubject);
        proxy.request(); // 调用代理类的方法
    }
}

二、动态代理

1. 定义与特点

动态代理是指代理类在程序运行时动态生成，而不是在编译时确定。Java动态代理主要依赖于java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。动态代理类能够代理任何实现了特定接口的类，这使得它非常灵活且易于扩展。

特点：

运行时生成：代理类的.class文件在运行时由JVM动态生成，代理关系在运行时确定。
自动编写：不需要程序员手动编写代理类代码，降低了开发成本。
接口约束：目标对象必须实现至少一个接口，因为动态代理是基于接口的。
高度灵活：可以在不修改目标对象代码的情况下，增加新的功能或修改现有功能。

2. 实现示例

假设我们还是使用上面的Subject接口和RealSubject类，现在使用动态代理来实现代理功能。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
// InvocationHandler 实现
class DynamicProxyHandler implements InvocationHandler {
    private Object target;
    public DynamicProxyHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        preRequest();
        Object result = method.invoke(target, args); // 调用目标对象的方法
        postRequest();
        return result;
    }
    private void preRequest() {
        System.out.println("Before method execution.");
    }
    private void postRequest() {
        System.out.println("After method execution.");
    }
    // 创建代理对象的方法
    @SuppressWarnings("unchecked")
    public static <T> T newProxyInstance(Class<T> interfaceClass, Object target) {
        return (T) Proxy.newProxyInstance(
                interfaceClass.getClassLoader(),
                new Class<?>[]{interfaceClass},
                new DynamicProxyHandler(target)
        );
    }
}
// 使用示例
public class DynamicProxyDemo {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();
        Subject proxy = DynamicProxyHandler.newProxyInstance(Subject.class, realSubject);
        proxy.request(); // 调用代理类的方法
    }
}

三、静态代理与动态代理的区别

编译与运行时：
- 静态代理是在编译时就确定了代理关系，代理类的.java文件是手动编写的。
- 动态代理则是在运行时动态生成代理类的.class文件，代理关系在运行时确定。
灵活性：
- 静态代理由于需要手动编写代理类，当接口增加方法时，所有代理类都需要修改，灵活性较低。
- 动态代理则无需手动编写代理类，当接口增加方法时，无需修改代理代码，灵活性高。
性能：
- 静态代理因为是编译时确定的，所以在性能上通常比动态代理稍好（尽管这种差异在大多数情况下可以忽略不计）。
- 动态代理因为涉及到反射调用，所以在性能上可能会稍逊一筹，但换来的是更高的灵活性和更少的代码量。
使用场景：
- 静态代理适用于代理类较少，且接口变化不大的情况。
- 动态代理则适用于代理类较多，或接口经常变化的情况，以及需要动态控制代理逻辑的场景。
实现复杂度：
- 静态代理实现简单，但维护成本较高。
- 动态代理实现相对复杂（主要是理解反射机制），但维护成本较低。

结论

静态代理和动态代理各有优缺点，选择哪种方式取决于具体的应用场景和需求。在Spring AOP的上下文中，动态代理因其高度的灵活性和易用性而被广泛使用，特别是在需要实现横切关注点（如事务管理、日志记录等）时，动态代理提供了一种非常有效的解决方案。通过理解静态代理和动态代理的区别，我们可以更好地利用Java的代理机制，为应用程序的设计和实现带来更多的灵活性和可维护性。