Java 代理机制详解：从静态代理到动态代理，彻底掌握代理模式的原理与实战

大葱白菜
280 阅读7分钟

​

 作为一名 Java 开发工程师，你一定在使用 Spring、MyBatis、RPC 框架等技术时接触过“代理”（Proxy）这个概念。无论是 Spring 的 AOP（面向切面编程）、事务管理，还是远程调用、日志记录、权限控制等场景，代理机制都扮演着至关重要的角色。

本文将带你全面掌握：

  • 什么是代理？
  • 静态代理与动态代理的区别
  • JDK 动态代理与 CGLIB 动态代理的实现原理
  • 代理模式的典型应用场景
  • 代理在主流框架中的使用（如 Spring AOP、MyBatis）
  • 代理的优缺点与最佳实践

并通过丰富的代码示例和真实项目场景讲解，帮助你写出更优雅、更灵活、更高级的 Java 代理代码。

🧠 一、什么是代理（Proxy）？

✅ 定义：

代理是一种设计模式，它为某个对象提供一个代理对象，以控制对该对象的访问。代理对象可以在不修改目标对象的前提下，为其添加额外功能。

✅ 代理的核心作用：

作用描述
控制访问限制或增强对目标对象的访问
增强功能在调用前后插入额外逻辑（如日志、事务、权限）
解耦调用将调用逻辑与业务逻辑分离
实现 AOP面向切面编程的基础
实现远程调用如 RMI、Dubbo 中的远程代理

🧪 二、代理的分类

✅ 1. 静态代理（Static Proxy）

定义：

在编译阶段就已经确定代理类和目标类的关系，代理类需要手动编写。

示例：

// 接口
public interface UserService {
    void addUser();
}

// 目标类
public class UserServiceImpl implements UserService {
    @Override
    public void addUser() {
        System.out.println("添加用户");
    }
}

// 代理类
public class UserServiceProxy implements UserService {
    private UserService target;

    public UserServiceProxy(UserService target) {
        this.target = target;
    }

    @Override
    public void addUser() {
        System.out.println("日志记录开始");
        target.addUser();
        System.out.println("日志记录结束");
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        UserService target = new UserServiceImpl();
        UserService proxy = new UserServiceProxy(target);
        proxy.addUser(); // 调用代理
    }
}

优点：

  • 简单直观，适合少量接口代理

缺点：

  • 代理类需要手动编写，扩展性差
  • 接口多时代码冗余严重
  • 不适合通用逻辑处理

✅ 2. 动态代理（Dynamic Proxy）

定义：

在运行时动态生成代理类，无需手动编写。Java 提供了两种主要方式：

  • JDK 动态代理（基于接口）
  • CGLIB 动态代理（基于继承，适用于类）

🧩 三、JDK 动态代理详解

✅ 原理：

JDK 动态代理基于 java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler，只能代理实现了接口的类。

✅ 示例：

import java.lang.reflect.*;

// 接口
public interface OrderService {
    void createOrder();
}

// 实现类
public class OrderServiceImpl implements OrderService {
    @Override
    public void createOrder() {
        System.out.println("创建订单");
    }
}

// 动态代理处理器
public class DynamicProxyHandler implements InvocationHandler {
    private Object target;

    public DynamicProxyHandler(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;
    }
}

// 使用
public class Main {
    public static void main(String[] args) {
        OrderService target = new OrderServiceImpl();
        OrderService proxy = (OrderService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new DynamicProxyHandler(target)
        );
        proxy.createOrder(); // 调用代理方法
    }
}

✅ 特点：

特点描述
代理对象是接口的实现类必须有接口才能使用
运行时动态生成无需手动编写代理类
基于反射调用性能略低
Spring AOP 默认使用当目标类实现接口时使用

🧩 四、CGLIB 动态代理详解

✅ 原理：

CGLIB（Code Generation Library）是一个基于 ASM 字节码操作的动态代理库，它通过继承目标类生成子类，从而实现代理，不需要接口。

✅ 示例：

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 OrderService {
    public void createOrder() {
        System.out.println("创建订单");
    }
}

// CGLIB 代理处理器
public class CglibProxy implements MethodInterceptor {
    private Object target;

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

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

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

// 使用
public class Main {
    public static void main(String[] args) {
        OrderService target = new OrderService();
        OrderService proxy = (OrderService) new CglibProxy(target).getProxy();
        proxy.createOrder();
    }
}

✅ 特点：

特点描述
无需接口可以代理没有实现接口的类
通过继承生成子类类似于“继承增强”
更强大的灵活性适用于更多场景
Spring AOP 默认使用当目标类未实现接口时使用

🧪 五、代理在主流框架中的应用

✅ 1. Spring AOP（面向切面编程）

Spring AOP 利用代理实现日志记录、事务管理、权限控制等通用逻辑。

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void before(JoinPoint joinPoint) {
        System.out.println("方法调用前：" + joinPoint.getSignature().getName());
    }
}

Spring 内部会根据是否有接口自动选择使用 JDK Proxy 或 CGLIB Proxy。

✅ 2. MyBatis Mapper 接口代理

MyBatis 通过动态代理将接口方法绑定到 SQL 映射文件。

@Mapper
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User selectById(Long id);
}

MyBatis 会为 UserMapper 接口生成代理类，调用时自动执行 SQL。

✅ 3. Dubbo、RMI 等 RPC 框架

远程调用中，客户端通过代理对象发起远程调用，屏蔽网络细节。

UserService proxy = ProxyFactory.getProxy(UserService.class);
User user = proxy.getUserById(1L);

⚠️ 六、代理的优缺点对比

✅ 优点：

优点描述
解耦调用与逻辑实现关注点分离
增强功能灵活可在调用前后插入任意逻辑
支持 AOP 编程是 Spring AOP 的基础
提高可扩展性可插拔式增强逻辑
降低代码冗余避免重复代码（如日志、事务）

❌ 缺点：

缺点描述
性能开销反射和字节码生成有一定性能损耗
调试困难代理对象可能隐藏原始调用逻辑
可读性差代理逻辑可能分散，不易维护
学习成本高需要理解动态代理、AOP、ASM 等底层机制
滥用风险过度使用可能导致代码“魔术化”

🧱 七、代理的最佳实践

实践描述
明确代理目的如日志、事务、权限等
优先使用接口代理尽量使用 JDK 动态代理
合理使用 CGLIB针对无接口的类
避免嵌套代理降低复杂度
封装代理逻辑如自定义 AOP 工具类
结合注解使用如 @Aspect、@Around
使用缓存机制提升代理性能
配合 Spring 使用简化 AOP 配置与使用

🚫 八、常见误区与注意事项

误区正确做法
不理解代理原理应理解 JDK Proxy 与 CGLIB 的区别
滥用动态代理应避免在高频调用中使用
不处理异常应在代理中捕获并处理异常
不封装代理逻辑应封装为通用工具类
不结合 AOP 使用应优先使用 Spring AOP 简化开发
不考虑性能应评估代理对性能的影响
不理解 Spring 的代理机制应了解 Spring AOP 的自动选择策略

📊 九、总结：Java 代理核心知识点一览表

内容说明
静态代理手动编写代理类，适合少量接口
JDK 动态代理基于接口，运行时生成代理类
CGLIB 动态代理基于继承，适用于无接口类
InvocationHandlerJDK 动态代理的核心接口
MethodInterceptorCGLIB 的核心接口
Spring AOP使用代理实现日志、事务等
MyBatis Mapper接口通过代理绑定 SQL
RPC 框架客户端通过代理发起远程调用
代理优点解耦、增强、AOP、扩展性强
代理缺点性能、调试、学习成本、滥用风险

💡 结语

Java 代理机制是 Java 中最强大、最灵活的特性之一，它为 AOP、远程调用、事务管理等提供了坚实的基础。掌握代理的原理与使用，是每一个 Java 开发工程师进阶为高级开发者的必经之路。

无论你是开发 Web 应用、中间件、插件系统，还是构建自己的通用工具类，代理机制都能为你提供极大的灵活性和扩展性。

📌 关注我，获取更多 Java 核心技术深度解析！

​

avatar
文章
阅读
粉丝