springaop相关笔记

SpringAOP

1、什么是AOP

AOP为Aspect Oriented Programming的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

实际上，AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强

2、AOP的作用和优势

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强

优势：减少重复代码，提高开发效率，并且便于维护

3、AOP的相关概念

Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

Target（目标对象）	代理的目标对象
Proxy （代理）	一个类被 AOP 织入增强后，就产生一个结果代理类
Joinpoint（连接点）	所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点
Pointcut（切入点）	所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
Advice（通知/ 增强）	所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知
Aspect（切面）	是切入点和通知（引介）的结合
Weaving（织入）	是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

开发明确事项：

• 谁是切点（切点表达式配置\注解）
• 谁是通知（切面类中的增强方法）
• 将切点和通知进行织入配置

例如：

切面类

package com.gaojiashun.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Pointcut;
/**
 * 切面：切入点和通知的集合
 */
//@Component
//@Aspect
public class MyAspect {

    /**
     * 切点表达式(权限修饰符 返回类型 包名，类名，方法名（所有请求参数）)
     * 切点：真正被增强的方法
     * 连接点：可以被增强的方法
     * 这里切点表达式所指定就是切点，没有指到的就是普通的连接点
     */
    @Pointcut("execution(* com.gaojiashun.service.*.*(..))")
    public void pt(){

    }

    //使用注解作为切入点
    @Pointcut("@annotation(com.gaojiashun.annotation.PointcutInvokeLog)")
    public void annotationPt(){

    }


    /**
     * 通知/增强：具体增强的代码
     */
//    @Before("annotationPt()")
//    public void methodBefore(){
//        System.out.println("增强方法被调用了");
//    }

    /**通知
     * Around对方法进行全方位增强
     * @param proceedingJoinPoint
     */
    @Around("annotationPt()")
    public void around(ProceedingJoinPoint proceedingJoinPoint){
        System.out.println("方法调用之前");
        try {

            proceedingJoinPoint.proceed();//触发方法

            System.out.println("方法调用之后");
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println("出现异常");
        }finally {
            System.out.println("最终调用");
        }
    }


}

1、切点表达式的写法

语法：

 execution([修饰符] 返回值类型 包名.类名.方法名(参数))

• 访问修饰符可以省略
• 返回值类型、包名、类名、方法名可以使用星号* 代表任意
• 包名与类名之间一个点 . 代表当前包下的类，两个点 … 表示当前包及其子包下的类
• 参数列表可以使用两个点 … 表示任意个数，任意类型的参数列表

例如：

execution(public void com.itheima.aop.Target.method())	
execution(void com.itheima.aop.Target.*(..))
execution(* com.itheima.aop.*.*(..))
execution(* com.itheima.aop..*.*(..))
execution(* *..*.*(..))

2、通知格式

通知的配置语法：

@通知注解(“切点表达式")注解通知的类型

名称	注解	说明
前置通知	@Before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	@AfterReturning	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	@Around	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	@AfterThrowing	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	@After	用于配置最终通知。无论增强方式执行是否有异常都会执行

使用注解作为切点

例如

注解，标记了该注解的方法会被拦截

package com.gaojiashun.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

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

日志打印切面类

package com.gaojiashun.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component
@Aspect
public class PrintLogAspect {
    
    //切点
    @Pointcut("@annotation(com.gaojiashun.annotation.PointcutInvokeLog)")
    public void pt(){

    }

    //通知
//    @After(value = "pt()")
    public void printAfterLog(JoinPoint joinPoint){
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        //获取类名
        String className = signature.getDeclaringTypeName();
        //获取方法名
        String methodName = signature.getName();
        //获取请求参数
        Object[] args = joinPoint.getArgs();
        String logs="::"+className+"===>"+methodName+"===>"+ Arrays.toString(args);
        System.out.println(logs);
    }

    //环绕通知
    @Around("pt()")
    public void printAroundLog(ProceedingJoinPoint proceedingJoinPoint){
        MethodSignature signature = (MethodSignature) proceedingJoinPoint.getSignature();
        String className = signature.getDeclaringTypeName();
        String methodName = signature.getName();
        Object[] args = proceedingJoinPoint.getArgs();
        String logs="::"+className+"===>"+methodName+"===>"+ Arrays.toString(args);
        try {
            Object returnValue = proceedingJoinPoint.proceed();//触发方法后获得的返回值
        } catch (Throwable e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }finally {
            System.out.println(logs);
        }

    }

//    @AfterThrowing(value = "pt()",throwing = "e")
//    public void testAfterThrowing(JoinPoint joinPoint,Throwable e){
//        e.printStackTrace();
//    }
}