AOP

1.AOP简介

AOP（Aspect Oriented Programming）面向切面编程，是一种编程范式，指导开发者如何组织程序结构
OOP（Object Oriented Programming）面向对象编程
作用：在步惊动原始设计的基础上进行功能增强，追加功能
Spring理念：无侵入式

2.AOP核心概念

- 2.1连接点

（JoinPoint）：程序执行过程中的任意位置，粒度为执行方法，抛出异常，设置变量等
在SpringAOP中，理解为方法的执行
切入点（Pointcut）：匹配连接点的式子
在SpringAop中，一个切入点可以只描述一个具体方法，也可以匹配多个方法

- 2.2一个具体方法

一个具体方法：com.hcx.dao包下的BookDao接口中的无形参返回值的save方法
匹配多个方法，所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法

-2.3 - 通知（Advice）

通知（Advice）：在切入点处执行的操作，也就是共性功能
在Spring中，功能最终以方法的形式呈现

-2.4 通知类

通知类：定义通知的类
切面（Aspect）：描述通知与切入点的对应关系

3.AOP注解开发版

3.1

package com.shangyacong.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;

@Configuration
@ComponentScan("com.shangyacong")
@EnableAspectJAutoProxy//表示注解开发AOP
public class SpringConfig {
}

这个是AOP的SpringConfig配置类
@Configuration注解表示这是一个配置类
@ComponentScan(“com.shangyacong”)表示要扫描com.shangyacong下的包
@EnableAspectJAutoProxy表示用注解开发AOP使其能进入aop包下的通知类能扫描他并生成bean

3.2

package com.shangyacong.dao;

import org.springframework.stereotype.Component;


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

这是一个接口里面有两个方法再继承接口时必须实现方法

3.3

package com.shangyacong.dao;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

@Repository
public class BookDaoImpl implements BookDao{

    public void save(){
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save...");

    }

    public void select() {
        System.out.println("book dao select...");
    }

}

这是一个实现类并继承了一个BookDao的接口里面重写了接口的方法

3.4

package com.shangyacong;

import com.shangyacong.config.SpringConfig;
import com.shangyacong.dao.BookDaoImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.shangyacong.dao.BookDao;

public class APP {
    public static void main(String[] args) {
        ApplicationContext applicationContext=new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao=  applicationContext.getBean(BookDao.class);
        bookDao.select();
    }
}

    ApplicationContext applicationContext=new AnnotationConfigApplicationContext(SpringConfig.class);

这行代码时获取配置文件
BookDao BookDao= applicationContext.getBean(BookDao.class);这行是从IOC容器中获取BookDao类型的Bean
下面是调用select方法
我们可以看到在select方法中什么都没有，只有一句打印

3.5

package com.shangyacong.aop;


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

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.shangyacong.dao..select())")
    private void pt(){}
    @Around("pt()")
    public Object Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("before advice");
        Object object= proceedingJoinPoint.proceed();
        System.out.println(System.currentTimeMillis());
        System.out.println("after advice");
        return object;
    }
}

以上代码是一个基本的 Spring AOP 切面的实现示例：

1. @Component 注解标识该类为 Spring 组件，它会被 Spring 扫描并纳入到 Spring 容器中管理。

2. @Aspect 注解标识该类为切面类，告诉 Spring 它包含切点和通知。

3. MyAdvice 类定义了一个切面，其中包含了一个切点和一个环绕通知。

4. @Pointcut 注解定义了一个切点，该切点匹配了 com.shangyacong.dao 包下的所有 select() 方法的执行。这里使用了 AspectJ 的切点表达式语法来定义切点。

5. Around 方法标记了一个环绕通知，它会在切点匹配的方法执行前后执行。

6. 在 Around 方法中，首先输出 “before advice”，表示在目标方法执行前执行的逻辑。

7. proceedingJoinPoint.proceed() 调用了目标方法的执行，实际上启动了目标方法的执行过程。

8. Object object= proceedingJoinPoint.proceed(); 语句执行目标方法，并将返回值保存在 object 变量中。

9. 在目标方法执行完成后，输出当前时间戳（System.currentTimeMillis()）和 “after advice”，表示在目标方法执行后执行的逻辑。

10. 最后，返回目标方法的执行结果。

这段代码通过切面 MyAdvice 定义了一个环绕通知，该通知会在匹配的目标方法执行前后分别输出 “before advice” 和 “after advice”，并输出当前时间戳。