spring-reading./spring-aop/spring-aop-jdkProxy/README.md

193 lines
8.5 KiB
Markdown
Raw Permalink Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

## JDK动态代理
- [JDK动态代理](#jdk动态代理)
- [一、基本信息](#一基本信息)
- [二、基本描述](#二基本描述)
- [三、主要功能](#三主要功能)
- [四、最佳实践](#四最佳实践)
- [五、源码分析](#五源码分析)
- [六、常见问题](#六常见问题)
### 一、基本信息
✒️ **作者** - Lex 📝 **博客** - [掘金](https://juejin.cn/user/4251135018533068/posts) 📚 **源码地址** - [github](https://github.com/xuchengsheng/spring-reading)
### 二、基本描述
JDK动态代理是一种在运行时生成代理类的机制它基于接口实现通过在代理类中重定向方法调用到实际对象并提供了InvocationHandler接口来实现代理对象方法调用的处理逻辑适用于AOP、远程方法调用等场景能够在不修改原始类的情况下实现横切关注点的统一管理提供更灵活和可维护的代码结构。
### 三、主要功能
1. **代理对象生成**
+ 在运行时生成代理对象,无需提前编写代理类的代码。
2. **接口实现**
+ 动态代理是基于接口的,可以为接口生成代理对象,而不是具体的类。
3. **方法重定向**
+ 代理对象可以重定向方法调用到实际对象,允许在方法调用前后执行一些额外逻辑。
4. **横切关注点的统一管理**
+ 通过代理对象,在方法调用前后执行统一的逻辑,如日志记录、权限验证、事务管理等,实现了横切关注点的统一管理。
5. **AOP的实现**
+ 动态代理是AOP面向切面编程的基础之一可以通过动态代理实现切面的横切关注点将应用程序核心业务逻辑与横切关注点分离开来提高了代码的可维护性和灵活性。
### 四、最佳实践
使用 JDK 动态代理的基本流程。首先,创建目标对象 `MyService` 的实例,然后获取目标对象的类信息。接着,通过调用 `Proxy.newProxyInstance` 方法创建代理对象,传入目标对象的类加载器、实现的接口以及调用处理器。最后,通过代理对象调用方法,实际上会调用 `MyInvocationHandler` 中的 `invoke` 方法来处理方法调用,并在方法执行前后添加额外的逻辑。
```java
public class JdkProxyDemo {
public static void main(String[] args) {
// 创建目标对象
MyService target = new MyServiceImpl();
// 获取目标对象的类对象
Class clz = target.getClass();
// 创建代理对象,并指定目标对象的类加载器、实现的接口以及调用处理器
MyService proxyObject = (MyService) Proxy.newProxyInstance(clz.getClassLoader(), clz.getInterfaces(), new MyInvocationHandler(target));
// 打印代理对象的类信息
System.out.println("ProxyObject = " + proxyObject.getClass());
// 通过代理对象调用方法,实际上会调用 MyInvocationHandler 中的 invoke 方法
proxyObject.doSomething();
}
}
```
实现了 `InvocationHandler` 接口,定义了一个名为 `MyInvocationHandler` 的类。该类包含一个私有属性 `target`,用于存储目标对象。构造函数接收一个目标对象作为参数,并将其存储在 `target` 属性中。在 `invoke` 方法中,会在目标方法执行前打印 "Before method execution",然后通过反射调用目标对象的方法,并获取方法的返回结果。最后,在目标方法执行后打印 "After method execution",并返回方法的结果。
```java
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 execution");
Object result = method.invoke(target, args);
System.out.println("After method execution");
return result;
}
}
```
定义了一个接口 `MyService`,其中包含一个抽象方法 `doSomething()`。然后,定义了一个实现了 `MyService` 接口的类 `MyServiceImpl`,并实现了 `doSomething()` 方法。
```java
public interface MyService {
void doSomething();
}
public class MyServiceImpl implements MyService {
@Override
public void doSomething() {
System.out.println("hello world");
}
}
```
运行结果,成功使用了 JDK 动态代理。首先打印了代理对象的类信息,确认了代理对象确实是由 `$Proxy0` 类生成的。接着,打印了 "Before method execution",表示方法执行前的逻辑已经被执行。然后调用了目标对象的 `doSomething()` 方法,输出了 "hello world"。最后打印了 "After method execution",表示方法执行后的逻辑也被执行了。这表明 JDK 动态代理成功地代理了目标对象的方法,并在方法执行前后执行了额外的逻辑。
```java
ProxyObject = class com.sun.proxy.$Proxy0
Before method execution
hello world
After method execution
```
### 五、源码分析
这段代码是通过 Arthas 工具反编译得到的结果。它是一个代理类,位于 `com.sun.proxy` 包下,命名为 `$Proxy0`。该类继承自 `Proxy` 类,并实现了 `MyService` 接口。在 `doSomething` 方法中,通过 `InvocationHandler` 对象的 `invoke` 方法调用了目标对象的 `doSomething` 方法。在静态代码块中,获取了 `java.lang.Object` 类中的 `equals`、`hashCode` 和 `toString` 方法,以及 `MyService` 接口中的 `doSomething` 方法的 `Method` 对象。
```java
package com.sun.proxy;
import com.xcs.spring.MyService;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements MyService {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy0(InvocationHandler invocationHandler) {
super(invocationHandler);
}
public final void doSomething() {
try {
this.h.invoke(this, m3, null);
return;
}
catch (Error | RuntimeException throwable) {
throw throwable;
}
catch (Throwable throwable) {
throw new UndeclaredThrowableException(throwable);
}
}
// ... [toString代码部分省略以简化]
// ... [hashCode代码部分省略以简化]
// ... [equals代码部分省略以简化]
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m3 = Class.forName("com.xcs.spring.MyService").getMethod("doSomething", new Class[0]);
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
return;
}
catch (NoSuchMethodException noSuchMethodException) {
throw new NoSuchMethodError(noSuchMethodException.getMessage());
}
catch (ClassNotFoundException classNotFoundException) {
throw new NoClassDefFoundError(classNotFoundException.getMessage());
}
}
}
```
### 六、常见问题
1. **代理对象的类型限制**
+ 由于 JDK 动态代理是基于接口实现的,因此只能代理实现了接口的类。如果目标对象没有实现接口,就无法使用 JDK 动态代理。
2. **无法代理 final 类和方法**
+ JDK 动态代理无法代理 final 类和 final 方法。因为 final 类无法被继承final 方法无法被重写,而动态代理需要生成代理类并继承目标类或实现目标接口。
3. **无法代理静态方法**
+ JDK 动态代理无法代理静态方法,因为动态代理是基于实例的,而静态方法是属于类的。
4. **性能开销**
+ 与静态代理相比JDK 动态代理的性能开销较大。动态代理在运行时生成代理类的字节码,并通过反射来调用方法,相比静态代理的直接方法调用,会增加额外的开销。
5. **泛型的处理**
+ 如果目标方法涉及泛型参数,代理对象可能无法正确处理。因为在泛型擦除后,代理对象无法获取到准确的泛型信息。
6. **调用堆栈的可读性**
+ 由于动态代理的调用会经过 `InvocationHandler`,可能会增加调用堆栈的深度,降低代码的可读性和调试的便利性。