一：AOP的背景
面试的时候面试官让我解释一下什么是AOP，当时不懂，在路上就查了，AOP：面向切面的编程技术，困惑了，JAVA是OOP：面向对象的编程技术。那么自己就立刻查了几个为题：1、什么是面向切面的编程技术；2、为什么要面向切面的编程技术；3、与OOP是什么关系？
首先解释第二个问题：在我们平时的开发过程中，你肯定会遇到下面几个面：1）权限校验；2）业务的核心代码；3）记录日志。那么在@Service层采用代码累加的方法，那么结构就会如下。
@Service
public class myService{
@Resource
private CoreService coreService;
@Resource
private LogService logService;
@Resource
private PropertyService propertyService;
// 权限校验代码
//核心业务层代码
//记录日志的代码
// 异常的处理
}
从上面的代码结构中我们可以看出以下几个问题：
1.1、代码混乱：核心业务模块与其他非核心的代码交织在一起，大大影响了代码的模块独立性能，不利于代码的维护，而且分工不明确造成代码混乱。
1.2、冗余代码：其实权限的校验，异常的处理，日志的记录可以独立在一个模块给所有的服务公用，写在一起导致代码的分散和冗余。
因此面向切面的编程技术应运而生。
解释第一个问题：什么是面向切面的编程技术。切面与切点是几何上面的术语，用在这里可以这样理解：将核心业务代码过程比作一个柱体，其他的日志记录，权限校验等就像是横切核心业务的面，这些面需要完成一些非核心的业务。如下图：
从图中可以看出我们定义了多个切面，每个切面都完成各自的非核心的业务，一个切面上还可以完成多个非核心的业务。
1.3、第三个问题：与OOP是什么关系？
AOP的实现技术有多种，其中与Java无缝对接的是一种称为AspectJ的技术，Spring AOP 与AspectJ 实现原理上并不完全一致，但功能上是相似的。AOP的出现确实解决外围业务代码与核心业务代码分离的问题，但它并不会替代OOP，如果说OOP的出现是把编码问题进行模块化，那么AOP就是把涉及到众多模块的某一类问题进行统一管理（参考：关于 Spring AOP (AspectJ) 你该知晓的一切；其实我也想到了他们的关系，但是感觉没有这篇博客总结的很好）
二：AOP的核心概念
从上右图可以可以很好看到切面（Aspect）包含了切点(PointCut)、连接点（JoinPoint）;额外还有通知（Advice）,织入（Weaving）,引入（Introduce）。
package springMVCmybatis.com.my.aop;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.springframework.core.annotation.Order;
@Aspect
// 切面执行顺序
@Order(3)
public class MyAopTest {
@Pointcut("execution(* springMVCmybatis..addController.addEmp(..))")
private void pointCutMethod() {
}
@Pointcut("execution(* springMVCmybatis.com.my.aop.UserServiceImp.*(..))")
private void testAOP() {
}
/*
* 声明前置通知 ，JoinPont是srpring提供的静态变量，
* 通过joinPoint参数可以获得目标方法的类名，方法参数，方法名等信息，这个参数可有可无。
*/
@Before("pointCutMethod() || testAOP()")
public void doBefore(JoinPoint joinPoint) {
System.out.println("@Before:开始添加--order=3");
}
//声明后置通知 ，如果result的类型与proceed执行的方法返回的参数类型不匹配那么就不会执行这个方法
@AfterReturning(pointcut = "pointCutMethod() || testAOP()", returning = "result")
public void doAfterReturning(String result) {
System.out.println("@AfterReturning:后置通知--order=3");
System.out.println("---" + result + "---");
}
//声明例外通知
@AfterThrowing(pointcut = "pointCutMethod() || testAOP()", throwing = "e")
public void doAfterThrowing(Exception e) {
System.out.println("@AfterThrowing:例外通知--order=3");
System.out.println(e.getMessage());
}
//声明最终通知
@After("pointCutMethod() || testAOP()")
public void doAfter() {
System.out.println("@After:最终通知--order=3");
}
/*
* 声明环绕通知
* 参数必须是ProceedingJoinPoint，通过该对象的proceed()方法来执行目标函数，
* proceed()的返回值就是环绕通知的返回值，proceedingJoinPoint是个接口，
* implement JoinPoint,所以也可以获得目标函数的类名，方法名等参数。
*/
@Around("pointCutMethod() || testAOP()")
public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("@Around:进入方法---环绕通知--order=3");
Object o = pjp.proceed();
System.out.println("@Around:退出方法---环绕通知--order=3");
return o;
}
}
上面是我写的一个例子，结合例子我们来看看这些核心的概念：
2.1、切面(Aspect)：是一个类，里面定义了通知与切点。
2.2、切点(PointCut)：表达式。就是告诉程序要在执行哪些核心业务的时候，执行非核心的业务。
2.3、通知（advice）:五种通知方式：
@Before：前置通知，在调用目标方法之前执行通知定义的任务@After：后置通知，在目标方法执行结束后，无论执行结果如何都执行通知定义的任务@After-returning：后置通知，在目标方法执行结束后，如果执行成功，则执行通知定义的任务@After-throwing：异常通知，如果目标方法执行过程中抛出异常，则执行通知定义的任务@Around：环绕通知，在目标方法执行前和执行后，都需要执行通知定义的任务。
五种通知方式的执行顺序：
正常情况下的执行顺序：
@Around:进入方法---环绕通知--order=3 @Before:开始添加--order=3 ============执行业务方法findUser,查找的用户是：张三============= @Around:退出方法---环绕通知--order=3 @After:最终通知--order=3 @AfterReturning:后置通知--order=3 ---张三---
异常情况下的执行顺序： @Around:进入方法---环绕通知--order=3 @Before:开始添加--order=3 ============执行业务方法addUser============= @After:最终通知--order=3 @AfterThrowing:例外通知--order=3 null
三：切点表达式。
这个表达式有很多种，如方法签名表达式，类型签名表达式，还有其他的表达式，我只用过前面两个，其他的没用过，也不做介绍，如果这两种表达式不能解决问题的可以参考我参考的博客。
execution(<修饰符模式>?<返回类型模式><方法所在类的完全限定名称模式>(<参数模式>)<异常模式>?) execution(modifiers-pattern? ret-type-pattern fully-qualified-class-name (param-pattern) throws-pattern?)
public String springMVCmybatic.com.my.aop.UserServiceImp(String a, int b) throw Exception{
}
- modifier-pattern?：表示方法的修饰符，可有可无；对应的就是 public
- ret-type-pattern：表示方法的返回值；对应的就是 String
- fully-qualified-class-name 方法所在类的完全限定名称；对应的就是 springMVCmybatic.com.my.aop.UserServiceImp
- param-pattern：表示方法的参数；对应的就是 String a, int b
- throws-pattern：表示方法抛出的异常，可有可无；对应的就是 throw Exception
3.2：&&，||，！
@Around("pointCutMethod() || testAOP()")
public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("@Around:进入方法---环绕通知");
Object o = pjp.proceed();
System.out.println("@Around:退出方法---环绕通知");
return o;
}
表达式之间可以采用与，或，非的方式来过滤。
四：多个切点的执行顺序
上面的例子中，定义了order=3，重新创建一个切面，定义order=6，执行的结果是：
@Around:进入方法---环绕通知--order=3 @Before:开始添加--order=3 @Around:进入方法---环绕通知--order=6 @Before:开始添加--order=6 ============执行业务方法findUser,查找的用户是：张三============= @Around:退出方法---环绕通知--order=6 @After:最终通知--order=6 @AfterReturning:后置通知--order=6 ---张三--- @Around:退出方法---环绕通知--order=3 @After:最终通知--order=3 @AfterReturning:后置通知--order=3 ---张三--- @Around:进入方法---环绕通知--order=3 @Before:开始添加--order=3 @Around:进入方法---环绕通知--order=6 @Before:开始添加--order=6 ============执行业务方法addUser============= @After:最终通知--order=6 @AfterThrowing:例外通知--order=6 null @After:最终通知--order=3 @AfterThrowing:例外通知--order=3 null
从结果中可以看出order越小越先执行，执行完了之后就order越小就越后推出。总结为下面的图：
【参考博客】
1、http://blog.csdn.net/javazejian/article/details/56267036/
2、http://blog.csdn.net/qqxhwwqwq/article/details/51678595