代理模式是在不修改原有代码逻辑的情况下，对原有代码逻辑增强的一种方式，要了解什么是动态代理，首先要知道什么是静态代理。
一、静态代理
假设一种场景，一个汽车类（Car）有一个启动方法（run），我在不修改业务逻辑的情况下，我想知道启动汽车花了多长时间该如何实现呢？
公共的汽车接口
/** * 机动车接口 * */ public interface Auto { void run() throws Exception; }
小汽车实现类
/** * 机动车接口 * */ public class Car implements Auto { public void run() throws Exception { //模拟方法执行过程 Thread.sleep(new Random().nextInt(10)); System.out.println("Car run"); } }
通过代理类实现对原有方法的增强，代理类实现相同的接口，并将被代理类指派给代理类的属性对象。
/** * 代理类 */ public class AutoProxy implements Auto { Auto auto; public AutoProxy(Auto auto) { this.auto = auto; } @Override public void run() throws Exception { long start = System.currentTimeMillis(); auto.run(); long end = System.currentTimeMillis(); System.out.println("启动时间：" + (end - start)); } }
运行代理类
public class Main { public static void main(String[] args) throws Exception { AutoProxy proxy = new AutoProxy(new Car()); proxy.run(); } }
Car run 启动时间：1
静态代理的几个要素：
接口：Auto
被代理类：Car
代理类：AutoProxy，实现相同接口，对原实现类进行增强
静态代理的特点是在程序编译期就已经编译好了，即代理类在运行之前就已经存在了。假如随着业务的发展，不光有小汽车，还出现了公交车（Bus），警车（Police Car）等等，如果用静态代理，需要为每个被代理类实现一个代理类，那有没有更优雅的方式呢？答案就是动态代理。
二、动态代理
动态代理模式下，代理类实现InvocationHandler接口，被代理的业务无任何侵入，即可实现对一组接口实现类的增强。
代理类
/** * 动态代理 */ public class DynamicAutoProxy implements InvocationHandler { Auto auto; public Object bind(Auto auto) { this.auto = auto; //生成代理对象 //第一个参数为被代理类的类加载器 //第二个参数为被代理类的接口 //第三个参数为代理类实例，这里传入this return Proxy.newProxyInstance(auto.getClass().getClassLoader(), auto.getClass().getInterfaces(), this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { long start = System.currentTimeMillis(); //反射调用实际的方法 Object object = method.invoke(auto, args); long end = System.currentTimeMillis(); System.out.println("启动时间：" + (end - start)); return object; } }
动态代理类的几个要素：
1、被代理对象（Car、Bus）
2、执行者对象（DynamicAutoProxy）
3、代理对象，在执行者对象中通过Proxy.newProxyInstance生成的代理对象。
运行代理类
public class Main { public static void main(String[] args) throws Exception { DynamicAutoProxy proxy = new DynamicAutoProxy(); Auto car = (Auto) proxy.bind(new Car()); car.run(); Auto bus = (Auto) proxy.bind(new Bus()); bus.run(); } }
Car run 启动时间：1 Bus run 启动时间：5
代理对象Proxy是如何生成的呢，跟踪下源码可以看出，只是对创建动态代理类的过程进行了封装。
@CallerSensitive public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException { // 执行者对象判空 Objects.requireNonNull(h); // 复制被代理类的接口 final Class<?>[] intfs = interfaces.clone(); final SecurityManager sm = System.getSecurityManager(); if (sm != null) { checkProxyAccess(Reflection.getCallerClass(), loader, intfs); } // 通过类加载器生成指定代理类 Class<?> cl = getProxyClass0(loader, intfs); /* * Invoke its constructor with the designated invocation handler. */ try { if (sm != null) { checkNewProxyPermission(Reflection.getCallerClass(), cl); } final Constructor<?> cons = cl.getConstructor(constructorParams); final InvocationHandler ih = h; if (!Modifier.isPublic(cl.getModifiers())) { AccessController.doPrivileged(new PrivilegedAction<Void>() { public Void run() { cons.setAccessible(true); return null; } }); } // 实例化一个Proxy代理对象 return cons.newInstance(new Object[]{h}); } catch (IllegalAccessException|InstantiationException e) { throw new InternalError(e.toString(), e); } catch (InvocationTargetException e) { Throwable t = e.getCause(); if (t instanceof RuntimeException) { throw (RuntimeException) t; } else { throw new InternalError(t.toString(), t); } } catch (NoSuchMethodException e) { throw new InternalError(e.toString(), e); } }
动态代理本质上是在代码运行的过程中动态的创建了Proxy代理对象。
jdk动态代理的前提是被代理类实现了接口，如果没有实现接口又将如何代理呢，cglib动态代理就是为了解决这个问题。
springboot中通过@EnableAspectJAutoProxy与@Aspect注解实现动态代理，实际上@SpringBootApplication会自动开启@EnableAspectJAutoProxy，不需要手工指定。
可通过下面代码跟踪
@SpringBootApplication->@EnableAutoConfiguration->spring.factories->@AopAutoConfiguration->@EnableAspectJAutoProxy
public @interface EnableAspectJAutoProxy { // true: 使用cglib代理，false：使用jdk动态代理，默认为false boolean proxyTargetClass() default false; //是否通过aop框架暴露代理对象 boolean exposeProxy() default false; }
