什么是动态代理？
在 Java
中，动态代理是一种代理模式的实现方式，它允许在运行时动态地创建代理类并动态地处理方法调用。
动态代理常用于解耦合、处理和其他对象交互相关的行为控制。
动态代理例子
下面是一个简单的Java动态代理示例，它演示了如何使用动态代理创建一个代理对象，以及如何在代理对象上调用方法并在方法调用前后执行一些操作：
首先，我们需要创建一个代理接口，定义一些方法：
1 2 3 4 public interface MyInterface { void doSomething () ; }
同时，也定义一个 MyInterface 的实现类：
1 2 3 4 5 6 public class MyInterfaceImpl implements MyInterface { @Override public void doSomething () { System.out.println("MyInterfaceImpl doSomething" ); } }
然后，创建一个实现 InvocationHandler
接口的处理器类，它将负责在代理对象上调用方法时执行额外的操作：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;public class MyInvocationHandler implements InvocationHandler { private final Object realObject; public MyInvocationHandler (Object realObject) { this .realObject = realObject; } @Override public Object invoke (Object proxy, Method method, Object[] args) throws Throwable { System.out.println("Before invoking " + method.getName()); Object result = method.invoke(realObject, args); System.out.println("After invoking " + method.getName()); return result; } }
接下来，我们可以在主程序中使用动态代理创建代理对象并调用方法：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 import java.lang.reflect.Proxy;public class Main { public static void main (String[] args) { MyInterface myInterface = new MyInterfaceImpl (); MyInvocationHandler handler = new MyInvocationHandler (myInterface); MyInterface proxy = (MyInterface) Proxy.newProxyInstance( MyInterface.class.getClassLoader(), new Class []{MyInterface.class}, handler ); proxy.doSomething(); } }
在上述示例中，我们首先定义了一个代理接口 MyInterface
，然后创建了一个实现了 InvocationHandler 接口的处理器类
MyInvocationHandler，
该处理器负责在方法调用前后输出日志。最后，在主程序中，我们使用
Proxy.newProxyInstance
方法创建了代理对象，并通过代理对象调用了方法。在方法调用前后，会执行处理器中的操作。
以上代码会输出：
1 2 3 Before invoking doSomething MyInterfaceImpl doSomething After invoking doSomething
我们可以看到，虽然我们好像是在调用 MyInterface
接口的方法，但是实际上又不单纯是调用这个方法，还在调用这个方法前后做了一些事情。
我们可以通过下图来更加直观地了解上面这个动态代理的例子到底做了什么：
1
这个图体现了使用 Java 动态代理的一些关键：
要使用 Java 中的 Proxy 来实现动态代理我们就需要定义
interface
我们需要通过 InvocationHandler
来调用被代理对象的方法，在 InvocationHandler 的
invoke
方法中，我们可以在调用被代理对象方法前后加一些自定义逻辑
需要通过 Proxy.newProxyInstance
创建代理对象，这个代理对象实现了我们指定的接口（也就是第二个参数传递的
interface）。
这个示例演示了如何使用动态代理创建代理对象，并在方法调用前后执行自定义的操作。在实际应用中，你可以根据需要自定义处理器类，以执行不同的操作，如日志记录、性能监测、事务管理等。
动态代理的使用场景
动态代理在 Java
中是用得非常多的，使用动态代理我们可以在不侵入代码的情况下，为类增加或修改行为。常见的使用场景如下：
RPC
在我们使用 Dubbo 的时候在我们服务端的类上加一个
@DubboService
注解就可以将一个类声明为可以被远程调用的服务了；
然后在客户端进行注入的时候，加上 @DubboReference
就可以将服务声明为一个远程服务了。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 @DubboService(version = "${product.service.version}") @Service public class ProductServiceRpcImpl implements ProductService { @Autowired private IProductService productService; @Override public Sku test (Long id) { return productService.test(); } } @Component public class ProductClient { @DubboReference( version = "${product.service.version}", cluster = "failfast", timeout = 5000, retries = 2, proxy = "jdk" // 一般情况不需要加这个配置 ) private ProductService productService; public void test () { System.out.println(productService.test(1L )); } }
在上面 Dubbo 客户端的代码中，我们在 @DubboReference
的注解中加了个 proxy = "jdk" 表示我们要使用 JDK
的动态代理，
但是我们需要知道的是，JDK 的动态代理性能上并不是最优的，所以 Dubbo
的默认代理方式不是 JDK 动态代理，上面指定 proxy
只是为了演示。
Dubbo
实现动态代理的方式有三种：bytebuddy、javassist、jdk。
我们可以通过下面代码验证一下上面的 ProductClient
是否真的使用了 JDK 的动态代理：
1 2 3 4 5 6 public void test () { System.out.println(productService.getClass()); System.out.println(Proxy.isProxyClass(productService.getClass())); }
从输出结果我们可以看到，productService 实际上就是 JDK
代理类的对象。
Spring 容器
我们知道 Spring
容器可以帮助我们注入一些对象，而这些被注入的对象都是代理对象，直接
new 出来的对象跟 Spring 注入的对象是不一样的：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 @Slf4j @SpringBootApplication @MapperScan("com.baiguiren.mapper") @RestController public class Main { @Autowired private PersonService personService; public static void main (String[] args) { SpringApplication.run(Main.class, args); } @GetMapping("/test") public void test () { System.out.println(personService.getClass()); PersonService personService1 = new PersonServiceImpl (); System.out.println(personService1.getClass()); } }
从上面这个例子我们发现，Spring 注入的对象，它的 Class
并不是我们所定义的那个类，而是一个代理类。
我的 aop 配置是
spring.aop.proxy-target-class=false，这样 Spring 会使用 JDK
代理，当然我们也可以去掉这个配置或者配置为 false，这样 Spring 会使用
CGLIB 来实现动态代理。
在使用 CGLIB 动态代理的时候，上面的
personService.getClass() 会输出
class (...).PersonServiceImpl$$EnhancerBySpringCGLIB$$23b7767d，
我们可以在输出中看到
$$EnhancerBySpringCGLIB$$，这就意味着我们拿到的注入的对象实际上是被
Spring 容器增强过的实例。
同样的，在我们使用 mybatis 的 Mapper
的时候，它也是一个代理：
1 2 3 4 5 6 7 8 9 10 11 @Service public class PersonServiceImpl implements PersonService { @Autowired private PersonMapper personMapper; @Override public Person find (int id) { System.out.println(personMapper instanceof Proxy); return personMapper.selectPersonById(id); } }
所以虽然我们定义了一个接口，里面什么内容也没写，但实际上底层会帮我们去实现一个类，然后基于这个类来创建实例。
事务管理
事实上，这也可以归到 2 中去，当然我们也可以在不使用 Spring
的情况下通过动态代理来实现事务管理：
1 2 3 4 5 6 7 8 9 10 11 12 13 @Component @Slf4j public class FooServiceImpl implements FooService { @Autowired private JdbcTemplate jdbcTemplate; @Override @Transactional(rollbackFor = RollbackException.class) public void insertThenRollback () throws RollbackException { jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ('BBB')" ); throw new RollbackException (); } }
这个例子中的 Transactional 其实也是 Spring
给我们提供的功能。通过 Transactional 注解，我们的
FooServiceImpl::insertThenRollback 会得到增强。
在我们抛出 RollbackException
的时候，这个方法中执行的操作将会被回滚，但是我们不需要手动去执行开启事务、提交事务、回滚事务的操作，比较方便。
上面的 insertThenRollback 转换为伪代码如下：
1 2 3 4 5 6 7 try { beginTransaction(); jdbcTemplate.execute("INSERT INTO FOO (BAR) VALUES ('BBB')" ); commit(); } catch (RollbackException e) { rollback(); }
通过上面这几个场景，相信我们已经体会到了动态代理的强大之处了，
当然实际中的使用远不止上面这几种场景。
代理模式
我们在文章开头就说了，动态代理是一种代理模式的实现方式。
现在我们再来看看代理模式的定义：
在不改变原始类（或叫被代理类）代码的情况下，通过引入代理类来给原始类附加功能。
一个很简单的例子如下，我们需要针对控制器中的所有方法做性能监测：
1 2 3 4 5 6 7 8 9 10 11 12 13 @GetMapping("/test1") public void test1 () throws InterruptedException { long start = System.currentTimeMillis(); System.out.println("test1..." ); Thread.sleep(100 ); long end = System.currentTimeMillis(); log.info("GET /test1: " + (end - start)); }
我们可以看到，上面这个例子实现的方式其实比较笨拙，如果我们有 100
个接口，上面的代码就得重复 100
遍，这种实现方式对开发人员是非常不友好的。
使用动态代理，我们可以有更加优雅的实现方式：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 public interface ITestController { void test1 () ; } public class TestController implements ITestController { @Override public void test1 () { System.out.println("test1..." ); } } @Slf4j public class ControllerInvocationHandler implements InvocationHandler { private final ITestController testController; public ControllerInvocationHandler (ITestController testController) { this .testController = testController; } @Override public Object invoke (Object proxy, Method method, Object[] args) throws Throwable { long start = System.currentTimeMillis(); Object result = method.invoke(testController, args); long end = System.currentTimeMillis(); log.info(method.getName() + " invoked: " + (end - start)); return result; } } ITestController testController = new TestController ();ITestController testControllerProxy = (ITestController) Proxy.newProxyInstance( testController.getClass().getClassLoader(), testController.getClass().getInterfaces(), new ControllerInvocationHandler (testController) ); testControllerProxy.test1();
当然，这也只是个例子，如果我们使用 Spring，我们可以通过
aspect 来实现上面这个功能。
同时，我们也发现，使用了动态代理之后，我们就不必在每一个方法中加上那些性能监测的代码了，这就可以将开发人员从繁琐的操作中解放出来了。
动态代理实现原理
了解了动态代理的基本使用、常用的使用场景之后，让我们再来了解一下它的实现原理（基于
JDK 1.8）。
还是以上一小节的例子来说明，在上面的例子中，我们为
ITestController
接口升成了一个代理对象，但是这个代理对象为什么可以直接调用被代理对象的方法呢？
这是因为，底层实际上是创建另一个继承自
java.lang.reflect.Proxy
的代理类，这个代理类实现了我们指定的
interfaces，而其中的方法体中，则会去调用实际被代理对象的方法。
这么说有点抽象，其实我们可以通过 Java 的一个命令行参数来让 Java
帮我们将升成的代理类保存到文件上：
1 2 -Dsun.misc.ProxyGenerator.saveGeneratedFiles=true
对于上一个例子中的 ITestController
的代理类，我们可以看到它的内容实际如下（项目目录下的
com/sun/proxy 文件夹）：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 package com.sun.proxy;public final class $Proxy69 extends Proxy implements ITestController { private static Method m3; public $Proxy69(InvocationHandler var1) throws { super (var1); } public final void test1 () throws { try { super .h.invoke(this , m3, (Object[])null ); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException (var3); } } static { try { m3 = Class.forName("com.baiguiren.ITestController" ).getMethod("test1" ); } ... } }
从生成的代码中，我们可以看到，所有对代理对象的方法调用，都委托给了
InvocationHandler::invoke 方法。
生成代理类的过程可以用下图表示（Proxy 类中的实现）：
2
Proxy 类中有两个方法会创建代理类，一个是
getProxyClass，另一个是
newProxyInstance，getProxyClass 获取
Class 对象，而 newProxyInstance
会基于这个代理类创建一个代理对象。上一步的两个方法中都会调用 getProxyClass0 来获取
Class
对象，这个方法会有缓存，如果之前已经创建则会从缓存获取，否则会新建一个
Class
如果是第一次创建代理类，则会通过 ProxyClassFactory
来创建一个新的 Class
在实际加载到内存之前，会通过 ProxyGenerator 的
generateProxyClass 方法来生成 Class
对象的字节码
通过 defineClass0 方法来创建一个 Class
对象。（这是一个 native 方法，具体实现由 JVM 提供）。
拿到了代理类，也就是上面那一段 $Proxy69
类所表示的类之后，就可以创建代理对象了。
因为这个代理类实现了我们指定的接口，所以是可以通过类型转换转换成不同的
interface 的，如
(ITestController) Proxy.newProxyInstance(...)。
最终，我们就拿到了一个实现了 ITestController
接口的代理对象，它的行为跟我们原来的对象完全一致，通过这种方式我们获得了一个附加了额外功能的代理对象。
其他实现动态代理的方式
除了使用 JDK 的动态代理之外，还有一种实现动态代理的方式是
CGLIB
动态代理，上面也有提及，他们都有一些局限性，需要根据我们的实际应用场景来选择。
比如，JDK 动态代理需要我们先定义 interface，而
CGLIB 是通过继承的方式来实现动态代理的，如果某个类有
final 标记，那它是无法使用 CGLIB
来做动态代理的。
本文主要是为了介绍动态代理的一些原理，至于其他代理方式，都是殊途同归的，所以本文不做过多探讨了。
总结
动态代理是一种 Java
编程技巧，通过在运行时生成代理类，它能够拦截对原始类的方法调用并在方法执行前后执行自定义操作，
这一特性使其广泛应用于解耦、性能监测、事务管理、RPC、AOP
等各种场景，提高了代码的可维护性和可扩展性。
最后，再简单总结一下本文的内容：
动态代理是一种代理模式的实现方式，它允许在运行时动态地创建代理类并动态地处理方法调用。
动态代理被广泛应用于 Spring 中，我们通过 @Autowired
注入的对象就是一个代理对象。
动态代理还被用于
RPC、事务管理等，可以将非业务代码放到代理层去实现
JDK 的动态代理是在运行时才根据 ClassLoader 和
interface 来创建 Class 的，具体加载到 JVM
的操作是底层帮我们实现的
还有一种很常见的动态代理方式是 CGLIB
动态代理，但它不能代理 final 类。
而使用 JDK 动态代理则需要先定义
interface，代理类会实现这些
interface，但是实际上还是会调用被代理对象的方法（通过
Invocationhandler）。
