一、AOP 配置
1、导入 jar 包
① 导入 Spring 基础包
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.3</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>${spring-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring-version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring-version}</version>
</dependency>
② 导入基础的 AOP 包
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
③ 导入加强版的面向切面编程（即使目标对象没有实现任何接口也能创建动态代理）
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>com.springsource.org.aspectj.weaver</artifactId>
<version>1.6.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aopalliance</groupId>
<artifactId>com.springsource.org.aopalliance</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>net.sourceforge.cglib</groupId>
<artifactId>com.springsource.net.sf.cglib</artifactId>
<version>2.1.3</version>
</dependency>
2、写配置
①将目标类和切面类（封装通知方法（在目标方法执行前后的方法））加入到IOC容器中
②告诉Spring哪个是切面类@Aspect
③告诉Spring，切面类里面的每一个方法，都是何时何地运行
将业务类添加到容器中：
@Service
public class MyMathCalculator implements Calculator{}
将切面类（日志类）加到容器中
/**
* 如果将这个类（切面类）中的这些方法（通知方法）动态的在目标方法运行的各个位置切入
*/
@Aspect
@Component
public class LogUtils {
/**
* 告诉 Spring 每个方法都什么时候运行
*
* try {
* @Before
* method.invoke(obj, args);
* @AfterReturning
* }catch(e) {
* @AfterThrowing
* }finally {
* @After
* }
*
*
* @Before：在目标方法运行之前 前置通知
* @After：在目标方法运行结束之后 后置通知
* @AfterReturning：在目标方法正常放回之后 返回通知
* @AfterThrowing：在目标方法抛异常之后 异常通知
* @Around：环绕 环绕通知
*/
//想在执行目标方法之前
//execution(访问权限符 返回值类 方法签名)
@Before("execution(public int com.njf.aop.calc.MyMathCalculator.add(int, int))")
public static void logStart(){
System.out.println("【XXX】方法执行了，参数为【XXX】");
}
//想在目标方法正执行完毕之后
@AfterReturning("execution(public int com.njf.aop.calc.MyMathCalculator.add(int, int))")
public static void logReturn(){
System.out.println("【XXX】方法执行完成，他的结果为是：");
}
@AfterThrowing("execution(public int com.njf.aop.calc.MyMathCalculator.add(int, int))")
//想在目标方法出现异常时执行
public static void logException(){
System.out.println("【XXX】方法出现了异常，异常为： ");
}
//想在目标方法结束时执行
@After("execution(public int com.njf.aop.calc.MyMathCalculator.add(int, int))")
public static void logEnd(){
System.out.println("【XXX】方法执行最终完成");
}
}
开启包扫描：
<context:component-scan base-package="com.njf.aop"></context:component-scan>
3、在配置文件中 开启基于注解的AOP模式
<!-- 开启基于注解的AOP功能：aop 名称空间 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
4、测试
ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
@Test
public void test1() {
//1、从ioc容器中拿到目标对象
//注意：如果想要用类型获取，一定要用他的接口类型，不要用他的本类
Calculator calculator = ioc.getBean(Calculator.class);
calculator.add(1, 2);
}
二、AspectJ
1、简介
AspectJ：Java社区里最完整最流行的AOP框架。
在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。
2、在 Spring 中启用 AspectJ 注解支持
① 导入jar包依赖
aopalliance.jar
aspectj.weaver.jar
spring-aspects.jar
② 开启基于注解的 AOP
（1）引入AOP名称空间
（2）配置文件
在配置文件中开启自动生成代理。
<!-- 开启 aspectJ 的自动代理功能 -->
<aop:aspectj-autoproxy />
作用：当 Spring IOC 容器侦测到 bean 配置文件中的 <aop:aspectj-autoproxy> 元素时，会自动为与 AspectJ 切面匹配的 bean 创建代理。
（3）开启 Spring IOC 的扫描组件
<!-- 让 IOC 容器扫描添加了注解的组件 -->
<context:component-scan base-package="com.spring.aop"></context:component-scan>
3、用AspectJ注解声明切面
（1）要在 Spring 中声明 AspectJ 切面，只需要在 IOC 容器中将切面声明为 bean 实例；
（2）当在 Spring IOC 容器中初始化 AspectJ 切面之后，Spring IOC 容器就会为那些与 AspectJ 切面想匹配的 bean 创建代理；
（3）在 AspectJ 注解中，切面只是一个带有 @Aspect 注解的 Java 类，它往往包含很多通知；
（4）通知是标注有某种注解的简单的 Java 方法；
try{
@Before
method.invoke(obj,args);
@AfterReturning
}catch(e){
@AfterThrowing：在目标方法抛异常之后
}finally{
@after：在目标方法运行结束之后
}
4、切点表达式：
execution(访问权限符 返回值类型 方法签名)
5、通知注解
AspectJ 支持 5 种类型的通知注解：
告诉Spring每个方法，都什么时候运行
① @Before：前置通知，在方法执行之前执行；
② @After：后置通知，在方法执行之后执行（finally里面，永远都会执行）；
③ @AfterRunning：返回通知，在方法返回结果之后执行；
④ @AfterThrowing：异常通知，在方法抛出异常之后执行；
⑤ @Around：环绕通知，围绕这方法执行；
三、完整代码
计算器核心业务：
// 计算器接口
public interface Calculator {
public int add(int i, int j);
public int sub(int i, int j);
public int mul(int i, int j);
public int div(int i, int j);
}
//计算器接口实现类
@Service
public class MyMathCalculator implements Calculator{
@Override
public int add(int i, int j) {
int result = i + j;
return result;
}
@Override
public int sub(int i, int j) {
int result = i - j;
return result;
}
@Override
public int mul(int i, int j) {
int result = i * j;
return result;
}
@Override
public int div(int i, int j) {
int result = i / j;
return result;
}
}
切面类：
/**
* 如果将这个类（切面类）中的这些方法（通知方法）动态的在目标方法运行的各个位置切入
*/
@Aspect
@Component
public class LogUtils {
/**
* 告诉 Spring 每个方法都什么时候运行
*
* try {
* @Before
* method.invoke(obj, args);
* @AfterReturning
* }catch(e) {
* @AfterThrowing
* }finally {
* @After
* }
*
*
* @Before：在目标方法运行之前 前置通知
* @After：在目标方法运行结束之后 后置通知
* @AfterReturning：在目标方法正常放回之后 返回通知
* @AfterThrowing：在目标方法抛异常之后 异常通知
* @Around：环绕 环绕通知
*/
//想在执行目标方法之前
//execution(访问权限符 返回值类 方法签名)
@Before("execution(public int com.njf.aop.calc.MyMathCalculator.add(int, int))")
public static void logStart(){
System.out.println("【XXX】方法执行了，参数为【XXX】");
}
//想在目标方法正执行完毕之后
@AfterReturning("execution(public int com.njf.aop.calc.MyMathCalculator.add(int, int))")
public static void logReturn(){
System.out.println("【XXX】方法执行完成，他的结果为是：");
}
@AfterThrowing("execution(public int com.njf.aop.calc.MyMathCalculator.add(int, int))")
//想在目标方法出现异常时执行
public static void logException(){
System.out.println("【XXX】方法出现了异常，异常为： ");
}
//想在目标方法结束时执行
@After("execution(public int com.njf.aop.calc.MyMathCalculator.add(int, int))")
public static void logEnd(){
System.out.println("【XXX】方法执行最终完成");
}
}
配置文件：
<!-- 扫描让 IOC 容器管理的 bean -->
<context:component-scan base-package="com.njf.aop"></context:component-scan>
<!-- 当Spring IOC容器侦测到bean配置文件中的该元素时，会自动为与AspectJ切面匹配的bean创建代理 -->
<!-- 开启 aspectJ 的自动代理功能 -->
<aop:aspectj-autoproxy />
四、细节
1、IOC容器中保存的是组件的代理对象
@Test
public void test1() {
//1、从ioc容器中拿到目标对象
//注意：如果想要用类型获取，一定要用他的接口类型，不要用他的本类
/**
* 细节一：
* com.njf.aop.calc.MyMathCalculator@368f2016
* class com.sun.proxy.$Proxy13
* AOP 的底层就是动态代理，容器中保存是组件是它的代理对象：$Proxy13, 当然不是本类的类型。
*
*/
Calculator calculator = ioc.getBean(Calculator.class);
calculator.add(1, 2);
System.out.println(calculator);
System.out.println(calculator.getClass());
}
2、没有接口就是本类类型
CGLIB会帮我们创建好代理对象，就算没有接口
@Test
public void test2() {
//没有接口就是本类类型，
//com.njf.aop.calc.MyMathCalculator@3098cf3b
//class com.njf.aop.calc.MyMathCalculator$$EnhancerByCGLIB$$13c10013
//cglib 帮我们创建好的代理对象
MyMathCalculator calculator = ioc.getBean(MyMathCalculator.class);
calculator.add(1, 2);
System.out.println(calculator);
System.out.println(calculator.getClass());
}
有接口就转成接口类型（Calculator.class），没有接口就转成本类类型（MyMathCalculator.class)