AOP底层原理解析

1 什么是AOP:

1. AOP AspectOrientedPrograming面向切面编程
3. AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存）
5. Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码
7. AspecJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，
8. AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入

2 AOP底层原理;

1. 就是代理机制:
2. *动态代理:(JDK中使用)

• * JDK的动态代理,对实现了接口的类生成代理.

3 Spring的AOP代理:

1. JDK动态代理:对实现了接口的类生成代理
2. CGLib代理机制:对类生成代理

4 AOP的术语:

1. Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.
3. Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.
5. Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
7. Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下,Introduction可以在运行期为类动态地添加一些方法或Field.
9. Target(目标对象):代理的目标对象
11. Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.
12. 
    
13. Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类
15. Aspect(切面):是切入点和通知（引介）的结合

16. spring采用动态代理织入，而AspectJ采用编译期织入和类装在期织入

17. 对于不使用接口的业务类，无法使用JDK动态代理
18. CGlib采用非常底层字节码技术，可以为一个类创建子类，解决无接口代理问题

5 AOP的底层实现:

  5.1 JDK动态代理

1. JDK1.3引入动态代理技术
2. 编写动态代理程序
3. java.lang.reflect.Proxy
4. java.lang.reflect.InvocationHandler

1. import java.lang.reflect.InvocationHandler;
2. import java.lang.reflect.Method;
3. import java.lang.reflect.Proxy;
4. /**
5. * @Title: JDK的动态代理的机制
6. * @ClassName:JDKProxy.java
7. * @Description:
8. *
9. * @Copyright2016-2017  Powered By 研发中心
10. * @author: 王延飞
11. * @date:2016年9月19日 下午10:28:08
12. * @version V1.0
13. */
14. publicclassJDKProxyimplementsInvocationHandler[]{
15. privateUserDao userDao;
16. publicJDKProxy(UserDao userDao){
17. super();
18. this.userDao = userDao;
19. }
20. publicUserDao createProxy(){
21. UserDao proxy =(UserDao)Proxy.newProxyInstance(userDao.getClass()
22. .getClassLoader(), userDao.getClass().getInterfaces(),this);
23. return proxy;
24. }
25. // 调用目标对象的任何一个方法 都相当于调用invoke();
26. publicObject invoke(Object proxy,Method method,Object[] args)
27. throwsThrowable{
28. if("add".equals(method.getName())){
29. // 记录日志:
30. System.out.println("日志记录=================");
31. Object result = method.invoke(userDao, args);
32. returnresult;
33. }
34. return method.invoke(userDao, args);
35. }
36. }

5.2 CGLIB动态代理

1. 对于不使用接口的业务类，无法使用JDK动态代理
2. CGlib采用非常底层字节码技术，可以为一个类创建子类，解决无接口代理问题
3. import java.lang.reflect.Method;
4. import org.springframework.cglib.proxy.Enhancer;
5. import org.springframework.cglib.proxy.MethodInterceptor;
6. import org.springframework.cglib.proxy.MethodProxy;
7. /**
8. * 使用CGLib生成代理对象
9. *
10. */
11. publicclassCGLibProxyimplementsMethodInterceptor{
12. privateProductDao productDao;
13. publicCGLibProxy(ProductDao productDao){
14. super();
15. this.productDao = productDao;
16. }
17. publicProductDao createProxy(){
18. // 使用CGLIB生成代理:
19. // 1.创建核心类:
20. Enhancerenhancer=newEnhancer();
21. // 2.为其设置父类:
22. enhancer.setSuperclass(productDao.getClass());
23. // 3.设置回调:(相当于JDK动态代理中的回调)
24. enhancer.setCallback(this);
25. // 4.创建代理:
26. return(ProductDao) enhancer.create();
27. }
28. /** * @param proxy CGlib根据指定父类生成的代理对象 * @param method 拦截的方法 * @param args 拦截方法的参数数组 * @param methodProxy 方法的代理对象，用于执行父类的方法 * @return    */
29. publicObject intercept(Object proxy,Method method,Object[] args,
30. MethodProxy methodProxy)throwsThrowable{
31. if("add".equals(method.getName())){
32. System.out.println("日志记录==============");
33. //  放行代码：这里相当于JDK中的(method.invoke)
34. Object obj = methodProxy.invokeSuper(proxy, args);
35. return obj;
36. }
37. return methodProxy.invokeSuper(proxy, args);
38. }
39. }

5.3 代理总结

1. Spring在运行期，生成动态代理对象，不需要特殊的编译器
2. Spring AOP的底层就是通过JDK动态代理或CGLib动态代理技术为目标Bean执行横向织入

• 1.若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。
• 2.若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。

4. 程序中应优先对接口创建代理，便于程序解耦维护
5. 标记为final的方法，不能被代理，因为无法进行覆盖

• JDK动态代理，是针对接口生成子类，接口中方法不能使用final修饰
• CGLib是针对目标类生产子类，因此类或方法不能使final的

6. Spring只支持方法连接点，不提供属性连接