什么是AOP

AOP详解（AOP概览），AOP面试
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
主要意图
将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。
[

](https://blog.csdn.net/dadiyang/article/details/82920139)
（1）：aop-面向切面（方面）编程，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
（2）：通俗易懂描述，不通过修改源代码方式，在主干功能中添加新代码进行实现新功能。
（3）：AOP实例
AOP - 图1

AOP（底层原理）

1：底层使用动态代理，什么是代理？什么是动态代理？
有俩种情况动态代理
1：有接口情况——JDK动态代理（创建接口实现类代理对象，增强类的方法）
AOP - 图2

2：没有接口情况——使用CGLIB动态代理（创建子类的代理对象，来增强类的方法）
AOP - 图3

JDK动态实现实现

1：使用jdk动态代理，需要使用Proxy类里的方法来创建代理对象，jdkApi
（1）：调用 java.lang.Object java.lang.reflect.Proxy中的newProxyInstance)
image.png
image.png
newProxyInstance) 方法有三个参数
1：第一个参数，类加载器
2：第二个参数：增强方法所在的类，这个类实现的接口，支持多接口
3：第三个参数：实现这个接口 InvocationHandler ，创建代理对象，主要是具体增强方法的内容

2：编写JDK动态代理，具体实现
（1）：创建接口，定义方法

  1. package com.junjay.spring5.dao;
  3. /**
  4.  * @author My
  5.  *    interface 接口关键字
  6.  */
  7. public interface UserDao{
  8.     public int add(int a,int b);
  9.     public String del(String id);
  10. }
  1. （2）：创建接口实现类，实现改接口
  1. package com.junjay.spring5.dao;
  3. import org.springframework.stereotype.Repository;
  5. /**
  6.  * @author My
  7.  *    implements 实现 UserDao 接口
  8.  *    
  9.  */
  10. @Repository
  11. public class UserDaoImpl implements UserDao{
  13.     @Override
  14.     public int add(int a, int b) {
  15.         System.out.println("UserDaoImpl 执行 add方法");
  16.         return a+b;
  17.     }
  19.     @Override
  20.     public String del(String id) {
  21.         System.out.println("UserDaoImpl 执行 del方法");
  22.         return id;
  23.     }
  25. }
  1. （3）：使用Proxy类来对接口增强
  1. package com.junjay.spring5.dao;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  6. import java.util.Arrays;
  8. public class JdkProxy {
  10.     public static void main(String[] args) {
  11.         Class[] interfaces = { UserDao.class };
  12.         UserDaoImpl userDaoImpl = new UserDaoImpl();
  13.         // 创建接口实现类的代理对象
  14.         UserDao newProxyInstance = (UserDao) Proxy.newProxyInstance(JdkProxy.class.getClassLoader(), interfaces,
  15.                 new UserProxy(userDaoImpl));
  16.         // Proxy.newProxyInstance....这一步相当于是创建接口实现类以接口做接收
  17.         // UserDao userDaoImpl = new UserDaoImpl(); // 但改UserDao为动态代理的接口
  18.         int add = newProxyInstance.add(3, 7);
  19.         System.out.println("返回结果："+add);
  20.     }
  22. }
  24. //创建代理对象代码
  25. /**
  26.  * @author My 内部类（类中创建新类）
  27.  */
  28. class UserProxy implements InvocationHandler {
  30.     // 把创建的接口实现类，传递过来
  31.     private Object obj;
  33.     // 有参构造，参数为需要代理对象的实现类
  34.     public UserProxy(Object obj) {
  35.         this.obj = obj;
  36.     }
  38.     // 增强逻辑
  39.     @Override
  40.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  41.         // 方法之前
  42.         System.err.println(method.getName() + "方法执行前。。。。" + " 传递的参数=" + Arrays.toString(args));
  43.         // 被增强的方法执行
  44.         Object object = method.invoke(obj, args);
  45.         // 方法之后
  46.         System.err.println("方法执行后=" + obj);
  47.         return object;
  48.     }
  49. }

测试代理对象：
image.png
一、JDK与CGLIB区别:
1.JDK动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。
2.CGLIB动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
javassist没有用过，说说cglib
在AOP中，Java原生自带的模式需要依赖于接口，
但是一些实现里面，是通过继承来实现的，压根就没有接口，或者只有很底层的接口。这种场景下，就没办法通过接口的这种动态代理方式来实现动作拦截。
所以只好依赖于cglib。
当然，最优雅的还是通过接口的方式，cglib只不过是无奈的选择罢了。另外，cglib是运行时动态修改字节码的。

AOP（术语）

（1）：连接点
（2）：切入点
（3）：通知（增强）
（4）：切面
AOP - 图7

AOP操作（准备）

1：在spring框架中一般都是基于AspectJ实现Aop操作
（1）：什么是AspectJ
AspectJ不是spring组成部分，是独立的aop框架，一般把aspectj和spring一起使用，进行aop操作
2：基于aspectj实现aop操作
（1）：基于xml配置文件实现
（2）：基于注解方式实现
3：在项目工程里引入aop相关jar包
image.png
image.png
4：切入点表达式
（1）：切入点表达式作用，确定哪个类里的哪个方法进行增强；
（2）：语法结构：
execution(表达式)
pointcut=”execution( ...(..)) 访问修饰符 返回值 包名.包名.包名…类名.方法名(参数列表)
eg：对com.spring5.dao.BookDao接口类中的add进行增强
execution( com.spring5.dao.BookDao.add(..) )
eg：对com.spring5.dao.BookDao接口类中的所有方法进行增强
execution( com.spring5.dao.BookDao.(..) )
eg：对com.spring5.dao.BookDao接口中所有类中的所有方法进行增强
execution( com.spring5.dao..(..) )

AOP操作（aspectj注解）

1：创建一个类，在类里定义一个方法（被增强类）

  1. package com.junjay.spring5.aopanno;
  3. import org.springframework.stereotype.Component;
  5. /**
  6.  * @author My
  7.  *    被增强类
  8.  */
  9. @Component
  10. public class User {
  12.     public void add() {
  13.         // int i = 10/0;
  14.         System.out.println("user add ....");
  15.     }
  16. }

2：创建增强类（编写增强逻辑）

  1. package com.junjay.spring5.aopanno;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.After;
  5. import org.aspectj.lang.annotation.AfterReturning;
  6. import org.aspectj.lang.annotation.AfterThrowing;
  7. import org.aspectj.lang.annotation.Around;
  8. import org.aspectj.lang.annotation.Aspect;
  9. import org.aspectj.lang.annotation.Before;
  10. import org.springframework.stereotype.Component;
  12. /**
  13.  * @author My
  14.  * 增强User类
  15.  */
  16. @Component
  17. @Aspect //生成代理对象
  18. public class UserProxy {
  20.     /**
  21.      * 前置通知
  22.      */
  23.     // @Before注解表示作为改方法的前置通知
  24.     @Before(value = "execution(* com.junjay.spring5.aopanno.User.add(..))")
  25.     public void beforeAdvice() {
  26.         System.err.println("@Before前置通知");
  27.     }
  29.     @AfterReturning(value = "execution(* com.junjay.spring5.aopanno.User.add(..))")
  30.     public void afterReturning() {
  31.         System.err.println("@AfterReturning后置通知");
  32.     }
  34.     /**
  35.      * @throws Throwable 
  36.      * @Around 环绕通知，在执行add（）方法之前、之后都执行
  37.      */
  38.     @Around(value = "execution(* com.junjay.spring5.aopanno.User.add(..))")
  39.     public void around(ProceedingJoinPoint pjp) throws Throwable {
  40.         System.err.println("@Around环绕之前。。。");
  41.         // 执行被增强的方法
  42.         pjp.proceed();
  43.         System.err.println("环绕之后。。。");
  44.     }
  46.     @AfterThrowing(value = "execution(* com.junjay.spring5.aopanno.User.add(..))")
  47.     public void afterThrowing() {
  48.         System.err.println("@AfterThrowing异常通知");
  49.     }
  51.     @After(value = "execution(* com.junjay.spring5.aopanno.User.add(..))")
  52.     public void after() {
  53.         System.err.println("@After最终通知");
  54.     }
  58. }
  59. package com.junjay.spring5.aopanno;
  61. import org.aspectj.lang.annotation.Aspect;
  62. import org.aspectj.lang.annotation.Before;
  63. import org.springframework.stereotype.Component;
  65. /**
  66.  * @author My
  67.  * 增强User类
  68.  */
  69. @Component
  70. @Aspect //生成代理对象
  71. public class UserProxy {
  73.     /**
  74.      * 前置通知
  75.      */
  76.     // @Before注解表示作为改方法的前置通知
  77.     @Before(value = "execution(* com.junjay.spring5.aopanno.User.add(..))")
  78.     public void beforeAdvice() {
  79.         System.err.println("前置通知后，在执行原始方法。");
  80.     }
  82. }

3：进行通知配置
（1）：在spring配置文件中，开启注解扫描
image.png
（2）：使用注解创建user，userproxy对象
image.pngimage.png
（3）：在增强类上面添加注解 @aspect
image.png
（4）：在spring配置文件中开启生成代理对象
image.png
4：配置不同类型的通知
（1）：在增强类里面，在作为通知方法上面添加通知类型
image.png
5：测试1,无异常通知
image.png
测试2，有异常通知
image.png
6：相同的切入点抽取

  1. @Component
  2. @Aspect //生成代理对象
  3. public class UserProxy {
  4. // 相同切入点抽取 Point-点 cut-切入
  5.     @Pointcut(value = "execution(* com.junjay.spring5.aopanno.User.add(..))")
  6.     public void pointdemo() {
  8.     }
  10.     /**
  11.      * 前置通知
  12.      */
  13.     // @Before注解表示作为改方法的前置通知
  14.     // pointdemo 方法上已经有了execution切入点方法直接使用就可以
  15.     @Before(value = "pointdemo()")
  16.     public void beforeAdvice() {
  17.         System.err.println("@Before前置通知");
  18.     }
  19. }

7： 有多个增强类对同一个方法进行增强，设置优先级
（1）在增强类上面添加注解@order （数值类型值） ，数字类型值越小优先级越高

  1. package com.junjay.spring5.aopanno;
  3. import org.aspectj.lang.annotation.Aspect;
  4. import org.aspectj.lang.annotation.Before;
  5. import org.springframework.core.annotation.Order;
  6. import org.springframework.stereotype.Component;
  8. @Component
  9. @Aspect //生成代理对象
  10. @Order(2)
  11. public class PerProxy {
  13.     /**
  14.      * 前置通知
  15.      */
  16.     // @Before注解表示作为改方法的前置通知
  17.     @Before(value = "execution(* com.junjay.spring5.aopanno.User.add(..))")
  18.     public void beforeAdvice() {
  19.         System.err.println("PerProxy -----  @Before前置通知");
  20.     }
  22. }
  1. @Component
  2. @Aspect //生成代理对象
  3. @Order(1)
  4. public class UserProxy {
  6.     // 相同切入点抽取 Point-点 cut-切入
  7.     @Pointcut(value = "execution(* com.junjay.spring5.aopanno.User.add(..))")
  8.     public void pointdemo() {
  10.     }
  12.     /**
  13.      * 前置通知
  14.      */
  15.     // @Before注解表示作为改方法的前置通知
  16.     // pointdemo 方法上已经有了execution切入点方法直接使用就可以
  17.     @Before(value = "pointdemo()")
  18.     public void beforeAdvice() {
  19.         System.err.println("UserProxy ----- @Before前置通知");
  20.     }
  21. }

image.png

AOP操作（AspectJ配置文件）

1：创建俩个类，增强类和被增强类，创建方法

  1. package com.junjay.spring5.aopxml;
  4. public class Book {
  6.     public void buy() {
  7.         System.out.println("book-------buy ");
  8.     }
  10. }
  1. package com.junjay.spring5.aopxml;
  3. public class BookProxy {
  5.     public void before() {
  6.         System.out.println("BookProxy 前置通知！！！");
  7.     }
  9. }

2：在spring配置文件中创建俩个类对象，spring配置文件中进行切入点通知配置配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.     xmlns:aop="http://www.springframework.org/schema/aop"
  5.     xmlns:p="http://www.springframework.org/schema/p"
  7.     xmlns:util="http://www.springframework.org/schema/util"
  9.     xmlns:tx="http://www.springframework.org/schema/tx"
  10.     xmlns:context="http://www.springframework.org/schema/context"
  11.     xsi:schemaLocation="
  12.        http://www.springframework.org/schema/beans
  13.        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  14.        http://www.springframework.org/schema/aop
  15.       http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
  16.        http://www.springframework.org/schema/tx
  17.       http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
  18.        http://www.springframework.org/schema/context
  19.        http://www.springframework.org/schema/context/spring-context-3.0.xsd
  21.        http://www.springframework.org/schema/util
  22.        http://www.springframework.org/schema/util/spring-util.xsd
  23.        ">
  25.     <!-- 创建对象 -->
  26.     <bean id="book" class="com.junjay.spring5.aopxml.Book"></bean>
  27.     <bean id="bookProxy" class="com.junjay.spring5.aopxml.BookProxy"></bean>
  29.     <!-- aop增强配置 -->
  30.     <aop:config>
  31.         <!-- 切入点 -->
  32.         <aop:pointcut expression="execution(* com.junjay.spring5.aopxml.Book.buy(..))" id="p"/>
  33.         <!-- 切面 把增强方法应用到被增强方法中 -->
  34.         <aop:aspect ref="bookProxy">
  35.             <!-- 增强作用在具体的方法上 method（before）设置增强类的方法 pointcut-ref增强的切入点id -->
  36.             <aop:before method="before" pointcut-ref="p"/>
  38.         </aop:aspect>
  40.     </aop:config>
  43. </beans>

3：测试image.png
8：完全使用注解使用aspectj
（1）：其他不变只是把配置文件转换成配置类

  1.     <context:component-scan
  2.         base-package="com.junjay.spring5"></context:component-scan>
  4.     <!-- 开启aspectj 生成代理对象,作用扫描有@aspectj注释的类，将其生成为代理对象  -->
  5.     <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
  1. package com.junjay.spring5.config;
  3. import org.springframework.context.annotation.ComponentScan;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.EnableAspectJAutoProxy;
  7. @Configuration
  8. @ComponentScan(basePackages = {"com.junjay.spring5"})
  9. // @EnableAspectJAutoProxy  开启aspectj 生成代理对象 默认为false 
  10. @EnableAspectJAutoProxy(proxyTargetClass = true)
  11. public class AopConfig {
  13. }