aop

---

AOP

一、 概念

1. 面向切面编程是一种编程范式，不是编程语言

常见的编程范式：

1. 面向过程编程
2. 面向对象编程(OOP)
3. 函数式编程
4. 事件驱动编程
5. 面向切面编程

2. 是OOP的补充，不是替代

3. AOP的初衷

1. DRY

   处理日志，权限，监控等公有和业务无关的逻辑，解决重复编写相同的逻辑。

2. SoC：

   1. 水平分离：展示层–>服务层–>持久层
   2. 垂直分离：OOP将公有的逻辑通过继承和组合的方式进行抽离。
   3. 切面分离：将功能性需求和非功能性需求分离。(日志，权限，监控等)

4. AOP的好处

1. 集中处理某一关注点/横切逻辑（修改，删除，添加）。
2. 侵入性少：不修改业务代码，增加业务代码非业务功能。增强代码的可读性，可维护性。

5. AOP的应用场景（非业务需求）

1. 权限控制
2. 缓存控制
3. 事务控制
4. 审计日志
5. 性能监控
6. 分布式追踪
7. 异常处理等

二、AOP使用

Experssion

1. 匹配注解

   1. 声明一个注解

      @Retention(RetentionPolicy.RUNTIME)
      @Target(ElementType.METHOD)
      public @interface Login {
      }

   2. 声明一个切面类，在切面类中编写pointCut，Advice

      @Aspect
      @Component
      public class SecurityAspect {
          @Autowired
          AuthService authService;
      
          @Pointcut("@annotation(AdminOnly)")
          public void adminOnly(){
      
          }
      
          @Before("adminOnly()")
          public void check(){
              authService.checkAccess();
          }
      }

   3. 在需要使用aop的方法上使用注解

      public class ProductServiceAop {
          @Autowired
          AuthService authService;
      
          @Login
          public void insert(Product product){
              //business
              System.out.println("insert product");
          }
          @Login
          public void view(Long productId){
              //business
              System.out.println("view product"+productId);
          }

1. 匹配包/类

   1. 匹配类[ProductService中所有的方法（公有）]

   @PointCut("within(org.study.service.ProductService)")

   1. 匹配包[org.study包及子包下所有类方法]

   @PointCut("within(org.study..*)")

2. 匹配对象

   1. 匹配AOP对象的目标对象为指定类型的方法

      @PointCut("this(org.study.DemoDao))

   2. 匹配实现IDao接口的目标对象（而不是aop代理后的对象)的方法

      @PointCut("target(org.study.IDao)")
      public void targetDemo(){}

   3. 匹配所有以Service结尾的bean里头的方法

      @PointCut("bean(*Service)")
      public void beanDemo(){}

3. 匹配参数

   1. 匹配任何以find开头，且只有一个Long参数的方法

      @PointCut("execution(**..find*(Long))")
      public void argsDemo1(){}

1. 匹配任何只有一个Long参数方法

   @PointCut("args(Long)")
   public void argsDemo2(){}

1. 匹配任何以find开头且第一个参数为Long类型的方法

   @PointCut("execution(**..find*(Long,..))")

1. 匹配第一个参数为Long类型的方法

   @PointCut("args(Long,..)")

1. 匹配注解

   1. 匹配方法标注有Login注解的方法

      @PointCut("annotation(org.study.security.Login)")
      public void Login(){};

1. 匹配标注有Beta的类底下的方法，要求annotation的RetentionPolicy级别为CLASS

   @PointCut("@within(com.google.common.annotations.Beta)")
   public void annoWithinDemo(){}

1. 匹配标注有Respository的类底下的方法,要求annotation的RetentionPolicy级别RUNTIME

   @PointCut("@Target(org.springframework.stereotype.Repository)")
   public void annoTargetDemo(){}

1. 匹配传入参数类标注有Repository注解的方法

   @PointCut("@args(org.springframework.stereotype.Repository)")
   public void annoArgsDemo(){}

1. execution

   1. 格式

      execution(
      modifier-pattern //修饰符
      ret-type-pattern //返回值
      declaring-type-pattern //描述baoming
      name-pattern  // 描述方法参数
      throws-pattern //匹配方法异常
      )

   2. 切点

      @PointCut("execution(public * org.study.service.*Service*.*(..))")
      public void match(){}

   3. 获取参数

      @Before("match() && args(name)")
      public void before(String name){
          System.out.println(name);
      }

   4. 获取放回值

      @AfterReturning (pointcut="match()", returning="result")
      public void afterReturn(String result){
          System.out.println(result);
      }

   5. 获取异常

      @AfterThrowing(pointcut="match()",throwing="e")
      public void AfterThrowing(Exception e){
          e.printStackTrace();
      }

Advice

织入代码的时机

1. @Before

   前置通知：在方法前执行

2. @After(finally)

   后置通知：不管执行成功，还是失败，都执行

3. @AfterReturning

   放回通知，成功执行之后

4. @AfterThrowing

   异常通知，抛出异常之后

5. @Around

   环绕通知

   @PointCut("execution(public * org.study.service.*Service*.*(..))")
   public void match(){}
   @Around ("match()")
   public void arround(){
    System.out.println(result);
   }

赏

谢谢你请我吃糖果

支付宝

微信