Aop简介

Aop(Aspect-OrientedProgramming 面向切面编程)。在面向对象编程中，常用封装、多态和继承这些来建立一个层次结果，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候。面向对象的对象就显得有些无力。因为这个时候我们通常用继承和委派来实现对重复代码的利用，但是当我们需要记录日志、和事务操作这些的时候，如果我们还采用继承的话会导致每个类都继承一个Log类，显得有些臃肿，用委派的话会显得类比较笨重，重要的是这些与我们业务无关的代码大量嵌入了进来。

所以这个时候就需要了Aop的重左到右的来实现，直接将重复的代码封装到一个切面，当然后定义一些切点来声明这些重复代码需要在哪些地方执行。定义一些连接点来标明什么时候需要执行，比如方法执行前执行后之类的。

Spring Aop

一些通知的注解

在环绕通知的时候，会传入一个ProceedingJoinPoint参数给环绕方法，执行其Process()方法即为调用了原来的方法，必须调用，不然会阻塞

切点的过滤及匹配的一些方式

execution的写法

当有多个条件的时候可以用 && 符号或者 and 来连接 还有 not 、! 、or、||这些

通过注解方式创建的实例

package com.unclezs.spring.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Objects;

/**
 * @author uncle
 * @date 2020/3/20 10:18
 */
@Aspect
@Component
public class AopTest {
    @Pointcut("@within(com.unclezs.spring.aop.annotation.AopPoint)")
    public void pointcut() {
    }

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

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

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

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

    @Around("pointcut()")
    public Object around(ProceedingJoinPoint joinPoint) {
        try {
            System.out.println("环绕Before");
            Object proceed = joinPoint.proceed();
            System.out.println("环绕After");
            return proceed;
        } catch (Throwable throwable) {
            System.out.println("环绕afterThrowing");
            throwable.printStackTrace();
        }
        return null;
    }
}

需要注意的是，在使用SpringAop的时候需要在配置类上面添加@EnableAspectJAutoProxy注解才能生效