动态代理java例子

动态代理是一种在运行时创建代理对象的方式，相对于静态代理，动态代理更加灵活和通用。下面是一个简单的 Java 代码示例，演示如何使用动态代理来代理一个接口：

首先，定义一个接口 `Person`，表示被代理对象的基本行为：

public interface Person {
    void introduce();
}

然后，定义实现了 `Person` 接口的 `RealPerson` 类，它是要被代理的真正对象：

public class RealPerson implements Person {
    private String name;

    public RealPerson(String name) {
        this.name = name;
        System.out.println("Creating real person: " + name);
    }

    @Override
    public void introduce() {
        System.out.println("Hi, my name is " + name);
    }
}

接下来，定义一个代理类 `DynamicProxyPerson`，它实现了 `InvocationHandler` 接口，并且持有一个 `Person` 对象的引用：

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

public class DynamicProxyPerson implements InvocationHandler {
    private Person person;

    public DynamicProxyPerson(Person person) {
        this.person = person;
    }

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

    public static void main(String[] args) {
        Person person = new RealPerson("Alice");

        Person proxy = (Person) Proxy.newProxyInstance(
                person.getClass().getClassLoader(),
                person.getClass().getInterfaces(),
                new DynamicProxyPerson(person)
        );

        proxy.introduce();
    }
}

在上面的示例中，`DynamicProxyPerson` 类是代理，它实现了 `InvocationHandler` 接口，并且持有一个 `Person` 对象的引用。在 `invoke()` 方法中，我们可以在调用被代理对象的方法之前和之后添加一些额外的逻辑。在 `main()` 方法中，我们使用 `Proxy` 类的 `newProxyInstance()` 方法来创建代理对象，该方法需要传入三个参数：类加载器、要代理的接口集合和代理处理器。最终，我们调用代理对象的 `introduce()` 方法，实际上会执行代理处理器中的 `invoke()` 方法。

该代码输出：

Creating real person: Alice
Before invoking introduce
Hi, my name is Alice
After invoking introduce

在输出中，我们可以看到代理处理器在调用 `introduce()` 方法之前和之后分别输出了一些额外的信息。这就是动态代理的基本原理，通过在运行时动态创建代理对象，并在代理处理器中添加一些额外的逻辑来实现对被代理对象的控制。