day30_1106_java_AOP

1. AOP

1.1 概述

1.1.1 定义

• AOP（Aspect Oriented Programming），即面向切面编程 。在不修改原有代码的基础上，对代码进行增强。

1.1.2 术语

1.1.3 底层原理

• debug调试

1.2 入门案例

1.2.1 环境搭建

• 项目名：day049_spring_aop

• 坐标：web、test、aop

  ​
    
  

    <!--确定spring boot版本-->
      <parent>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-parent</artifactId>
          <version>2.2.5.RELEASE</version>
          <relativePath/>
      </parent>
  ​
      <properties>
          <maven.compiler.source>8</maven.compiler.source>
          <maven.compiler.target>8</maven.compiler.target>
      </properties>
  ​
  ​
      <dependencies>
          <!--web开发启动器-->
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-web</artifactId>
          </dependency>
  ​
          <!--test 启动器-->
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-test</artifactId>
          </dependency>
  ​
          <!--aop 启动器-->
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-aop</artifactId>
          </dependency>
  ​
  ​
      </dependencies>

  ​

1.2.2 基本代码

• 配置文件：application.yml （可选）

• 启动类：AopApplication

  package com.czxy;
  ​
  import org.springframework.boot.SpringApplication;
  import org.springframework.boot.autoconfigure.SpringBootApplication;
  ​
  /**
   * @author 桐叔
   * @email liangtong@itcast.cn
   * @description
   */
  @SpringBootApplication
  public class AopApplication {
      public static void main(String[] args) {
          SpringApplication.run(AopApplication.class, args);
      }
  }

  ​

• 目标类：UserService、UserServiceImpl

  • UserService接口

    package com.czxy.service;
    ​
    /**
     * @author 桐叔
     * @email liangtong@itcast.cn
     * @description
     */
    public interface UserService {
        public Integer insert();
    ​
        public Integer update(String text);
    }

    ​

  • UserServiceImpl实现类

    package com.czxy.service.impl;
    ​
    import com.czxy.service.UserService;
    import org.springframework.stereotype.Service;
    ​
    /**
     * @author 桐叔
     * @email liangtong@itcast.cn
     * @description
     */
    @Service
    public class UserServiceImpl implements UserService {
        @Override
        public Integer insert() {
            System.out.println("user service impl insert");
            return 1;
        }
    ​
        @Override
        public Integer update(String text) {
            System.out.println("user service impl update: " + text);
            return 100;
        }
    }

    ​

• 测试类：TestUserService

  package com.czxy;
  ​
  import com.czxy.service.UserService;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.springframework.boot.test.context.SpringBootTest;
  import org.springframework.test.context.junit4.SpringRunner;
  ​
  import javax.annotation.Resource;
  ​
  /**
   * @author 桐叔
   * @email liangtong@itcast.cn
   * @description
   */
  @RunWith(SpringRunner.class)
  @SpringBootTest(classes = AopApplication.class)
  public class TestUserService {
  ​
      @Resource
      private UserService userService;
  ​
      @Test
      public void testInsert() {
          Integer result = userService.insert();
          System.out.println(result);
      }
  ​
      @Test
      public void testUpdate() {
          Integer result = userService.update("溜溜溜");
          System.out.println(result);
      }
  ​
  ​
  }

  ​

1.2.3 AOP代码

package com.czxy.aspect;
​
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
​
/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 * @description
 */
@Component              //将当前类，加载到Spring容器
@Aspect                 //声明切面类
public class MyAspect {
​
    //前置通知注解
    @Before("execution(* com.czxy.service..*.*(..))")
    public void before() {
        System.out.println("开启事务");
    }
​
    //后置通知
    @AfterReturning("execution(* com.czxy.service..*.*(..))")
    public void ar() {
        System.out.println("提交事务");
    }
}
​

1.3 通知类型

try {
    //1.前置通知 @Before                //3.环绕通知(前) @Around
    // 业务代码
    //2.后置通知 @AfterReturning        //3.环绕通知(后) @Around
} catch (Exception e) {
    //4.抛出异常通知 @AfterThrowing
} finally {
    //5.最终通知  @After
}

package com.czxy.aspect;
​
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
​
/**
 * @author 桐叔
 * @email liangtong@itcast.cn
 * @description
 */
@Component              //将当前类，加载到Spring容器
@Aspect                 //声明切面类
public class MyAspect {
​
    //前置通知注解
    @Before("execution(* com.czxy.service..*.*(..))")
    public void before(JoinPoint joinPoint) {
        // 通过连接点(joinPoint)获得方法签名(Signature)，从而获得方法的名称
        System.out.println("前置通知: " + joinPoint.getSignature().getName());
    }
​
    //后置通知，可以获得返回值的，通过returning设置变量名
    @AfterReturning(value = "execution(* com.czxy.service..*.*(..))", returning = "r")
    public void ar(JoinPoint joinPoint, Object r) {
        System.out.println("后置通知：" + joinPoint.getSignature().getName() + "， 返回值：" + r);
    }
​
    //环绕通知：需要手动执行目标方法，返回值类型Object
    @Around("execution(* com.czxy.service..*.*(..))")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕前：" + proceedingJoinPoint.getSignature().getName());
        //手动执行目标方法
        Object r = proceedingJoinPoint.proceed();
        System.out.println("环绕后");
        return r;
    }
​
    //抛出异常通知，获得异常类型,通过throwing设置变量名
    @AfterThrowing(value = "execution(* com.czxy.service..*.*(..))", throwing = "e")
    public void afterThrowing(Exception e) {
        System.out.println("抛出异常通知：" + e.getMessage());
    }
​
    //最终异常
    @After("execution(* com.czxy.service..*.*(..))")
    public void after() {
        System.out.println("最终通知");
    }
}

​

1.4 切入点表达式

• 切入点指示符用来指示切入点表达式目的。将通知作用到哪里？

• AspectJ提供多种指示符：

• 本章节主要学习：execution

• 语法：execution(访问修饰符? 返回值 包名.类名.方法名(方法参数) throws 异常?)

  • 其中带 ?的表示可以省略的部分

  • 表达式中支持使用一些特殊符号进行模糊匹配

  • * 用于匹配1个或多个位置

  • ..用于匹配0个或多个位置

  //实例
  //返回值任意   报名.            当前包及其子包   类名任意    方法名任意   参数任意
      *        com.czxy.service      ..        *       .      *     (..)
      
  //各个成员取值：
  返回值：
      int、String 等，具体的类型
      *           任意类型
  包名：
      com.czxy            具体的包
      com.czxy..          当前包及其子包
      com.czxy.*service   以Service结尾的包
  类名：
      User*               以User为前缀
      *Service            以Service为后缀
      *                   任意
  方法名
      select*             以select开头
      save*               以save开头
  参数
      int                 一个参数
      int,int             两个参数
      ..                  任意

• 参考：https://www.cnblogs.com/cunkouzh/p/5844816.html

• 参考2：【精选】Spring AOP中@Pointcut切入点表达式详解_book多得的博客-CSDN博客

• 抽取切入点

  package com.czxy.aspect;
  ​
  import org.aspectj.lang.JoinPoint;
  import org.aspectj.lang.ProceedingJoinPoint;
  import org.aspectj.lang.annotation.*;
  import org.springframework.stereotype.Component;
  ​
  /**
   * @author 桐叔
   * @email liangtong@itcast.cn
   * @description
   */
  @Component              //将当前类，加载到Spring容器
  @Aspect                 //声明切面类
  public class MyAspect2 {
  ​
      // 抽取切入点表达式
      @Pointcut("execution(* com.czxy.service..*.*(..))")
      private void myPointcut(){
  ​
      }
      @Before("myPointcut()")
      public void before(JoinPoint joinPoint) {
          System.out.println("前置通知2: " + joinPoint.getSignature().getName());
      }
  ​
      @AfterReturning(value = "myPointcut()", returning = "r")
      public void ar(JoinPoint joinPoint, Object r) {
          System.out.println("后置通知2：" + joinPoint.getSignature().getName() + "， 返回值：" + r);
      }
  ​
  }