Java代理模式详解：动态与静态对比分析

本文深入解析Java代理模式，重点对比**静态代理**与**动态代理**的实现与应用。作为一种结构型设计模式，代理模式通过代理对象控制对真实对象的访问，常用于AOP、事务管理等场景。文章首先介绍了**静态代理**，强调其编译期生成、代码冗余的特点。随后详细讲解了**动态代理**，包括基于接口的**JDK动态代理**和基于继承的**CGLIB动态代理**，突出了动态代理的灵活性。最后，对比了两者在生成时机、灵活性、依赖条件和性能上的差异，并分析了各自的应用场景，帮助开发者根据实际需求选择合适的代理方式。掌握代理模式，提升代码可维护性和扩展性。

代理模式通过代理对象控制对真实对象的访问，分为静态代理和动态代理。静态代理在编译期生成，需为每个被代理类编写对应代理类，代码冗余；动态代理在运行时生成，包括JDK动态代理（基于接口）和CGLIB动态代理（基于继承），具有更高灵活性，适用于AOP、事务管理等场景。两者主要区别在于生成时机、灵活性、依赖条件和性能。

Java中的代理模式是一种结构型设计模式，它通过引入一个代理对象来控制对真实对象的访问。代理模式常用于增强功能、延迟加载、权限控制等场景。在Java中，主要分为静态代理和动态代理两种实现方式，它们的核心区别在于代理类的生成时机和灵活性。

静态代理的实现

静态代理是在程序编译阶段就确定代理类，代理类和被代理类实现相同的接口或继承相同父类。代理类持有被代理类的实例，在调用方法时可添加额外逻辑。

定义一个公共接口：

public interface Service {
    void execute();
}

真实对象实现接口：

public class RealService implements Service {
    public void execute() {
        System.out.println("执行实际业务");
    }
}

代理类也实现同一接口，并持有一个真实对象的引用：

public class StaticProxy implements Service {
    private Service target;

    public StaticProxy(Service target) {
        this.target = target;
    }

    public void execute() {
        System.out.println("前置处理");
        target.execute();
        System.out.println("后置处理");
    }
}

使用时创建代理对象：

Service real = new RealService();
Service proxy = new StaticProxy(real);
proxy.execute();

优点是结构简单，易于理解；缺点是每个被代理类都需要写一个对应的代理类，代码冗余，扩展性差。

动态代理的实现

动态代理的代理类在运行时由JVM动态生成，不需要手动编写代理类。Java提供了两种常见实现方式：JDK动态代理和CGLIB动态代理。

基于接口实现，使用java.lang.reflect.Proxy类和InvocationHandler接口。

示例：

import java.lang.reflect.*;

public class JdkDynamicProxy implements InvocationHandler {
    private Object target;

    public JdkDynamicProxy(Object target) {
        this.target = target;
    }

    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;
    }

    // 生成代理对象
    public Object getProxy() {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            this
        );
    }
}

使用方式：

RealService real = new RealService();
JdkDynamicProxy handler = new JdkDynamicProxy(real);
Service proxy = (Service) handler.getProxy();
proxy.execute();

JDK动态代理要求被代理类必须实现至少一个接口，内部通过反射机制调用方法。

基于继承实现，通过字节码技术为类创建子类，从而拦截方法调用。适用于没有实现接口的类。

需引入CGLIB库（如Maven依赖）：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

示例：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {
    private Object target;

    public CglibProxy(Object target) {
        this.target = target;
    }

    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;
    }

    public Object getProxy() {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }
}

使用：

RealService real = new RealService();
CglibProxy cglibProxy = new CglibProxy(real);
RealService proxy = (RealService) cglibProxy.getProxy();
proxy.execute();

CGLIB无需接口，但不能代理final类或final方法。

动态代理与静态代理的区别

• 生成时机：静态代理在编译期生成，动态代理在运行时生成代理类。
• 灵活性：动态代理更灵活，一套代码可适配多个类；静态代理每新增一个类就要写一个代理类。
• 依赖条件：JDK动态代理依赖接口，CGLIB依赖继承；静态代理两者都可，但需手动编码。
• 性能：静态代理性能最好，无反射开销；JDK动态代理有反射成本；CGLIB生成子类有一定开销，但调用性能较好。
• 应用场景：静态代理适合固定场景；动态代理广泛用于AOP、事务管理、RPC框架等需要通用拦截的场合。

本篇关于《Java代理模式详解：动态与静态对比分析》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！