浅显易懂理解AOP

理解AOP（JDK+cglib）

1. 什么是AOP

   Aspect Oriented Programing 面向切面编程， 相比较 oop 面向对象编程来说， Aop关注的不再是程序代码中某个类，某些方法，而 aop 考虑的更多的是一种面到面的切入，即层与层之间的一种切入，所以称之为切面。 联想大家吃的汉堡（中间夹肉）。那么 aop是怎么做到拦截整个面的功能呢？考虑中级学到的 servlet urlpattern /* 的配置 ，实际上也是 aop 的实现 。

2. Aop的功能

   AOP 主要应用于日志记录，性能统计，安全控制,事务处理等方面，实现公共功能性的重复使用。

3. AOP 带来的好处

   1. 降低模块与模块之间的耦合度，提高业务代码的聚合度。 （高内聚低耦合）

   2. 提高了代码的复用性。

   3. 提高系统的扩展性

4. AOP中的基本概念

   • 连接点（动态）JoinPoint

   • PointCut 切入点（静态）

     窒息任意的公共方法
     execution(public *(..))
     执行任意的 set 方法
     execution(* set*(..))
     执行 com.mage.service 包下任意类的任意方法
     execution(* com.mage.service.*.*(..))
     执行 com.mage.service 包 以及子包下任意类的任意方法
     execution(* com.mage.service..*.*(..))
     

   • Advice 通知

   • Aspect 切面

   • Target 目标对象

   • weave 织入

   • 引入

5. AOP实现

   1. 引入jar包，可在父类项目中引入

      <dependency>
          <groupId>org.aspectjgroupId>
          <artifactId>aspectjweaverartifactId>
          <version>1.8.9version>
      dependency>
      

   2. XML文件配置

      //添加命名空间
      xmlns:aop="http://www.springframework.org/schema/aop"
      http://www.springframework.org/schema/aop
      http://www.springframework.org/schema/aop/spring-aop.xsd
      
      //添加代理
      <aop:aspectj-autoproxy/>
      

   3. 代码实现 LogCut实现

      package com.nanda.cut;
      
      import jdk.nashorn.internal.runtime.ECMAErrors;
      import org.aspectj.lang.ProceedingJoinPoint;
      import org.aspectj.lang.annotation.*;
      import org.springframework.stereotype.Component;
      
      /**
       * @Author LiGang
       * @Date 2020/6/17 9:19
       * @Version 1.0
       */
      //@Aspect //声名这是一个注解
      //@Component  //类的初始化
      public class LogCut {
          //切入点
          /*
              定义一个切入点
              .扫描包下的所有类
              ..表示包以及所有子包下的所有类
           */
      
          @Pointcut("execution (* com.nanda.service..*.*(..))")
          public void cut(){ }
          @Before(value = "cut()")
          public void before(){
              System.out.println("我是前置通知");
          }
          @AfterReturning(value = "cut()")
          public void afterRunning(){
              System.out.println("我是返回通知");
          }
      
          @After(value = "cut()")
          public void after() {
              System.out.println("我是最终通知");
          }
      
          @AfterThrowing(value = "cut()",throwing = "e")
          public void afterThrowing(Exception e){
              System.out.println("我是异常通知："+e);
          }
      
          /*
              声明环绕通知 并将通知应用到切入点上
              方法执行前后 通过环绕通知定义相应处理
           */
          @Around(value = "cut()")
          public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
              Object proceed = null;
              try {
                  System.out.println("我是前置通知");
                  proceed = joinPoint.proceed();
                  System.out.println("我是返回通知");
                  System.out.println("我是异常通知");
                  return proceed;
              }catch (Exception e){
                  System.out.println("我是异常通知");
                  e.printStackTrace();
              }
              return proceed;
          }
      }
      
      

   4. xml配置实现

      注：此处开启切面配置后，实现类只需要单纯考虑实现即可

      
      <aop:config>
          
          <aop:aspect ref="logCut">
              
             <aop:pointcut expression="execution (* com.mage.service..*.*(..))"
              id="cut"/>
              
              <aop:before method="before" pointcut-ref="cut"/>
              
              <aop:after-returning method="afterReturning" pointcut-ref="cut"/>
              
              <aop:after-throwing method="afterThrowing" throwing="e" pointcut-ref="cut"/>
              
              <aop:after method="after" pointcut-ref="cut"/>
              
              <aop:around method="around" pointcut-ref="cut"/>
          aop:aspect>
      aop:config>
      

6. AOP常见问题

   1. 代理模式实现三要素是什么？

      接口定义
      目标对象 与代理对象必须实现统一接口
      代理对象持有目标对象的引用 增强目标对象行为

   2. jdk 动态代理与 cglib 动态代理区别是什么？

      静态代理：手动为目标对象制作代理对象，即在程序编译阶段完成代理对象的创建
      动态代理：在程序运行期动态创建目标对象对应代理对象
      jdk动态代理：被代理目标对象必须实现某一或某一组接口 实现方式 通过回调创建代理对象。
      cglib动态代理：被代理目标对象可以不必实现接口，继承的方式实现

   3. Spring AOP 两种实现机制是什么?
      动态代理 jdk cglib

   4. 什么是 aop,谈谈你对 aop 的理解。

      面向切面，相比oop关注的是代码中的层或面
      解耦，提高系统扩展性
      提高代码复用

   5. aop 通知类型有哪些?

      After，Before，afterRunning，around，afterThrowing