AOP（Aspect Orient Programming），一般称为面向切面编程，作为面向对象的一种补充，用于处理系统中分布于各个模块的横切关注点，比如事务管理，日志，缓存等等.AOP 实现的关键在于AOP框架自动创建的AOP代理，AOP代理主要分为静态代理和动态代理，静态代理的代表为AspectJ;而动态代理则以Spring AOP为代表。静态代理是编译期实现，动态代理是运行期实现，可想而知前者拥有更好的性能。
本文主要介绍Spring AOP的两种代理实现机制，JDK动态代理和CGLIB动态代理。
静态代理是编译阶段生成AOP代理类，也就是说生成的字节码就织入了增强后的AOP对象;动态代理则不会修改字节码，而是在内存中临时生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。
Spring AOP中的动态代理主要有两种方式，JDK动态代理和CGLIB动态代理.JDK动态代理通过反射来接收被代理的类，并且要求被代理的类必须实现一个接口.JDK动态代理的核心是InvocationHandler接口和代理类。
如果目标类没有实现接口，那么Spring AOP会选择使用CGLIB来动态代理目标类.CGLIB（代码生成库），是一个代码生成的类库，可以在运行时动态的生成某个类的子类，注意，CGLIB是通过继承的方式做的动态代理，因此如果某个类被标记为最终的，那么它是无法使用CGLIB做动态代理的，诸如私人的方法也是不可以作为切面的。
我们分别通过实例来研究AOP的具体实现。
直接使用Spring AOP
首先定义需要切入的接口和实现。为了简单起见，定义一个口述接口和一个具体的实现类，只有两个方法的sayHi（）和sayBye（）。
public interface Speakable { void sayHi(); void sayBye();}
@Servicepublic class PersonSpring implements Speakable { @Override public void sayHi() { try { Thread.currentThread().sleep(30); } catch (Exception e) { throw new RuntimeException(e); } System.out.println("Hi!!"); } @Override public void sayBye() { try { Thread.currentThread().sleep(10); } catch (Exception e) { throw new RuntimeException(e); } System.out.println("Bye!!"); }}
接下来我们希望实现一个记录的sayHi（）和sayBye（）执行时间的功能。
定义一个MethodMonitor类用来记录方法执行时间
public class MethodMonitor { private long start; private String method; public MethodMonitor(String method) { this.method = method; System.out.println("begin monitor.."); this.start = System.currentTimeMillis(); } public void log() { long elapsedTime = System.currentTimeMillis() - start; System.out.println("end monitor.."); System.out.println("Method: " + method + ", execution time: " + elapsedTime + " milliseconds."); }}
光有这个类还是不够的，希望有个静态方法用起来更顺手，像这样
MonitorSession.begin();doWork();MonitorSession.end();
说干就干，定义一个MonitorSession
public class MonitorSession { private static ThreadLocal<MethodMonitor> monitorThreadLocal = new ThreadLocal<>(); public static void begin(String method) { MethodMonitor logger = new MethodMonitor(method); monitorThreadLocal.set(logger); } public static void end() { MethodMonitor logger = monitorThreadLocal.get(); logger.log(); }}
万事具备，接下来只需要我们做好切面的编码，
@Aspect@Componentpublic class MonitorAdvice { @Pointcut("execution (* com.deanwangpro.aop.service.Speakable.*(..))") public void pointcut() { } @Around("pointcut()") public void around(ProceedingJoinPoint pjp) throws Throwable { MonitorSession.begin(pjp.getSignature().getName()); pjp.proceed(); MonitorSession.end(); }}
如何使用？我用了spring boot，写一个启动函数吧。
@SpringBootApplicationpublic class Application { @Autowired private Speakable personSpring; public static void main(String[] args) { SpringApplication.run(Application.class, args); } @Bean public CommandLineRunner commandLineRunner(ApplicationContext ctx) { return args -> { // spring aop System.out.println("******** spring aop ******** "); personSpring.sayHi(); personSpring.sayBye(); System.exit(0); }; }}
运行后输出：
jdk动态代理
开始监控..
嗨!!
结束监视器。
方法：sayHi，执行时间：32毫秒。
开始监视..
再见!!
结束监视器。
方法：sayBye，执行时间：22毫秒。
JDK动态代理
刚刚的例子其实内部实现机制就是JDK动态代理，因为人实现了一个接口。
为了不和第一个例子冲突，我们再定义一个人来实现Speakable，这个实现是不带Spring Annotation的，所以他不会被Spring托管。
public class PersonImpl implements Speakable { @Override public void sayHi() { try { Thread.currentThread().sleep(30); } catch (Exception e) { throw new RuntimeException(e); } System.out.println("Hi!!"); } @Override public void sayBye() { try { Thread.currentThread().sleep(10); } catch (Exception e) { throw new RuntimeException(e); } System.out.println("Bye!!"); }}
重头戏来了，我们需要利用的InvocationHandler实现一个代理，让它去包含人这个对象。那么再运行期实际上是执行这个代理的方法，然后代理再去执行真正的方法。所以我们得以在执行真正方法的前后做一些手脚.JDK代理动态的英文利用反射实现，直接看代码。
public class DynamicProxy implements InvocationHandler { private Object target; public DynamicProxy(Object object) { this.target = object; } @Override public Object invoke(Object arg0, Method arg1, Object[] arg2) throws Throwable { MonitorSession.begin(arg1.getName()); Object obj = arg1.invoke(target, arg2); MonitorSession.end(); return obj; } @SuppressWarnings("unchecked") public <T> T getProxy() { return (T) Proxy.newProxyInstance( target.getClass().getClassLoader(), target.getClass().getInterfaces(), this ); }}
通过getProxy可以得到这个代理对象，调用就是具体的执行方法，可以看到我们在执行每个真正的方法前后都加了监视器。
我实现了一个工厂类来获取个人代理对象
public class PersonProxyFactory { public static Speakable newJdkProxy() { // 代理PersonImpl DynamicProxy dynamicProxy = new DynamicProxy(new PersonImpl()); Speakable proxy = dynamicProxy.getProxy(); return proxy; }}
具体使用
// jdk dynamic proxySystem.out.println("******** jdk dynamic proxy ******** ");Speakable jdkProxy = PersonProxyFactory.newJdkProxy();jdkProxy.sayHi();jdkProxy.sayBye();
输出结果：
******** jdk dynamic proxy ******** begin monitor..Hi!!end monitor..Method: sayHi, execution time: 32 milliseconds.begin monitor..Bye!!end monitor..Method: sayBye, execution time: 22 milliseconds.
CGLIB动态代理
我们再新建一个人来，这次不实现任何接口。
public class Person { public void sayHi() { try { Thread.currentThread().sleep(30); } catch (Exception e) { throw new RuntimeException(e); } System.out.println("Hi!!"); } public void sayBye() { try { Thread.currentThread().sleep(10); } catch (Exception e) { throw new RuntimeException(e); } System.out.println("Bye!!"); }}
如果春季识别到所代理的类没有实现接口，那么就会使用CGLIB来创建动态代理，原理实际上成为所代理类的子类。
public class CGLibProxy implements MethodInterceptor { private static CGLibProxy instance = new CGLibProxy(); private CGLibProxy() { } public static CGLibProxy getInstance() { return instance; } private Enhancer enhancer = new Enhancer(); @SuppressWarnings("unchecked") public <T> T getProxy(Class<T> clazz) { enhancer.setSuperclass(clazz); enhancer.setCallback(this); return (T) enhancer.create(); } @Override public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable { MonitorSession.begin(arg1.getName()); Object obj = arg3.invokeSuper(arg0, arg2); MonitorSession.end(); return obj; }}
类似的通过getProxy可以得到这个代理对象，拦截就是具体的执行方法，可以看到我们在执行每个真正的方法前后都加了监视器。
在工厂类中增加获得个人代理类的方法，
public static Person newCglibProxy() { CGLibProxy cglibProxy = CGLibProxy.getInstance(); Person proxy = cglibProxy.getProxy(Person.class); return proxy;}
具体使用
// cglib dynamic proxySystem.out.println("******** cglib proxy ******** ");Person cglibProxy = PersonProxyFactory.newCglibProxy();cglibProxy.sayHi();cglibProxy.sayBye();
输出结果：
开始监视..
嗨!!
结束监视器。
方法：sayHi，执行时间：53毫秒。
开始监视..
再见!!
结束监视器。
方法：sayBye，执行时间：14毫秒。
小结
对比JDK代理动态状语从句：CGLIB代理，在实际使用中发现CGLIB在创建代理对象时所花费的时间却比JDK动态代理要长，实测数据
Method: newJdkProxy, execution time: 5 milliseconds.Method: newCglibProxy, execution time: 18 milliseconds.
所以CGLIB更适合代理不需要频繁实例化的类。
在具体方法执行效率方面，理应是不通过反射的CGLIB更快一些，然后测试结果并非如此，还需要高手指教。
JDK
方法：sayHi，执行时间：32毫秒。
CGLib
方法：sayHi，执行时间：53毫秒。
文中代码：HTTPS：//github.com/deanwong/aop-study
扩展阅读
来源：http://www.importnew.com/28342.html
来源：https://www.cnblogs.com/javafirst0/p/10736421.html