一、Aop关键术语个人理解

1.1 Joinpoint(连接点)

所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点。（通俗理解：业务层接口的所有方法都叫连接点）

1.2 Pointcut(切入点)

所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。 （通俗理解：被增强的业务层接口的方法叫切入点）

这样看来，连接点不一定是切入点，但切入点一定是连接点。

1.3 Advice(通知/增强)

所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。
通知的类型：前置通知、后置通知、异常通知、最终通知、环绕通知。

通知的查找方法：找到invoke方法中明确调用业务层那行代码，在其之前执行的就是前置通知，在其之后执行的就是后置通知，在catch中的就是异常通知，在finally中的就是最终通知。整个的invoke方法执行就是环绕通知。

注意：返回通知和异常通知只能有一个会被执行，因为发生异常执行异常通知，然后就不会继续向下执行，自然后置通知也就不会被执行，反之亦然。

1.4 Introduction(引介)

引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field。

1.5 Target(目标对象)

代理的目标对象。（被代理的对象）

1.6 Weaving(织入):

织入是指把增强应用到目标对象来创建新的代理对象的过程。 spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。

1.7 Proxy（代理）

一个类被AOP织入增强后，就产生一个结果代理类。（代理对象）

1.8 Aspect(切面):

切面是切入点和通知（引介）的结合。 （通俗理解：建立切入点方法和通知方法在执行调用的对应关系就是切面）

二、Pointcut表达式

2.1 Pointcut表达式类型

标准的AspectJ Aop的pointcut的表达式类型是很丰富的，但是Spring Aop只支持其中的9种，外加Spring Aop自己扩充的一种一共是10种类型的表达式，分别如下。

• execution：一般用于指定方法的执行，用的最多。
• within：指定某些类型的全部方法执行，也可用来指定一个包。
• this：Spring Aop是基于动态代理的，生成的bean也是一个代理对象，this就是这个代理对象，当这个对象可以转换为指定的类型时，对应的切入点就是它了，Spring Aop将生效。
• target：当被代理的对象可以转换为指定的类型时，对应的切入点就是它了，Spring Aop将生效。
• args：当执行的方法的参数是指定类型时生效。
• @target：当代理的目标对象上拥有指定的注解时生效。
• @args：当执行的方法参数类型上拥有指定的注解时生效。
• @within：与@target类似，看官方文档和网上的说法都是@within只需要目标对象的类或者父类上有指定的注解，则@within会生效，而@target则是必须是目标对象的类上有指定的注解。而根据笔者的测试这两者都是只要目标类或父类上有指定的注解即可。
• @annotation：当执行的方法上拥有指定的注解时生效。
• bean：当调用的方法是指定的bean的方法时生效。

Pointcut定义时，还可以使用&&、||、! 这三个运算。进行逻辑运算。可以把各种条件组合起来使用。

2.2 Pointcut表达式使用示例

2.2.1 execution

execution是使用的最多的一种Pointcut表达式，表示某个方法的执行，其标准语法如下。

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

• 修饰符匹配（modifier-pattern?）
• 返回值匹配（ret-type-pattern）可以为*表示任何返回值,全路径的类名等
• 类路径匹配（declaring-type-pattern?）
• 方法名匹配（name-pattern）可以指定方法名 或者 代表所有, set 代表以set开头的所有方法
• 参数匹配（(param-pattern)）可以指定具体的参数类型，多个参数间用“,”隔开，各个参数也可以用“”来表示匹配任意类型的参数，如(String)表示匹配一个String参数的方法；(,String) 表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型；可以用(…)表示零个或多个任意参数
• 异常类型匹配（throws-pattern?）
• 其中后面跟着“?”的是可选项

下面看几个例子

//表示匹配所有方法  
1）execution(* *(..))  

//表示匹配com.fsx.run.UserService中所有的公有方法  
2）execution(public * com.fsx.run.UserService.*(..))  

//表示匹配com.fsx.run包及其子包下的所有方法
3）execution(* com.fsx.run..*.*(..))  

Pointcut定义时，还可以使用&&、||、! 这三个运算。进行逻辑运算

// 签名：消息发送切面
@Pointcut("execution(* com.fsx.run.MessageSender.*(..))")
private void logSender(){}

// 签名：消息接收切面
@Pointcut("execution(* com.fsx.run.MessageReceiver.*(..))")
private void logReceiver(){}

// 只有满足发送  或者  接收  这个切面都会切进去
@Pointcut("logSender() || logReceiver()")
private void logMessage(){}

这个例子中，logMessage()将匹配任何MessageSender和MessageReceiver中的任何方法。

当我们的切面很多的时候，我们可以把所有的切面放到单独的一个类去，进行统一管理，比如下面：

//集中管理所有的切入点表达式
public class Pointcuts {

@Pointcut("execution(* *Message(..))")
public void logMessage(){}

@Pointcut("execution(* *Attachment(..))")
public void logAttachment(){}

@Pointcut("execution(* *Service.*(..))")
public void auth(){}
}

这样别的使用时，采用全类名+方法名的方式

@Before("com.fsx.run.Pointcuts.logMessage()")
public void before(JoinPoint joinPoint) {
    System.out.println("Logging before " + joinPoint.getSignature().getName());
}

2.2.2 within

within是用来指定类型的，指定类型中的所有方法将被拦截。

// AService下面所有外部调用方法，都会拦截。备注：只能是AService的方法，子类不会拦截的
@Pointcut("within(com.fsx.run.service.AService)")
public void pointCut() {
}

所以此处需要注意：上面写的是AService接口，是达不到拦截效果的，只能写实现类：

//此处只能写实现类
@Pointcut("within(com.fsx.run.service.impl.AServiceImpl)")
public void pointCut() {
}

匹配包以及子包内的所有类：

@Pointcut("within(com.fsx.run.service..*)")
public void pointCut() {
}

2.2.3 this

Spring Aop是基于代理的，this就表示代理对象。this类型的Pointcut表达式的语法是this(type)，当生成的代理对象可以转换为type指定的类型时则表示匹配。基于JDK接口的代理和基于CGLIB的代理生成的代理对象是不一样的。（注意和上面within的区别）

// 这样子，就可以拦截到AService所有的子类的所有外部调用方法
@Pointcut("this(com.fsx.run.service.AService*)")
public void pointCut() {
}

2.2.4 target

Spring Aop是基于代理的，target则表示被代理的目标对象。当被代理的目标对象可以被转换为指定的类型时则表示匹配。

注意：和上面不一样，这里是target，因此如果要切入，只能写实现类了

@Pointcut("target(com.fsx.run.service.impl.AServiceImpl)")
public void pointCut() {
}

2.2.5 args

args用来匹配方法参数的。

• 1、“args()”匹配任何不带参数的方法。
• 2、“args(java.lang.String)”匹配任何只带一个参数，而且这个参数的类型是String的方法。
• 3、“args(…)”带任意参数的方法。
• 4、“args(java.lang.String,…)”匹配带任意个参数，但是第一个参数的类型是String的方法。
• 5、“args(…,java.lang.String)”匹配带任意个参数，但是最后一个参数的类型是String的方法。

@Pointcut("args()")
public void pointCut() {
}

这个匹配的范围非常广，所以一般和别的表达式结合起来使用

2.2.6 @target

@target匹配当被代理的目标对象对应的类型及其父类型上拥有指定的注解时。

//能够切入类上（非方法上）标准了MyAnno注解的所有外部调用方法
@Pointcut("@target(com.fsx.run.anno.MyAnno)")
public void pointCut() {
}

2.2.7 @args

@args匹配被调用的方法上含有参数，且对应的参数类型上拥有指定的注解的情况。

例如：

// 匹配**方法参数类型上**拥有MyAnno注解的方法调用。如我们有一个方法add(MyParam param)接收一个MyParam类型的参数，而MyParam这个类是拥有注解MyAnno的，则它可以被Pointcut表达式匹配上
@Pointcut("@args(com.fsx.run.anno.MyAnno)")
public void pointCut() {
}

2.2.8 @within：

@within用于匹配被代理的目标对象对应的类型或其父类型拥有指定的注解的情况，但只有在调用拥有指定注解的类上的方法时才匹配。

“@within(com.fsx.run.anno.MyAnno)”匹配被调用的方法声明的类上拥有MyAnno注解的情况。比如有一个ClassA上使用了注解MyAnno标注，并且定义了一个方法a()，那么在调用ClassA.a()方法时将匹配该Pointcut；如果有一个ClassB上没有MyAnno注解，但是它继承自ClassA，同时它上面定义了一个方法b()，那么在调用ClassB().b()方法时不会匹配该Pointcut，但是在调用ClassB().a()时将匹配该方法调用，因为a()是定义在父类型ClassA上的，且ClassA上使用了MyAnno注解。但是如果子类ClassB覆写了父类ClassA的a()方法，则调用ClassB.a()方法时也不匹配该Pointcut。

2.2.9 @annotation：使用得也比较多

@annotation用于匹配方法上拥有指定注解的情况。

// 可以匹配所有方法上标有此注解的方法
@Pointcut("@annotation(com.fsx.run.anno.MyAnno)")
public void pointCut() {
}

我们还可以这么写，非常方便的获取到方法上面的注解

@Before("@annotation(myAnno)")
public void doBefore(JoinPoint joinPoint, MyAnno myAnno) {
    System.out.println(myAnno); //@com.fsx.run.anno.MyAnno()
    System.out.println("AOP Before Advice...");
}

2.2.10 bean

这是Spring增加的一种方法，spring独有，bean用于匹配当调用的是指定的Spring的某个bean的方法时。

• 1、“bean(abc)”匹配Spring Bean容器中id或name为abc的bean的方法调用。
• 2、“bean(user*)”匹配所有id或name为以user开头的bean的方法调用。

// 这个就能切入到AServiceImpl类的素有的外部调用的方法里
@Pointcut("bean(AServiceImpl)")
public void pointCut() {
}

2.3 类型匹配语法

• *：匹配任何数量字符；
• ...：匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数。
  +：匹配指定类型的子类型；仅能作为后缀放在类型模式后边。

java.lang.String    匹配String类型； 
java.*.String       匹配java包下的任何“一级子包”下的String类型； 如匹配java.lang.String，但不匹配java.lang.ss.String 
java..*             匹配java包及任何子包下的任何类型。如匹配java.lang.String、java.lang.annotation.Annotation 
java.lang.*ing      匹配任何java.lang包下的以ing结尾的类型；
java.lang.Number+   匹配java.lang包下的任何Number的子类型； 如匹配java.lang.Integer，也匹配java.math.BigInteger 

2.4 表达式的组合

表达式的组合其实就是对应的表达式的逻辑运算，与、或、非。可以通过它们把多个表达式组合在一起。

• 1、“bean(userService) && args()”匹配id或name为userService的bean的所有无参方法。
• 2、“bean(userService) || @annotation(MyAnnotation)”匹配id或name为userService的bean的方法调用，或者是方法上使用了MyAnnotation注解的方法调用。
• 3、“bean(userService) && !args()”匹配id或name为userService的bean的所有有参方法调用。

三使用案例

3.1 引入aop相关的依赖

<!--aop相关的依赖引入-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

3.2 环绕通知使用

@Component
@Aspect
@Slf4j
public class FeignCallDetailAspect {

    // 定义切点Pointcut
    @Pointcut("execution(* com.yibo.order.service..api.open.*.*(..))")
    public void excludeService() {

    }

    @Around("excludeService()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {

        RequestAttributes ra = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes sra = (ServletRequestAttributes) ra;
        HttpServletRequest request = sra.getRequest();

        String url = request.getRequestURL().toString();
        String method = request.getMethod();
        String uri = request.getRequestURI();
        String queryString = request.getQueryString();

        //log.info("请求开始, 各个参数, url: {}, method: {}, uri: {}, params: {}", url, method, uri, queryString);
        Object[] args = joinPoint.getArgs();
        String params = "";
        //获取请求参数集合并进行遍历拼接
        if(args.length>0){
            if("POST".equals(method)){
                Object object = args[0];
                //请求参数
                Map<String, Object> map = getKeyAndValue(object);

            }else if("GET".equals(method)){
                params = queryString;
            }
        }


        // result的值就是被拦截方法的返回值
        Object result = joinPoint.proceed();

        log.info("请求结束，controller的返回值是 " + JSON.toJSONString(result));
        return result;
    }

    /**
     * 获取接口参数
     * @param obj
     * @return
     */
    public static Map<String, Object> getKeyAndValue(Object obj) {
        Map<String, Object> map = new HashMap<>();
        // 得到类对象
        Class userCla = (Class) obj.getClass();
        /* 得到类中的所有属性集合 */
        Field[] fs = userCla.getDeclaredFields();
        for (int i = 0; i < fs.length; i++) {
            Field f = fs[i];
            f.setAccessible(true); // 设置些属性是可以访问的
            Object val = new Object();
            try {
                val = f.get(obj);
                // 得到此属性的值
                map.put(f.getName(), val);// 设置键值
            } catch (IllegalArgumentException | IllegalAccessException e) {
                e.printStackTrace();
            }

        }
        return map;
    }

}

3.3 内网调用接口自动赋值app security的AOP方案

/**
 * app授权配置组件
 *
 **/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@Component
public class AppSecurityConfigComponent {

    /**
     应用id
     */
    @Value("${xundu.app-id}")
    private String appId;

    /**
     版本号
     */
    @Value("${xundu.app.version}")
    private String version;


    /**
     密钥
     */
    @Value("${xundu.app.security-key}")
    private String securityKey;

    public void setSecurityProperties(SecurityBaseForm securityForm) {
        securityForm.setVersion(this.version);
        securityForm.setAppId(this.appId);
        securityForm.setSecurityKey(this.securityKey);
    }

}

/**
 * 解决调用内网接口自动赋值app security的AOP方案
 *
 */
@Component
@Aspect
public class SecurityBaseFormAspect {

    @Resource
    private AppSecurityConfigComponent securityKeyConfigComponent;

    /**
     * 切面的声明
     * 影响到的方法：
     * 1: 被{@link org.springframework.cloud.openfeign.FeignClient}标记的类
     * 2: 参数为{@link SecurityBaseForm}的所有方法
     */
    @Pointcut("@within(org.springframework.cloud.openfeign.FeignClient) && args(xundu.app.api.validate.SecurityBaseForm)")
    public void pointCut() {
    }

    /**
     * 定义Advice
     * 前置处理， 对请求的参数进行赋值：将配置的App配置赋值到SecurityBaseForm中
     *
     * @param joinPoint 连接点对象
     */
    @Before("pointCut()")
    public void handle(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        Arrays.stream(args).filter(arg -> arg instanceof SecurityBaseForm)
                .forEach(arg -> securityKeyConfigComponent
                        .setSecurityProperties((SecurityBaseForm) arg));
    }
}

四、理解AOP

4.1 什么是AOP

AOP（Aspect Oriented Programming），面向切面思想，是Spring的三大核心思想之一（两外两个：IOC-控制反转、DI-依赖注入）。

那么AOP为何那么重要呢？在我们的程序中，经常存在一些系统性的需求，比如权限校验、日志记录、统计等，这些代码会散落穿插在各个业务逻辑中，非常冗余且不利于维护。例如下面这个示意图：

有多少业务操作，就要写多少重复的校验和日志记录代码，这显然是无法接受的。当然，用面向对象的思想，我们可以把这些重复的代码抽离出来，写成公共方法，就是下面这样：

这样，代码冗余和可维护性的问题得到了解决，但每个业务方法中依然要依次手动调用这些公共方法，也是略显繁琐。有没有更好的方式呢？有的，那就是AOP，AOP将权限校验、日志记录等非业务代码完全提取出来，与业务代码分离，并寻找节点切入业务代码中：

4.2 AOP体系与概念

简单地去理解，其实AOP要做三类事：

• 在哪里切入，也就是权限校验等非业务操作在哪些业务代码中执行。
• 在什么时候切入，是业务代码执行前还是执行后。
• 切入后做什么事，比如做权限校验、日志记录等。

因此，AOP的体系可以梳理为下图：

一些概念详解：

• Pointcut：切点，决定处理如权限校验、日志记录等在何处切入业务代码中（即织入切面）。切点分为execution方式和annotation方式。前者可以用路径表达式指定哪些类织入切面，后者可以指定被哪些注解修饰的代码织入切面。

• Advice：处理，包括处理时机和处理内容。处理内容就是要做什么事，比如校验权限和记录日志。处理时机就是在什么时机执行处理内容，分为前置处理（即业务代码执行前）、后置处理（业务代码执行后）等。

• Aspect：切面，即Pointcut和Advice。

• Joint point：连接点，是程序执行的一个点。例如，一个方法的执行或者一个异常的处理。在 Spring AOP 中，一个连接点总是代表一个方法执行。

• Weaving：织入，就是通过动态代理，在目标对象方法中执行处理内容的过程。

参考：
https://blog.csdn.net/weixin_44830331/article/details/119169791

https://www.codeleading.com/article/718121000/

https://www.cnblogs.com/satire/p/14874827.html

https://blog.csdn.net/weixin_46228112/article/details/123930413