Java动态代理：浅度和深度代理的区别实例

原创 Love The Way You Lie 2024-10-15 07:27 23阅读 0赞

在Java中，动态代理是一种在运行时创建对象的机制。通过反射API实现，主要涉及Proxy类、InvocationHandler接口等。

**浅度代理（Proxying）：**

1. **原生方式：** 使用java.lang.reflect.Proxy直接创建对象。
```java
// 创建一个代理对象
MyService service = (MyService) Proxy.newProxyInstance(
    MyClass.class.getClassLoader(),
    new Class[]{MyService.class}, 
    new InvocationHandler() {
        // 实现服务方法的逻辑
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 在这里处理真实对象的方法调用
            return method.invoke(service, args);
        }
    });
```
2. **Spring AOP：** 使用AOP代理，通常通过配置文件定义切面。
```java
// Spring AOP配置
@Configuration
@Aspect
public class MyServiceAspect {

@Around("execution(* com.example.service.MyService.*(..))") // 指定目标方法
    public Object myMethod(ProceedingJoinPoint pjp) throws Throwable {
        // 在这里处理真实对象的方法调用
        return pjp.proceed();
    }
}
```
**深度代理（Stubbing）：**

1. **动态代码生成：** 通过编程语言（如Groovy、JavaScript等）动态生成代码实现服务方法的逻辑。
```java
// Groovy示例
import groovy.lang.GroovyShell;
import groovy.lang.Script;

def createServiceMethod(String methodSignature, Object... args) {
    // 创建GroovyShell和Script对象
    def shell = new GroovyShell();
    Script script = shell.parse("def ${methodSignature}($args){return $args}}");

// 调用方法并返回结果
    return script.invokeMethod(methodSignature, args));
}

// 使用示例
String myServiceMethodResponse = createServiceMethod(
    "myServiceMethod",
    "参数1",
    "参数2"
).toString();

println("服务方法响应: $myServiceMethodResponse");
```
2. **JDK动态代理（Java 5+）：** 相较于动态代码生成，JDK动态代理基于字节码重写，更加稳定且易于维护。
```java
// Java 5+示例
import java.lang.reflect.Proxy;
import java.util.Arrays;

public interface MyService {
    String doSomething(String arg1, String arg2));
}

class MyServiceImpl implements MyService {
    @Override
    public String doSomething(String arg1, String arg2)) {
        return "Result from " + arg1 + ", " + arg2;
    }
}

// 创建代理对象并调用方法
MyService service = (MyService) Proxy.newProxyInstance(
    MyService.class.getClassLoader(),
    new Class[]{MyService.class}, 
    new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 在这里处理真实对象的方法调用
            System.out.println("Invoking original method: " + method.getName());

// 调用真实服务方法
            String result = method.invoke(service, Arrays.asList(args))) instanceof String ? (String) result : result;

System.out.println("Result from invoked method: " + result);

return result;
        }
    });
}

public class Main {
    public static void main(String[] args) {
        MyService service = service();
        String response = service.doSomething("arg1", "arg2"));
        System.out.println("Final result: " + response);
    }

private static MyService service() {
        return new MyServiceImpl();
    }
}
```
在以上示例中，我们首先定义了目标接口（MyService）和实现类（MyServiceImpl）。然后创建了一个代理对象，并调用了真实服务方法。最终输出了调用真实服务方法的结果。