Java的动态代理：应用场景与实现方式示例-蒲公英云

Java的动态代理：应用场景与实现方式示例

原创我不是女神ヾ 2024-11-07 06:51 139阅读 0赞

Java的动态代理是一种在运行时动态创建代理类和对象的机制，它允许开发者在不修改原有类代码的情况下，增加额外的功能。动态代理主要应用在以下场景：

AOP（面向切面编程）：在不改变业务逻辑代码的前提下，动态地添加日志、权限检查、事务管理等功能。
事件监听：为对象动态添加事件处理功能。
测试：在单元测试中模拟对象行为，进行Mock测试。
框架开发：许多框架（如Spring）使用动态代理来实现依赖注入、AOP等特性。

实现方式Java动态代理主要有两种实现方式：`java.lang.reflect.Proxy` 类和 `java.lang.reflect.InvocationHandler`接口。

使用 `java.lang.reflect.Proxy` 和 `InvocationHandler`

以下是使用这两个类实现动态代理的一个简单示例：

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

//定义一个接口interface MyInterface {
void doSomething();
}

// 实现InvocationHandler接口，创建代理逻辑class MyInvocationHandler implements InvocationHandler {
private 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: “ + method.getName());
Object result = method.invoke(target, args);
System.out.println(“After method: “ + method.getName());
return result;
}
}

//被代理的类class RealSubject implements MyInterface {
@Override public void doSomething() {
System.out.println(“Doing something”);
}
}

public class DynamicProxyExample {
public static void main(String[] args) {
// 创建被代理类实例 RealSubject realSubject = new RealSubject();
// 创建动态代理 MyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(
MyInterface.class.getClassLoader(),
new Class[]{MyInterface.class},
new MyInvocationHandler(realSubject)
);
//通过代理调用方法 proxyInstance.doSomething();
}
}
``在这个例子中，RealSubject类实现了MyInterface接口，MyInvocationHandler类实现了InvocationHandler接口，并在invoke方法中定义了代理逻辑。DynamicProxyExample类中创建了RealSubject的实例，并使用Proxy.newProxyInstance方法创建了一个动态代理，这个代理实现了MyInterface`接口，并在调用方法前后添加了额外的逻辑。

使用 `Lambda`表达式（Java8+）

从Java8开始，可以使用 Lambda表达式简化动态代理的实现：

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

interface MyInterface {
void doSomething();
}

class RealSubject implements MyInterface {
@Override public void doSomething() {
System.out.println(“Doing something”);
}
}

public class DynamicProxyExample {
public static void main(String[] args) {
RealSubject realSubject = new RealSubject();
MyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(
MyInterface.class.getClassLoader(),
new Class[]{MyInterface.class},
(proxy, method, args) -> {
System.out.println(“Before method: “ + method.getName());
Object result = method.invoke(realSubject, args);
System.out.println(“After method: “ + method.getName());
return result;
}
);
proxyInstance.doSomething();
}
}
``在这个简化的例子中，我们直接将Lambda表达式传递给Proxy.newProxyInstance方法，从而避免了创建一个单独的InvocationHandler类。这种方式更加简洁，但在处理复杂的代理逻辑时，可能不如显式定义一个InvocationHandler` 类那样清晰。