注：AOP称为面向切面编程，在程序开发中常用来解决一些系统公共的问题，比如日志，事务，权限拦截等等，本文主要讲述Spring AOP的使用。
基本概念
1、Aspect(切面):通常是一个类，里面可以定义切入点和通知，比如Log类。
2、JointPoint(连接点):程序执行过程中明确的点，即在哪个地方进行拦截。
3、Advice(通知):AOP在特定的切入点上执行的增强处理，主要包括以下几种方式：before,after,afterReturning,afterThrowing,around
（1）前置通知（Before）：在目标方法前调用。
（2）后置通知（After）：在目标方法后调用，无论是否有异常都执行。
（3）环绕通知（Around）：将 Before 和 After ，甚至抛出增强和返回增强合到一起，即动态代理功能一样。
（4）返回通知（AfterReturning）：在方法返回结果后执行，该增强可以接收到目标方法返回结果，前提没有异常的情况下。
（5）异常通知（AfterThrowing）：在目标方法抛出对应的类型后执行，可以接收到对应的异常信息，前提抛出异常的情况下。
4、Pointcut(切入点):就是带有通知的连接点，在程序中主要体现为书写切入点表达式
5、AOP代理：AOP框架创建的对象，代理就是目标对象的加强。
具体实例
该实例功能，在做除法运算时，将其日志打印输出，具体代码如下：
Calc.java 业务类
package com.itbofeng;
import org.springframework.stereotype.Service;
//核心业务逻辑类，保证业务逻辑类的功能单一，使用Spring Aop降低代码的侵入性
@Service
public class Calc {
//进行触发运算功能
public int div(int a, int b) {
return a/b;
}
}
Log.java 切面类：日志记录
package com.itbofeng;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
//切面类：日志记录功能
@Aspect
@Component
public class Log {
//切点
@Pointcut("execution(public * com.itbofeng.*.*(..))")
public void logPointCut(){}
//前置通知
@Before("logPointCut()")
public void calcBefore(JoinPoint joinPoint){
String name=joinPoint.getSignature().getName();
Object [] args=joinPoint.getArgs();
System.out.println("Log.calcBefore exec method "+name+",the args are"+ Arrays.asList(args));
}
//返回通知
@AfterReturning(returning = "ret",pointcut = "logPointCut()")
public void calcAfterReturning(JoinPoint joinPoint,Object ret){
String name=joinPoint.getSignature().getName();
Object [] args=joinPoint.getArgs();
System.out.println("Log.AfterReturning exec method "+name+",the args are"+ Arrays.asList(args)+",the result is "+ret);
}
//异常通知
@AfterThrowing(pointcut="logPointCut()",throwing="e")
public void calcAfterThrowing(JoinPoint joinPoint,Exception e){
String name=joinPoint.getSignature().getName();
Object [] args=joinPoint.getArgs();
System.out.println("Log.AfterThrowing exec method "+name+",the args are"+ Arrays.asList(args)+",the Exception is "+e.getMessage());
}
//后置通知
@After("logPointCut()")
public void calcAfter(JoinPoint joinPoint){
String name=joinPoint.getSignature().getName();
Object [] args=joinPoint.getArgs();
System.out.println("Log.calcAfter exec method "+name+",the args are"+ Arrays.asList(args)+"....");
}
@Around("logPointCut()")
public Object calcAround(ProceedingJoinPoint proceedingJoinPoint){
//相当于前置通知
Object [] args=proceedingJoinPoint.getArgs();//参数
System.out.println("Log.calcAround before...,the args are"+Arrays.asList(args));
Object ret=null;
try {
ret=proceedingJoinPoint.proceed();//返回值
//相当于返回通知
System.out.println("Log.calcAround AfterReturning...,the result is "+ret);
} catch (Throwable e) {
//相当于异常通知
System.out.println("Log.calcAround AfterThrowing..."+e.getMessage());
e.printStackTrace();
}finally {
//相当于后置通知
System.out.println("Log.calcAround after...");
return ret;
}
}
}
MainConfig.java 配置类
package com.itbofeng;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@Configuration
@ComponentScan
//开启AspectJ自动代理功能相当于xml中的<aop:aspectj-autoproxy />
@EnableAspectJAutoProxy
//配置类：这里使用的是基于注解的方式，相当于xml方式的配置文件
public class MainConfig {
}
AopApplicationTests.java 测试类
package com.itbofeng;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
//测试类
public class AopApplicationTests {
@Test
public void testAop() throws Exception {
ApplicationContext applicationContext=new AnnotationConfigApplicationContext(MainConfig.class);
Calc calc=applicationContext.getBean(Calc.class);
calc.div(1,1);//改变这里为1/0可以测试异常情况下
}
}
运行结果：
运行1：前提说明：先注释环绕通知，运行calc.div(1,1);正常情况下：
Log.calcBefore exec method div,the args are[1, 1]
Log.calcAfter exec method div,the args are[1, 1]....
Log.AfterReturning exec method div,the args are[1, 1],the result is 1
Process finished with exit code 0
运行2：前提说明：先注释环绕通知，运行calc.div(1,0);异常情况下：
Log.calcBefore exec method div,the args are[1, 0]
Log.calcAfter exec method div,the args are[1, 0]....
Log.AfterThrowing exec method div,the args are[1, 0],the Exception is / by zero
java.lang.ArithmeticException: / by zero
运行3：前提说明：先注释除环绕外的其他通知，运行calc.div(1,1);正常情况下：
Log.calcAround before...,the args are[1, 1]
Log.calcAround AfterReturning...,the result is 1
Log.calcAround after...
Process finished with exit code 0
运行3：前提说明：先注释除环绕外的其他通知，运行calc.div(1,0);异常情况下：
Log.calcAround before...,the args are[1, 0]
Log.calcAround AfterThrowing.../ by zero
Log.calcAround after...
java.lang.ArithmeticException: / by zero
小结：
本文主要讲解了AOP中的基本概念，以及简单的使用Spring AOP，主要是为了体验一下什么是AOP，在本文中需要掌握以下三个方面：
1、AOP的理解:面向切面编程，是一种编程思想，就像面向对象编程一样,Spring AOP只是一个具体的实现，就像Java是面向对象语言一样。
2、Spring AOP在应用程序中应用场景：在应用程序中AOP主要承担一些系统级别的功能也即一些通用的功能，如日志记录，权限校验，错误处理，事务控制等。
3、注解的使用：需要掌握理解这些注解的使用，以及每个通知方法执行时机。
最后：我这里有Spring、Spring Boot相关的视频教程（由于各种原因，不方便在此公开，还请见谅，不过这视频是我见到我认为最好的教程，不过教程也建议有过Spring使用经验的朋友观看，这样效果会更加好，有好多地方会涉及原理讲解，没有使用过的话，压力会有点大），我就是一边没事的时候看看教程，加上自己的理解，写文章的，所以文章有误的地方，还请大家指正，我一定会虚心学习的，有需要视频教程的朋友，可以私信我。如果大家觉得文章不错，点个赞，关注一下，感谢你的支持。
