深入解析动态代理模式：23种设计模式之三

### 引言

在设计模式系列文章中，我们已经探讨了静态代理模式。接下来，我们将深入研究更为灵活和强大的动态代理模式。动态代理模式允许我们在运行时动态生成代理对象，并且可以在不修改原始代码的情况下对方法调用进行拦截和增强。

#### 动态代理的核心概念

动态代理的关键在于能够在程序运行时创建代理对象，而不是在编译时确定。通过使用Java的`java.lang.reflect.Proxy`类和`InvocationHandler`接口，我们可以实现这一目标。

##### 抽象接口

首先定义一个抽象接口，该接口声明了所有需要被代理的方法。例如：

```java
package com.yemaozi.proxy.dynamic;

public interface IGamePlayer {
void login(String username, String password);
void killBoss();
void upGrade();
}
```

##### 真实主题类

接下来，实现上述接口的具体类，即真实主题类。这个类包含了业务逻辑的具体实现：

```java
package com.yemaozi.proxy.dynamic;

public class GamePlayer implements IGamePlayer {
private String name;

public GamePlayer(String name) {
this.name = name;
}

@Override
public void login(String username, String password) {
System.out.println("登录名为 " + username + " 进入游戏，" + name + " 登录成功！");
}

@Override
public void killBoss() {
System.out.println(this.name + " 击杀了Boss！");
}

@Override
public void upGrade() {
System.out.println(this.name + " 升级了！");
}
}
```

##### 动态代理处理器

为了实现动态代理，我们需要创建一个实现了`InvocationHandler`接口的类。这个类负责处理所有代理对象的方法调用。

```java
package com.yemaozi.proxy.dynamic;

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

public class GamePlayerInvocationHandler implements InvocationHandler {
private Object obj;

public GamePlayerInvocationHandler(Object obj) {
this.obj = obj;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if ("login".equalsIgnoreCase(method.getName())) {
System.out.println("代理登录游戏！");
}
return method.invoke(this.obj, args);
}
}
```

##### 动态代理场景类

最后，我们可以通过`Proxy.newProxyInstance`方法来动态创建代理对象，并调用其方法。

```java
package com.yemaozi.proxy.dynamic;

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

public class Client {
public static void main(String[] args) {
IGamePlayer gp = new GamePlayer("张三");
InvocationHandler gpHandler = new GamePlayerInvocationHandler(gp);
ClassLoader classLoader = gp.getClass().getClassLoader();
Class[] cls = new Class[]{IGamePlayer.class};
IGamePlayer proxyGp = (IGamePlayer) Proxy.newProxyInstance(classLoader, cls, gpHandler);
proxyGp.login("zhangsan", "123456");
proxyGp.killBoss();
proxyGp.upGrade();
}
}
```

#### 执行结果

```
代理登录游戏！
登录名为 zhangsan 进入游戏，张三 登录成功！
张三 击杀了Boss！
张三升级了！
```

#### 面向切面编程（AOP）

在动态代理模式中，除了动态生成代理对象外，还可以通过面向切面编程（AOP）的思想，在方法调用前后添加额外的功能。例如，可以在方法执行前添加日志记录、权限验证等操作。

##### AOP示例

下面是一个简单的AOP示例，展示了如何在方法调用前后添加前置通知和后置通知。

```java
package com.yemaozi.proxy.dynamic_aop;

public interface Subject {
void doSomething(String str);
}

public class RealSubject implements Subject {
@Override
public void doSomething(String str) {
System.out.println("do something..." + str);
}
}

public interface IAdvice {
void exec();
}

public class BeforeAdvice implements IAdvice {
@Override
public void exec() {
System.out.println("前置通知被执行！");
}
}

public class AfterAdvice implements IAdvice {
@Override
public void exec() {
System.out.println("后置通知被执行！");
}
}

public class MyInvocationHandler implements InvocationHandler {
private Subject realSubject;

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

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
IAdvice beforeAdvice = new BeforeAdvice();
beforeAdvice.exec();
Object result = method.invoke(this.realSubject, args);
IAdvice afterAdvice = new AfterAdvice();
afterAdvice.exec();
return result;
}
}

public class DynamicProxy {
public static T newProxyInstance(ClassLoader classLoader, Class[] interfaces, InvocationHandler handler) {
@SuppressWarnings("unchecked")
T t = (T) Proxy.newProxyInstance(classLoader, interfaces, handler);
return t;
}
}

public class AOPClient {
public static void main(String[] args) {
Subject realSubject = new RealSubject();
InvocationHandler handler = new MyInvocationHandler(realSubject);
ClassLoader classLoader = realSubject.getClass().getClassLoader();
Class[] interfaces = realSubject.getClass().getInterfaces();
Subject proxySubect = DynamicProxy.newProxyInstance(classLoader, interfaces, handler);
proxySubect.doSomething("这是一个Dynamic AOP示例！！！");
}
}
```

#### 应用场景

动态代理模式在实际开发中有着广泛的应用，尤其是在框架和中间件中。例如，Spring AOP、DBCP连接池、AspectJ等都大量使用了动态代理技术。

总结来说，动态代理模式提供了一种灵活的方式来增强现有类的功能，而无需修改其源代码。这对于构建可扩展、可维护的系统具有重要意义。