AOP知识点总结

AOP简介

AOP面向切面编程，一种编程范式，指定开发者如何组织程序结构
作用：在不惊动原始设计的基础上为其进行功能增强
Spring 理念：无入侵式/无侵入式

连接点范围大于切入点（连接点包含切入点）目标对象：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的
代理：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现

AOP入门案例

思路分析：

1.导入坐标

 <dependency >
            <groupId >org.aspectj</groupId>
            <artifactId >aspectjweaver</artifactId>
            <version >1.9.4</version>
        </dependency>

spring-context坐标依赖spring-aop坐标

2.制作连接点方法（原始操作，Dao操作与实现类）

public interface BookDao {
    public void save();
    public void update();
}

@Repository
public class BookDaoImpl  implements BookDao {
    @Override
    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save....");
    }

    @Override
    public void update() {
        System.out.println("book dao update...");

    }
}

3.制作共性功能（通知类与通知）

public class MyAdvice {
   
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

4.定义切入点

public class MyAdvice {
    @Pointcut("execution(void com.example.aop_quickstart.dao.BookDao.update()) ")//4.指定在那个切入点实现
    private void pt(){}
    }

切入点定义依托一个不具有实际意义的方法进行，即无参数，无返回值，方法体无实际逻辑

5.绑定切入点与通知关系（切面），并指定通知添加到原始连接点的具体执行位置

public class MyAdvice {
    @Pointcut("execution(void com.example.aop_quickstart.dao.BookDao.update()) ")//4.指定在那个切入点实现
    private void pt(){}


    @Before("pt()") //5.绑定
    public void method(){
        System.out.println(System.currentTimeMillis());
    }

}

6.定义通知类受Spring容器管理，并定义当前类为切面类 @Component @Aspect

@Component
@Aspect
//实现下面的方法aop
public class MyAdvice {
    @Pointcut("execution(void com.example.aop_quickstart.dao.BookDao.update()) ")//4.指定在那个切入点实现
    private void pt(){}


    @Before("pt()") //5.绑定
    public void method(){
        System.out.println(System.currentTimeMillis());
    }

}

7.开启Spring对Aop注解驱动支持@EnableAspectJAutoProxy

@Configuration
@ComponentScan ("com.example.aop_quickstart")
@EnableAspectJAutoProxy
//告诉spring该程序里有用注解开发的aop,启动了MyAdvice里的@Aspect
public class SpringConfig {
}

AOP工作流程

SpringAOP本质：代理模式

1.Spring容器启动
2.读取所有切面配置中的切入点
3.初始化bean，判定bean对应的类中的方法是否匹配到任意切入点

• 匹配失败，创建对象
• 匹配成功，创建原始对象（目标对象）的代理对象

4.获取执bean行方法

• 获取bean，调用方法并执行，完成操作
• 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

AOP切入点表达式

语法格式

切入点：要进增强的方法
切入点表达式：要进行增强的方法的描述方式
描述方式一：

execution(void com.example.aop_quickstart.dao.BookDao.update())

描述方式二：

execution(void com.example.aop_quickstart.dao.BookDaoImpl.update())

标准格式：动作关键字（访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名）
访问修饰符：public private等,可省略
异常名：方法定义中抛出指定异常，可省略

通配符

*：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现

 execution(public * com.example.*.UserService.find*(*))
 匹配com.example包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法

…：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

 execution(public  User  com..UserService.findById(..))
 匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法

+：专用于匹配子类类型

execution(* *..Service+.*(..))

书写技巧

AOP通知类型

AOP通知共分为五种类型

• 前置通知 @Before

@Before("pt()")
    public void before(){
        System.out.println("before advice ...");
    }

• 后置通知 @After

@After("pt()")
    public void after(){
        System.out.println("after advice ...");
    }

• 环绕通知 @Around

 @Around("pt()")
    public Object around(ProceedingJoinPoint pjp ) throws Throwable {
        System.out.println("around before advice...");
        //表示对原始操作的调用
        Object ret=pjp.proceed();//around通知
        System.out.println("around after advice...");
        return ret;
    }

Around注意事项：

• 返回后通知@AfterReturning

@AfterReturning("pt2()")
    public void afterReturning(){
        System.out.println("afterReturning advice...");
    }

• 抛出异常后通知@AfterThrowing

 @AfterThrowing("pt2()")
    public void afterThrowing(){
        System.out.println("afterThrowing advice...");
    }

AOP通知获取数据

获取切入点方法的参数

• JoinPoint:适用于前置、后置、返回后、抛出异常后通知
  JoinPoint对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数

@Before("pt()")
    public void before(JoinPoint jp ){
         Object[] args=jp.getArgs();
        System.out.println(Arrays.toString(args));
        System.out.println("before advice ... ");
    }

• ProceedJoinPoint:适用于环绕通知
  ProceedJoinPoint是JoinPoint的子类

@Around("pt()")
 public Object arround(ProceedingJoinPoint pjp)throws Throwable {
        Object[]args =  pjp.getArgs();
        System.out.println(Arrays.toString(args));
         Object ret= pjp.proceed(args);
        Object ret=  null;
        return ret ;
    }

获取切入点方法返回值

• 返回后通知
  抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接受对应的异常对象

  @AfterReturning(value="pt()",returning = "ret")
    public void afterReturning( JoinPoint jp,Object ret){
        System.out.println("afterReturning advice..."+ret);
    }

• 环绕通知
  环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值

@Around("pt()")
 public Object arround(ProceedingJoinPoint pjp)throws Throwable {
        Object ret= pjp.proceed();
        return ret ;
    }

获取切入点方法运行异常信息

• 抛出异常后通知

抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接受对应的异常对象

@AfterThrowing(value="pt()",throwing ="t")
    public void afterThrowing(Throwable t){
        System.out.println("afterThrowing advice...");
    }

• 环绕通知
  抛出异常后通知可以获取切入点方法运行的异常信息，使用形参可以接受运行时抛出的异常对象

 @Around("pt()")
    public Object arround(ProceedingJoinPoint pjp) {
        Object ret=  null;
        try{
            ret= pjp.proceed(args);
        } catch (Throwable throwable){
            throwable.printStackTrace();
        }
        return ret ;
    }

AOP总结