专项攻克——AOP

• 参考博客：AOP的使用（详细讲解）

• 参考B站视频1
  

  5分钟精通SpringAOP-视频

• 参考B站视频2
  

  史上最完整的AOP底层原理-视频

1 什么是AOP

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程
（1）面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而是的业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
（2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能
（3）使用登录的例子说明AOP

2 AOP作用、使用场景

应用场景：

1. 拦截器、
2. RPC接口统一日志打印、
3. 接口入参数据校验、
4. 权限控制、
5. 监控方法运行时间、
6. 缓存优化 （第一次调用查询数据库，将查询结果放入内存对象， 第二次调用， 直接从内存对象返回，不需要查询数据库 ）
7. 接口限流（推荐wx文章：Redis 做接口限流，一个注解的事！）
8. 多数据源处理（推荐wx文章：AOP多数据源动态切换）
9. 事务管理 （调用方法前开启事务， 调用方法后提交关闭事务 ）

补充知识

• 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
• 切面（Aspect）：切面是一个类，其中包含了多个通知和切点。切面用于描述在哪些类、哪些方法的什么位置上执行哪些通知。切面是切点和通知的组合称谓，就是变相给组合起了个名字。
• 切点（PointCut）：切点是一个表达式，用于描述哪些类的哪些方法会被拦截。通常情况下，切点会使用表达式语言（@execution、within、this 与 target、bean）来定义。在一个应用程序中，通常会有多个切点。（参考：AOP中常见的切点标志符）
• 通知/增强（Advice）：通知是在切点处执行的代码。通知定义了在目标方法执行前、执行后或异常抛出时需要执行的代码。通知有多种类型。
• 目标（Target）：被通知对象。
• 代理（Proxy）：向目标对象应用通知之后创建的对象。
• 连接点（JointPoint）：与切入点匹配的执行点。连接点可以说是切点的全集，切点是连接点的子集。。

举个例子，下面是一个AOP切面模型图，在某一个方法执行前后执行的一些操作，并且这些操作不会影响程序本身的运行。可以发现，在执行业务逻辑代码的前后，都需要做“验证参数、前置日志、后置日志”的相同操作。这些相同操作可以抽象出来，放在切面类里，在切面类里通过execution（切点）指定要在哪些业务逻辑（连接点）的前或后织入通知代码（advice）。

---

---

3 AOP底层实现原理

关于动态代理和静态代理的概念，推荐博客：静态代理和动态代理

AOP底层使用动态代理，有JDK动态代理和CGLIB动态代理

• （1）动态代理有接口情况，==使用JDK动态代理，即创建接口实现类代理对象，增强类的方法。
  

• （2）动态代理没有接口情况，==使用CGLIB动态代理，即创建子类的代理对象，增强类的方法。
  

代理设计模式：AOP的实现原理是动态代理，讲到动态代理之前先说一下代理模式， 代理模式是指给某一个对象提供一个代理，并由代理对象控制对原对象的引用。代理模式包含如下角色：

• subject：抽象主题角色，是一个接口。该接口是对象和它的代理共用的接口;
• RealSubject：真实主题角色，是实现抽象主题接口的类;
• Proxy:代理角色，内部含有对真实对象RealSubject的引用，从而可以操作真实对象。

代理对象提供与真实对象相同的接口，以便代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
eg：一个班上的学生需要交作业，现在由班长代理交作业，那么班长就是代理，学生就是被代理的对象。

---

按照代理的创建时期，代理类可以分为静态代理和动态代理，他们的区别如下

1. 静态代理：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。
2. 动态代理：动态代理是指java程序运行过程（程序已经启动正在运行中）由jvm生成代理类的class信息，该class信息生成后是直接处于内存中的，并没有写入磁盘保存起来，然后通过反射方式实例化代理类对象。因为代理类的class信息已经存在于内存中，所以可以通过反射方式实例化。

---

静态代理的缺点：静态代理在代码运行之前就已经存在代理类了，每一个代理对象都需要去建一个代理类去代理，当需要代理的对象有很多时，就需要创建很多的代理类，降低了程序可维护性。所以有了动态代理，动态代理可以很方便的对代理类的函数进行统一处理，而不用修改每个代理类中的方法。

3.1 AOP的JDK动态代理

3.1.1 Proxy类及InvocationHandler类

JDK动态代理，需要使用Proxy类的newProxyInstance 方法创建代理对象，该方法有三个参数：
(1) loader，类加载器
(2) interfaces，增强方法所在的类，这个类实现的接口，支持多个接口
(3) h，实现这个接口 InvocationHandler，创建代理对象，写增强的部分

public static Object newProxyInstance(ClassLoader loader,
                                        Class<?>[] interfaces,
                                        InvocationHandler h)

3.1.2 JDK动态代理代码案例

1. 创建接口，定义方法

   public interface UserDao {
       public int add(int a,int b);
       public String update(String id);
   
   }
   

2. 创建接口实现类、方法

   public class UserDaoImpl implements UserDao{
       @Override
       public int add(int a,int b) {
           return a+b;
       }
   
       @Override
       public String update(String id) {
           return id;
       }
   
   }
   

3. 创建代理对象代码

   //创建代理对象（把手）
   public class UserDaoProxy implements InvocationHandler {
   
       //把创建的是谁的代理对象，把谁传递过来
       //有参构造传递
       private Object obj;
   
       public UserDaoProxy(Object obj) {
           this.obj = obj;
       }
   
       //增强的逻辑
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) 
       									throws Throwable {
            //方法之前
            System.out.println("方法之前执行..."+method.getName()+":传递的参数..."+ Arrays.toString(args));
            //被增强的方法执行
            Object res = method.invoke(obj, args);
            //方法之后
            System.out.println("方法之后执行..."+obj);
           return res;
       }
   }
   

4. 调用：使用 Proxy 类创建接口代理对象

   //使用 Proxy 类创建接口代理对象
   public class JDKProxy {
       public static void main(String[] args) {
   
           //创建接口实现类代理对象
           Class[] interfaces = {UserDao.class};
   
           UserDaoImpl userDaoImpl = new UserDaoImpl();
           
           UserDao dao = (UserDao) Proxy.newProxyInstance(
           		JDKProxy.class.getClassLoader(), //JDK代理的类加载器
           		interfaces, //接口
           		new UserDaoProxy(userDaoImpl));//将接口实现类交给处理器增强
   
           int res = dao.add(1, 2);
           System.out.println("result:"+res);
       }
   
   }
   

   

3.2 AspectJ框架（CGLIB）【重点】

Spring框架一般都是基于AspectJ实现AOP操作

3.2.1 AspectJ是什么？

AspectJ不是Spring组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作。

3.2.2 基于AspectJ实现AOP操作

（1）在项目工程里面引入AOP相关依赖
（2）基于xml配置文件实现
（3）基于注解方式实现

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.15.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.9</version>
        </dependency>

        <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjtools</artifactId>
            <version>1.9.9</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

3.2.3 补充知识——切点表达式execution

• 切点表达式作用：知道对哪个类里面的哪个方法进行增强

• 语法结构：

  execution （【权限修饰符public private等】【返回类型 int long等】【类全路径】【方法名称】(【参数列表】)）

• 举例

  1. 增强某方法，如com.jin.dao.UserDao类的add方法

     execution(* com.jin.dao.UserDao.add(..))
     

  2. 增强类的所有方法，如com.jin.dao.UserDao类的所有方法

     execution(* com.jin.dao.UserDao.*(..))
     

  3. 增强某包里的所有类的所有方法，如com.jin.dao包里所有类的所有方法

     	execution(* com.jin.dao.*.*(..))
     

3.2.4 AspectJ注解方式（CGLIB）-案例【重要】

1. 进行通知的配置
   （1）方式一、在spring配置文件中，开启注解扫描；在spring配置文件中开启生成代理对象

   <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xmlns:context="http://www.springframework.org/schema/context"
          xmlns:aop="http://www.springframework.org/schema/aop"
          xsi:schemaLocation="
          http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context.xsd
          http://www.springframework.org/schema/aop
          http://www.springframework.org/schema/aop/spring-aop.xsd
   ">
       <!--开启注解扫描-->
   <context:component-scan base-package="com.jin.aopanno"></context:component-scan>
   </beans>
   
   <!--开启Aspect生成代理对象-->
   <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
   

   （2）方式二、完全使用注解开发，创建配置类，不需要创建xml配置文件

   @ComponentScan(basePackages = {"com.jin.pojo"})
   @Configuration
   //默认EnableAspectJAutoProxy为false，True则使用CGLIB
   @EnableAspectJAutoProxy(proxyTargetClass = true) 
   public class SpringConfig {
   }
   

   测试代码：

   @Test
       public void MyTest01(){
           AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
           User user = context.getBean("user", User.class);
           user.add();
       }
   

2. 使用注解创建被增强类User类（目标对象）

   //被增强的类
   @Component
   public class User {
       public void add(){
           System.out.println("add ...");
       }
   

3. 使用注解@Aspect创建增强类UserProxy类，在增加类的通知方法上添加通知类型注解@Before、@After、@AfterReturning、@AfterThrowing、@Around，并使用切点表达式指明代理的目标。

   补充知识

   • @Aspect 设置当前类为切面类
   • @Pointcut 使用当前方法名作为切入点引用名称，例如

     @Pointcut("execution(* *(..))")
     public void pt() {
     }
     

   • @Before 标注当前方法作为前置通知
   • @After 标注当前方法作为后置通知
   • @AfterReturning 标注当前方法作为返回后通知
   • @AfterThrowing 标注当前方法作为异常后通知
   • @Around 标注当前方法作为环绕通知

   增强类（切面）

   //增强类
   /**
   如果有多个增强类对同一个方法进行增强，可以通过
   Order设置增强类优先级，数字类型值越小优先级越高
   */
   @Component
   @Aspect //@Aspect注解指明该类为代理对象
   @Order(1)
   public class UserProxy {
       //前置通知
       //@Before注解表示作为前置通知
       @Before(value = "execution(* com.jin.aopanno.User.add(..))")
       public void before(){
           System.out.println("before ...");
       }
       //返回之后的通知
       @AfterReturning(value = "execution(* com.jin.aopanno.User.add(..))")
       public void afterReturning(){
           System.out.println("afterReturning ...");
       }
       //
       @After(value = "execution(* com.jin.aopanno.User.add(..))")
       public void after(){
           System.out.println("after ...");
       }
   	//异常通知
       @AfterThrowing(value = "execution(* com.jin.aopanno.User.add(..))")
       public void afterThrowing(){
           System.out.println("AfterThrowing ...");
       }
       //？？
       @Around(value = "execution(* com.jin.aopanno.User.add(..))")
       public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
           System.out.println("环绕之前 ...");
           proceedingJoinPoint.proceed();
           System.out.println("环绕之后 ...");
       }
   }
   

   

6. AOP是如何运行的？