Java 动态代理和静态代理 详解（结合代码实列）

📖Java 动态代理和静态代理的区别

---

动态代理和静态代理是两种不同的代理模式，它们在代理对象的创建和使用方式上有所不同。

1. 静态代理：
   • 静态代理是在编译期间就已经确定的，需要为每个被代理的类编写一个代理类，代理类和被代理类实现相同的接口或继承相同的父类。
   • 静态代理的代理类在编译时就存在，所以在程序运行时只能代理特定的类，无法动态地决定代理哪些类。
   • 静态代理对原始对象的方法调用进行了包装，可以在调用前后添加额外的逻辑，但代理类需要提前编写，会增加代码的量。
   • 静态代理在代码中显式指定代理对象，使用起来相对直观，但增加新的代理类需要重新编译。
2. 动态代理：
   • 动态代理是在运行时创建代理对象，无需提前编写代理类。使用Java的反射机制来动态生成代理类和代理对象。
   • 动态代理基于接口进行代理，通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口实现。
   • 动态代理可以代理多个接口的类，并动态决定代理哪些类。在运行时，可以根据需要为不同的对象生成代理，更具灵活性。
   • 动态代理不需要为每个被代理类编写特定的代理类，更加灵活和节省代码量。
   • 动态代理在代理对象的方法调用前后可以添加自定义的逻辑，例如日志记录、事务管理等。
   • 动态代理的缺点是相对于静态代理而言，运行时生成代理对象需要一定的性能开销。

🔖下面是一个结合代码示例

---

展示了Java中动态代理和静态代理的区别：

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

// 接口定义
interface Subject {
    void doSomething();
}

// 静态代理类
class StaticProxy implements Subject {
    private Subject realSubject;

    public StaticProxy(Subject realSubject) {
        this.realSubject = realSubject;
    }

    public void doSomething() {
        System.out.println("静态代理 - 前置处理");
        realSubject.doSomething();
        System.out.println("静态代理 - 后置处理");
    }
}

// 动态代理处理器
class DynamicProxyHandler implements InvocationHandler {
    private Object realObject;

    public DynamicProxyHandler(Object realObject) {
        this.realObject = realObject;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("动态代理 - 前置处理");
        Object result = method.invoke(realObject, args);
        System.out.println("动态代理 - 后置处理");
        return result;
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建被代理对象
        Subject realSubject = new RealSubject();

        // 静态代理示例
        Subject staticProxy = new StaticProxy(realSubject);
        staticProxy.doSomething();

        System.out.println("------------------");

        // 动态代理示例
        Subject dynamicProxy = (Subject) Proxy.newProxyInstance(
                realSubject.getClass().getClassLoader(),
                realSubject.getClass().getInterfaces(),
                new DynamicProxyHandler(realSubject)
        );
        dynamicProxy.doSomething();
    }
}

// 实现类
class RealSubject implements Subject {
    public void doSomething() {
        System.out.println("执行业务操作");
    }
}

• 上述代码中，首先定义了一个接口Subject，表示一个业务对象需要实现的功能。然后，创建了一个实现了Subject接口的具体类RealSubject。
• 接下来，我们实现了一个静态代理类StaticProxy，它在实际调用被代理对象前后进行额外的处理。然后，创建了一个静态代理对象staticProxy，并调用其doSomething()方法。
• 然后，我们定义了一个动态代理处理器DynamicProxyHandler，它实现了InvocationHandler接口并在实际调用被代理对象前后进行额外的处理。最后，我们使用Proxy.newProxyInstance()方法创建了一个动态代理对象dynamicProxy，并调用其doSomething()方法。

🔖运行上述代码，输出如下

---

静态代理 - 前置处理
执行业务操作
静态代理 - 后置处理
------------------
动态代理 - 前置处理
执行业务操作
动态代理 - 后置处理

📈总结

---

• 从输出结果可以看出，静态代理和动态代理都在原始对象的方法调用前后添加了额外的处理逻辑。但是，静态代理需要提前手动编写代理类，而动态代理则是在运行时生成代理对象。
• 静态代理在编写和使用上更为直观，但是当需要代理多个类或接口时，需要为每个类或接口编写特定的代理类，有一定的重复工作。而动态代理可以更加灵活地决定代理哪些类或接口，并且减少了代码的重复性。

• Java中的动态代理和静态代理都是代理模式的实现方式，适用于不同的场景。
  • 静态代理适合以下场景：
    • 当目标对象（被代理对象）数量有限且确定时，可以通过手动编写代理类来实现静态代理。静态代理在编译时就创建了代理类，因此在运行时性能较好。
    • 静态代理对目标对象进行了封装，在不修改原有代码的情况下增加了额外的功能。这使得静态代理常被用于日志记录、事务管理等横切关注点。
  • 动态代理适合以下场景：
    • 当目标对象数量不确定或者无法提前确定时，动态代理可以更方便地生成代理对象。它在运行时生成代理类和代理对象，避免了手动编写多个代理类的繁琐工作。
    • 动态代理可以灵活地在运行时为目标对象添加、删除或更改代理行为。这使得动态代理常被用于AOP（面向切面编程）、RPC（远程过程调用）等应用场景。
• 需要注意的是，由于动态代理在运行时通过反射机制创建代理类和代理对象，因此相比静态代理，其性能可能略低。此外，动态代理只能代理实现了接口的目标对象，而静态代理没有这个限制。
• 总结起来，静态代理适用于目标对象数量有限且确定、需要封装和增加额外功能的场景；而动态代理适用于目标对象数量不确定或无法提前确定、需要灵活添加、删除或更改代理行为的场景。根据具体需求和情况，选择合适的代理方式。