AIGC标识 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 的完整可编译示例)再深入,可以告诉我。

posted @ 2026-11-19 23:19  SeedQi  阅读(2)  评论(0)    收藏  举报