Sring AOP通过PointCut来指定在那些类的那些方法上织入横切逻辑，通过Advice来指定在切点上具体做什么事情。如方法前做什么，方法后做什么，抛出异常做什么。
再来看一下图
定义PointCut
Spring中有两种方式定义Pointcut：
- XML文件
- 注解
在xml文件中，入门中做了的演示：
<aop:config>
<!-- 定义切点 -->
<aop:pointcut id="hello" expression="execution(public * * (..))"></aop:pointcut>
...
</aop:config>
注解的方式：
@Component
@Aspect
public class HelloWorld {
@Pointcut("execution(public * * (..))")
public void sayHello(){
System.out.println("hello");
}
...
}
XML与注解方式类似，学会了一种，另外一种无难度上手，我们使用XML演示。
增强(Advice)
通过Idea，看一下Advice接口的接口继承类：
[图片上传失败...(image-d49d25-1530458748566)]
主要可分为5类增强：
MthodBeforeAdvice：目标方法实施前增强
AfterReturningAdvice：目标方法实施后增强
ThrowsAdvice 异常抛出增强
IntroductionAdvice 引介增强，为目标类添加新的属性和方法。可以构建组合对象来实现多继承
MethodInterceptor 方法拦截器，环绕增强，在方法的前后实施操作
AfterAdvice,BeforeAdvice当前是作为标记使用，内部无接口方法，为后来扩展使用。
Interceptor接口也不是直接使用，同样作为标记类，可使用其子接口。
前置增强
前置增强主要在匹配到的切点运行之前执行，在XML配置中使用<aop:before>，相应的接口为MethodBeforeAdvice，其方法为
/**
* @param method 要被激发的方法
* @param args 方法的参数
* @param target 目标对象，可能为null
* @throws Throwable 如果这个对象想要终止调用，那么抛出异常，异常会返回给方法调用者，否则异常会被包装为运行时异常
*/
void before(Method method, Object[] args, Object target) throws Throwable;
当一个Bean对象实现了MethodBeforeAdvice，在XML配置文件中指定这个bean为advice，Spring会自动在切点方法执行前执行MethodBeforeAdvice的接口。
<bean id="helloworld" class="me.aihe.exam.controller.HelloWorld" />
<!-- timelog实现了MethodBeforeAdvice接口 -->
<bean id="timeLog" class="me.aihe.exam.controller.TimeLoggingAop" />
<aop:config>
<aop:pointcut id="hello" expression="execution(public * * (..))"></aop:pointcut>
<!-- advisor的作用为将Pointcut和Advice组装起来 -->
<aop:advisor
id="timelogAdvisor"
advice-ref="timeLog"
pointcut-ref="hello"
/>
</aop:config>
在调用相应的切点方法之前，前置增强都会生效。
后置增强
弄明白了前置增强，后置增强也是同一个道理，不过后置增强是在切点运行后执行。接口为AfterReturningAdvice，方法为
/**
* 当方法成功返回之后运行
* @param returnValue 如果方法有返回值，那么returnValue就是返回值
* @param method 激发的方法
* @param args 方法的参数
* @param target 目标对象
* @throws Throwable 同上
*/
void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable;
在切点方法运行之后，后置增强会生效。
异常抛出增强
当切点方法抛出异常时，异常抛出增强才会被执行。其接口为ThrowsAdvice，接口没有指定方法，实现这个接口的对象是通过反射来调用其增强方法的。
// 异常增强方法格式如下
// 前面的三个参数是可选的，ThrowableSubclass为Throwable的子类
void afterThrowing([Method, args, target], ThrowableSubclass)
//案例如下
public void afterThrowing(Exception ex)
public void afterThrowing(RemoteException)
public void afterThrowing(Method method, Object[] args, Object target, Exception ex)
public void afterThrowing(Method method, Object[] args, Object target, ServletException ex)
增强案例
根据前面的前置，后置，异常抛出增强，看一个完整的案例：
// TimeLoggingAop实现了前置增强，后置增强，异常环绕增强
public class TimeLoggingAop implements MethodBeforeAdvice,AfterReturningAdvice,ThrowsAdvice {
private long startTime = 0;
@Override
public void before(Method method, Object[] objects, Object o) throws Throwable {
startTime = System.nanoTime();
}
@Override
public void afterReturning(Object returnValue, Method method, Object[] objects, Object target) throws Throwable {
long spentTime = System.nanoTime() - startTime;
String clazzName = target.getClass().getCanonicalName();
String methodName = method.getName();
System.out.println("执行" + clazzName + "#" + methodName + "消耗" + new BigDecimal(spentTime).divide(new BigDecimal(1000000)) + "毫秒");
}
public void afterThrowing(Method method, Object[] args, Object target, Exception ex){
System.out.println("执行" + method.getName() + "出现异常，" + "异常消息为：" + ex.getMessage());
}
}
// 普通的HelloWorld对象
public class HelloWorld {
public void sayHello(){
System.out.println("hello");
}
public void sayHelloWithException(){
System.out.println("hello");
throw new RuntimeException("Hello World运行时出了一点问题");
}
}
public static void main(String[] args) {
//普通对象
HelloWorld helloWorld = new HelloWorld();
//增强对象
BeforeAdvice beforeAdvice = new TimeLoggingAop();
//组装普通对象和增强对象
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(helloWorld);
proxyFactory.addAdvice(beforeAdvice);
//获取组装后的代理对象
HelloWorld proxyHelloWorld = (HelloWorld) proxyFactory.getProxy();
//运行
proxyHelloWorld.sayHello();
proxyHelloWorld.sayHelloWithException();
}
//运行结果
hello
执行me.aihe.exam.controller.HelloWorld#sayHello消耗29.392268毫秒
hello
执行sayHelloWithException出现异常，异常消息为：Hello World运行时出了一点问题
通过上面这个案例，我们大体知道什么是增强，字面意思：
在原本方法之上增加一些额外的东西，原本的功能增强了，所以叫增强，这是中文翻译过来的增强。
英文名为Advice，建议，在方法周围建议方法做什么事情，然后真的做了...
环绕增强
环绕增强可以理解为前置增强，后置增强，异常抛出增强的结合体，只有一个接口MethodInterceptor，其方法为：
// MethodInvocation封装了目标对象和参数数组，调用它的invocation.proceed()方法即激发目标对象的方法。
Object invoke(MethodInvocation invocation) throws Throwable;
一个用法案例：
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("前置增强执行");
try {
Object result = invocation.proceed();
System.out.println("后置增强执行");
return result;
}catch (Exception e){
System.out.println("异常抛出增强执行");
//做其它的动作
}
return null;
}
增强顺序
当多个增强作用与同一个切点的时候，具体哪一个增强会先执行呢？
Spring根据@Order注解或者实现了Ordered接口的增强类来进行判断。
public interface Ordered {
int HIGHEST_PRECEDENCE = -2147483648;
int LOWEST_PRECEDENCE = 2147483647;
int getOrder();
}
注解相关增强
增强的概念一样，在使用方式上稍微有点区别，增强的相关注解有：
@Before
@AfterReturning
@AfterThrowing(
@After //相当于try-catch-finally中的final，一般用于释放资源
@Around
使用上与接口差不多
最后
增强是AOP中核心概念之一，本文在增强上稍作一些探索，深入还要靠大家，最后希望能帮到大家
参考
- 《Spring Reference》
- 《精通Spring 4.x 企业级应用开发实战》
