Java代理模式原理与应用解析

**Java代理模式详解与使用方法：** 深入理解Java代理模式，这是一种强大的结构型设计模式，通过代理对象控制对目标对象的访问，实现功能增强而无需修改目标类代码。本文详细解析三种代理模式：静态代理、JDK动态代理和CGLIB动态代理。静态代理结构清晰但扩展性有限；JDK动态代理利用Proxy和InvocationHandler在运行时生成代理，适用于目标类实现接口的场景，便于共用代理逻辑；CGLIB则通过继承目标类实现代理，适用于无接口的情况，但存在目标类不能为final的限制。Spring AOP默认优先使用JDK动态代理，无接口时采用CGLIB。掌握代理模式，提升代码的灵活性和可维护性。

代理模式通过代理对象控制对目标对象的访问，可在不修改目标类的情况下增强功能。1. 静态代理需手动编写代理类并实现与目标类相同的接口，结构清晰但扩展性差；2. JDK动态代理利用Proxy和InvocationHandler在运行时生成代理类，要求目标类实现接口，适合共用代理逻辑；3. CGLIB通过继承目标类生成子类实现代理，适用于无接口场景，但目标类不能为final。Spring AOP默认优先使用JDK动态代理，若目标类未实现接口则采用CGLIB。

代理模式是一种结构型设计模式，它允许你提供一个代理对象来控制对另一个对象的访问。在Java中使用代理模式，通常用于延迟加载、权限控制、日志记录或远程调用等场景。核心思想是：代理类和目标类实现相同的接口，客户端通过代理类间接访问目标类，从而可以在不修改目标类的前提下增强其功能。

静态代理

静态代理要求代理类和被代理类实现同一个接口，并在代理类中持有被代理类的实例。

定义一个公共接口：

public interface Service {
    void execute();
}

目标类实现接口：

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

代理类也实现同一接口，并包含目标对象：

public class ServiceProxy implements Service {
    private Service realService;

    public ServiceProxy(Service realService) {
        this.realService = realService;
    }

    public void execute() {
        System.out.println("代理：开始前处理（如日志）");
        realService.execute();
        System.out.println("代理：结束后处理（如清理）");
    }
}

使用方式：

Service service = new RealService();
Service proxy = new ServiceProxy(service);
proxy.execute();

优点是结构清晰，缺点是每个目标类都需要写一个对应的代理类，扩展性差。

动态代理（JDK Proxy）

JDK动态代理通过java.lang.reflect.Proxy类和InvocationHandler接口实现，无需为每个类编写代理类。

关键点是代理类在运行时自动生成，只要目标类实现了接口，就可以为其创建代理。

定义InvocationHandler实现：

import java.lang.reflect.*;

public class LoggingHandler implements InvocationHandler {
    private Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用方法前：" + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("调用方法后：" + method.getName());
        return result;
    }
}

使用动态代理创建代理对象：

RealService realService = new RealService();
LoggingHandler handler = new LoggingHandler(realService);

Service proxy = (Service) Proxy.newProxyInstance(
    realService.getClass().getClassLoader(),
    realService.getClass().getInterfaces(),
    handler
);

proxy.execute();

这种方式灵活，适合多个实现接口的类共用同一套代理逻辑。

CGLIB 动态代理

如果目标类没有实现接口，JDK动态代理无法使用。这时可以使用CGLIB库，它通过继承方式生成子类来实现代理。

需要添加CGLIB依赖（Maven）：

    cglib
    cglib
    3.3.0

定义一个没有接口的类：

public class SimpleService {
    public void doWork() {
        System.out.println("执行工作");
    }
}

使用CGLIB创建代理：

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

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.invoke(target, args);
        System.out.println("方法调用后");
        return result;
    }

    public static Object createProxy(Object target) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(new CglibProxy(target));
        return enhancer.create();
    }
}

使用方式：

SimpleService service = new SimpleService();
SimpleService proxy = (SimpleService) CglibProxy.createProxy(service);
proxy.doWork();

CGLIB适用于没有接口的类，但要求类不能是final，方法也不能是final或private。

Java中使用代理模式有三种常见方式：

• 静态代理：手动编写代理类，适合简单固定场景
• JDK动态代理：基于接口，运行时生成代理，使用广泛
• CGLIB代理：基于继承，可代理无接口的类，需引入第三方库

选择哪种方式取决于目标类是否实现接口以及项目依赖。Spring框架中AOP默认优先使用JDK动态代理，若无接口则使用CGLIB。

理论要掌握，实操不能落！以上关于《Java代理模式原理与应用解析》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！