JAVA设计模式，动态代理模式
动态代理（Dynamic Proxy）是Java中一种非常有用的设计模式。它允许在运行时创建一个实现了一组给定接口的新类。这种模式主要用于当需要为某个对象提供一个代理以控制对该对象的访问时。通过这种方式，可以添加额外的功能，如事务管理、安全检查等，而无需修改原始对象的代码。
### 动态代理的主要组成部分
1. **接口**：定义一组方法，代理类和被代理类都需要实现这些方法。
2. **被代理类**：实现了上述接口的实际业务逻辑类。
3. **InvocationHandler**：这是一个接口，它有一个方法`invoke`，该方法负责处理所有的方法调用。这个接口的实例包含了对被代理对象的引用，并且可以在这个方法中添加额外的操作。
4. **代理类**：这是由Java反射机制动态生成的一个类，它实现了与被代理类相同的接口。当通过代理对象调用方法时，实际上会调用到`InvocationHandler`中的`invoke`方法。
### 实现步骤
1. 定义一个或多个接口。
2. 创建实现这些接口的被代理类。
3. 创建一个实现了`InvocationHandler`接口的类，该类包含对被代理对象的引用，并在`invoke`方法中实现所需的额外操作。
4. 使用`Proxy.newProxyInstance`方法来创建代理对象。
### 示例代码
假设我们有一个简单的接口`MyInterface`，以及其实现类`MyRealObject`。
#### 接口
```java
public interface MyInterface {
void doSomething();
}
```
#### 被代理类
```java
public class MyRealObject implements MyInterface {
@Override
public void doSomething() {
System.out.println("Doing something...");
}
}
```
#### InvocationHandler 实现
```java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInvocationHandler implements InvocationHandler {
private final 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 call");
Object result = method.invoke(target, args);
System.out.println("After method call");
return result;
}
}
```
#### 创建代理对象并使用
```java
import java.lang.reflect.Proxy;
public class Main {
public static void main(String[] args) {
MyInterface realObject = new MyRealObject();
MyInterface proxyObject = (MyInterface) Proxy.newProxyInstance(
MyInterface.class.getClassLoader(),
new Class[]{MyInterface.class},
new MyInvocationHandler(realObject)
);
proxyObject.doSomething(); // 通过代理对象调用方法
}
}
```
以上示例展示了如何使用Java的动态代理模式。当你运行这段代码时，你会看到输出不仅包括`doSomething`方法的执行结果，还有我们在`MyInvocationHandler`中添加的前后操作信息。这正是动态代理的魅力所在——能够在不改变原有业务逻辑的情况下，轻松地添加新的功能。