AOP思想应该怎么去理解！-aop的思想

我们都知道，在面试的时候，很多面试官喜欢问基础的知识，但是基础的内容说的都是AOP的理论，然后问到实际讲解 Spring 的 AOP 的时候，却又问的不是那么的细致，因为毕竟是面试，但是当你面试一些稍微大型的公司的时候，他们就喜欢刨根问底的询问一些你了解的 AOP 都应用在哪些地方，又是怎么使用，今天阿粉就来说说这个 Spring 的 AOP 是怎么使用的。

AOP 思想

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

上面所说的是百度百科给出的提供信息，其实用通俗的讲，他就是一个模型，也是一种思想，是用来让自己的代码的耦合度降低的一个思想，因为我们不管是写代码还是写对应的业务逻辑，都要有一个思想，那就是高内聚，低耦合的思想，只有保持了这种思想，我们才能写出相对优质的代码，而 AOP 则是要我们对这个思想体现出来。

那么 AOP 是什么呢？

AOP 怎么理解

AOP 俗称，面向切面编程，我们也都知道在面试的时候，这么说是肯定没错的，那么接下来面试官的问题就是 AOP 一般都应用在什么地方，比如说是在自己的项目中，AOP都应用在哪些地方，是怎么应用的，然后再根据你说的应用，继续往下问。

其实理解的话，那就是面向切面编程，就是我们对一个纵向的代码，进行横向的抽取，抽取出来的意义则是我们对自己的业务做一些相应的改变，但是不修改本质的内容，这就是 AOP 在我们项目中最多的意义。

AOP 的相关概念

Aspect（切面）： Aspect 声明类似于 Java 中的类声明，在 Aspect 中会包含着一些 Pointcut 以及相应的 Advice。

Joint point（连接点）：表示在程序中明确定义的点，典型的包括方法调用，对类成员的访问以及异常处理程序块的执行等等，它自身还可以嵌套其它 joint point。

Pointcut（切点）：表示一组 joint point，这些 joint point 或是通过逻辑关系组合起来，或是通过通配、正则表达式等方式集中起来，它定义了相应的 Advice 将要发生的地方。

Advice（增强）：Advice 定义了在 Pointcut 里面定义的程序点具体要做的操作，它通过 before、after 和 around 来区别是在每个 joint point 之前、之后还是代替执行的代码。

Target（目标对象）：织入 Advice 的目标对象。

Weaving（织入）：将 Aspect 和其他对象连接起来, 并创建 Adviced object 的过程

上面说的这些内容全都是一些比较官方的术语，官方讲解的内容就是上面这些，也是面试的时候说的最多的内容，那么 AOP 这个思想，是怎么应用的呢？

AOP 的应用

接下来阿粉整个简单的应用来熟悉一下这个 AOP 的典型应用。

首先，引入相关依赖：

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.4.4</version>
    </dependency>
    <!-- aop 依赖, aspectj -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>

接着我们创建一个 Controller 和 Service 类

@Service
@Slf4j
public class UserService {

 public void save() {
     log.info("saving data!");
 }
}

@Controller
@RequestMapping("demo/")
public class DemoController {

    final UserService userService;

    public DemoController(UserService userService) {
        this.userService = userService;
    }
    
    /**
     * 模拟 AOP
     */
    @RequestMapping("/aop")
    @ResponseBody
    public void aopTest() {
        userService.save();
    }
}

接着我们构建出一个切面类

@Aspect
@Component
@Slf4j
public class UserServiceAspect {

    /**
     * 环绕切面
     */
    @Around("execution(* com.computer.fundamentals.networkprogram.service.UserService.*(..))")
    public void saveHandle(ProceedingJoinPoint proceedingJoinPoint) {
        log.info("start");

        Object result;
        try {
            result = proceedingJoinPoint.proceed();
        } catch (Throwable throwable) {
            log.info("server error");
        }

        log.info("end");
    }

}

然后我们做个测试，直接访问接口看一下我们的打印日志，

2021-11-01 10:07:11.887  INFO 12052 --- [nio-8080-exec-1] c.c.f.n.service.aop.UserServiceAspect    : start
2021-11-01 10:07:11.894  INFO 12052 --- [nio-8080-exec-1] c.c.f.n.service.UserService              : saving data!
2021-11-01 10:07:11.894  INFO 12052 --- [nio-8080-exec-1] c.c.f.n.service.aop.UserServiceAspect    : end

这样我们自己受用就实现了一个 AOP 的操作，那么 Spring 中，都有什么会应用到这个 AOP 思想呢？

AOP 思想的应用

AOP 的应用场景：

日志打印
全局异常拦截
统一返回值
多数据源的切换

上述的场景，都是 AOP 的典型应用，目的是什么都很清楚，在不影响代码业务逻辑的情况下完成一些相对比较好的操作，这样就能完美的实现了 AOP 思想。

至于怎么实现日志，阿粉都不用多说，百度上随便都能抄一份，自己手动敲一下代码，就完全没毛病了，你对 AOP 还有什么不了解的呢？