java几种代理方法
📜 1. 静态代理
思路:手动编写一个代理类,实现与目标类相同的接口,在方法中“包裹”目标对象。
接口与目标类
public interface UserService {
void addUser(String user);
}
public class UserServiceImpl implements UserService {
@Override
public void addUser(String user) {
System.out.println("添加用户: " + user);
}
}
代理类与调用
public class UserServiceProxy implements UserService {
private final UserService target;
public UserServiceProxy(UserService target) { this.target = target; }
@Override
public void addUser(String user) {
System.out.println("[代理] 验证权限..."); // 前置增强
target.addUser(user); // 调用目标方法
System.out.println("[代理] 记录日志..."); // 后置增强
}
}
// 使用
UserService real = new UserServiceImpl();
UserService proxy = new UserServiceProxy(real);
proxy.addUser("张三");
输出:
[代理] 验证权限...
添加用户: 张三
[代理] 记录日志...
静态代理的代理关系在编译时就已固定。
⚙️ 2. JDK 动态代理
思路:基于 java.lang.reflect.Proxy 和 InvocationHandler,在运行时为接口动态生成代理对象。
接口与目标类(同上,或新建一个)
public interface Animal { void speak(); }
public class Dog implements Animal {
public void speak() { System.out.println("汪汪汪!"); }
}
处理器与调用
import java.lang.reflect.*;
public class AnimalInvocationHandler implements InvocationHandler {
private final Object target;
public AnimalInvocationHandler(Object target) { this.target = target; }
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("[动态代理] 方法调用前...");
Object result = method.invoke(target, args);
System.out.println("[动态代理] 方法调用后...");
return result;
}
}
// 使用
Animal real = new Dog();
Animal proxy = (Animal) Proxy.newProxyInstance(
real.getClass().getClassLoader(),
real.getClass().getInterfaces(),
new AnimalInvocationHandler(real)
);
proxy.speak();
输出:
[动态代理] 方法调用前...
汪汪汪!
[动态代理] 方法调用后...
JDK 动态代理的硬性条件是目标类必须实现接口,否则无法生成代理。
🧬 3. CGLIB
思路:通过继承目标类生成子类代理,因此不要求目标类实现接口,但无法代理 final 类或 final 方法。
Maven 依赖
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>3.3.0</version>
</dependency>
目标类(无需接口)
public class UserService {
public void save() { System.out.println("保存用户"); }
}
拦截器与调用
import net.sf.cglib.proxy.*;
import java.lang.reflect.Method;
public class MyInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("前置增强");
Object result = proxy.invokeSuper(obj, args); // 调用父类(目标类)方法
System.out.println("后置增强");
return result;
}
}
// 使用
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserService.class);
enhancer.setCallback(new MyInterceptor());
UserService proxy = (UserService) enhancer.create();
proxy.save();
输出:
前置增强
保存用户
后置增强
CGLIB 的核心是 Enhancer 和 MethodInterceptor,通过继承实现,所以对 final 成员无能为力。
🚀 4. Byte Buddy
思路:现代化字节码库,API 更流畅,支持类、接口、方法级细粒度拦截。
Maven 依赖
<dependency>
<groupId>net.bytebuddy</groupId>
<artifactId>byte-buddy</artifactId>
<version>1.14.18</version>
</dependency>
目标类与拦截逻辑
public class Foo {
public String sayHelloFoo() { return "Hello in Foo!"; }
}
public class Bar {
public static String sayHelloBar() { return "Holla in Bar!"; }
}
生成代理并委托
import net.bytebuddy.ByteBuddy;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.matcher.ElementMatchers;
Foo proxy = new ByteBuddy()
.subclass(Foo.class)
.method(ElementMatchers.named("sayHelloFoo"))
.intercept(MethodDelegation.to(Bar.class))
.make()
.load(Foo.class.getClassLoader())
.getLoaded()
.newInstance();
System.out.println(proxy.sayHelloFoo()); // 输出: Holla in Bar!
Byte Buddy 用 subclass() 生成子类,用 method(...).intercept(...) 指定拦截逻辑,并将调用委托给 Bar 中的同名同签名方法。它比 CGLIB 更现代,在 Mockito、Spring Boot 等项目中都有应用。
🔧 5. ASM
思路:最底层的字节码操作框架,通过 ClassReader → ClassVisitor(增强逻辑)→ ClassWriter 直接改写字节码。不建议用于普通业务代理,多用于 Java Agent、APM 探针等底层场景。
Maven 依赖
<dependency>
<groupId>org.ow2.asm</groupId>
<artifactId>asm</artifactId>
<version>9.7</version>
</dependency>
核心生成框架(示意)
import org.objectweb.asm.*;
public class AsmProxyGenerator {
public static byte[] enhance(byte[] originalClassBytes) {
ClassReader reader = new ClassReader(originalClassBytes);
ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
ClassVisitor visitor = new ClassVisitor(Opcodes.ASM9, writer) {
@Override
public MethodVisitor visitMethod(int access, String name, String descriptor,
String signature, String[] exceptions) {
MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
return new MethodVisitor(Opcodes.ASM9, mv) {
@Override
public void visitCode() {
super.visitCode();
// 在方法字节码最前面插入:System.out.println("方法被代理");
mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out",
"Ljava/io/PrintStream;");
mv.visitLdcInsn("方法被代理");
mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println",
"(Ljava/lang/String;)V", false);
}
};
}
};
reader.accept(visitor, ClassReader.SKIP_DEBUG);
return writer.toByteArray();
}
}
ASM 的 AOP 流程本质是 读取 → 访问并修改 → 输出字节码,需要开发者对 JVM 指令(如 visitFieldInsn、visitMethodInsn)有直接理解。实际使用中通常结合 ASMifier 工具生成骨架代码,而非手写全部指令。
🛠️ 6. Javassist
思路:用接近 Java 源码的字符串来定义增强逻辑,比 ASM 更易上手,Dubbo 等 RPC 框架用它生成代理。
Maven 依赖
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.30.2-GA</version>
</dependency>
目标类
public class Foo {
public void bar() { System.out.println("Foo.bar() 执行"); }
}
ProxyFactory + MethodHandler
import javassist.util.proxy.*;
import java.lang.reflect.Method;
public class JavassistProxyDemo {
public static void main(String[] args) throws Exception {
ProxyFactory factory = new ProxyFactory();
factory.setSuperclass(Foo.class); // 继承 Foo 生成子类
MethodHandler handler = new MethodHandler() {
@Override
public Object invoke(Object self, Method m, Method proceed, Object[] args) throws Throwable {
System.out.println("方法调用前: " + m.getName());
Object result = proceed.invoke(self, args); // 执行原方法
System.out.println("方法调用后");
return result;
}
};
Foo proxy = (Foo) factory.create(new Class[0], new Object[0], handler);
proxy.bar();
}
}
输出:
方法调用前: bar
Foo.bar() 执行
方法调用后
ProxyFactory 通过 setSuperclass 指定目标类,MethodHandler 中的 proceed 负责回调原方法。Javassist 官方推荐使用 factory.create(..., handler) 这种一步到位的方式,并为代理工厂保持缓存默认开启,避免重复生成类导致 Metaspace 压力。
💎 小结
| 方式 | 核心入口 | 是否需要接口 | 典型用途 |
|---|---|---|---|
| 静态代理 | 手写类 | 是(或继承同一父类) | 简单、固定增强 |
| JDK 动态代理 | Proxy + InvocationHandler |
是 | Spring AOP(有接口时) |
| CGLIB | Enhancer + MethodInterceptor |
否 | Spring AOP(无接口时) |
| Byte Buddy | ByteBuddy DSL |
否 | Mockito、监控、Agent |
| ASM | ClassReader/Visitor/Writer |
否 | APM 探针、底层字节码改写 |
| Javassist | ProxyFactory + MethodHandler |
否 | Dubbo 等 RPC 代理生成 |
如果你希望针对其中某一种(比如 Byte Buddy 的拦截器写法或 ASM 的完整可编译示例)再深入,可以告诉我。

浙公网安备 33010602011771号