1 概述
1.1 定义
-  AOP(Aspect Oriented Programming),即面向切面编程 。在不修改原有代码的基础上,对代码进行增强。 
1.2 术语

1.3 底层原理
入门案例
-  项目名: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>
基本代码
-  配置文件: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);
    }
}
AOP代码

ackage 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("提交事务");
    }
}
通知类型
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;
@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("最终通知");
    }
}
切入点表达式
切入点指示符用来指示切入点表达式目的。将通知作用到哪里?
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:https://blog.csdn.net/qq_63815371/article/details/127785377 
抽取切入点
package com.czxy.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@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);
    }
}




















