Spring AOP的解读
一、为什么会有AOP
在日常的开发中经常会有这样一种场景，支付相关的业务中经常需要记录日志，而记录的日志大体相同；这样就会造成支付组件和日志组件强关联，耦合在一起了。而AOP的出现就是为了解决这种问题的。
二、什么是AOP
AOP里面有这样几个概念：目标对象、切点、切面支持类、切面、通知。AOP为开发者提供一种横切关注点（如日志组件横切了支付组件）分离并织入的机制，把横切关注点分离，然后通过某种技术织入到系统中，从而解耦了相关组件。
三、认识AOP
使用AOP功能需要的jar包如下：
1、接口类：
public interface IHelloWorldService { public boolean sayHello(); }
2、接口实现类：
public class HelloWorldService implements IHelloWorldService { public boolean sayHello() { System.out.println("=======Hello World:"); return true; } }
3、切面支持类：该类就是通知的具体实现，切面是切点+通知的组合。
public class HelloWorldAspect { public void beforeAdvice() { System.out.println("=======before advice:"); } public void afterFinalAdvice() { System.out.println("========after advice" ); } }
HelloWorldAspect并不是真正的切面实现，而是定义通知实现的类，我们可以将它看做是缺少了切入点的切面。
4、Spring配置文件
<bean id="helloWorldService" class="aop.HelloWorldService"/> <bean id="aspect" class="aop.HelloWorldAspect"/> <aop:config> <aop:pointcut id="pointcut" expression="execution(* aop..*.*(..))"/> <aop:aspect ref="aspect"> <aop:before pointcut-ref="pointcut" method="beforeAdvice()"/> <aop:after pointcut="execution(* aop..*.*(..))" method="afterFinalAdvice"/> </aop:aspect> </aop:config>
1、<aop:config>：AOP相关的功能都在该标签下面
2、<aop:pointcut id="pointcut" expression="execution(* aop..*.*(..))"/>
切点的定义，这种定义的方式可以让多个切面通过id的形式重复引用，expression表达式表示的是匹配aop包（包含子包）下任何类的任何方法。
3、<aop:aspect ref="aspect">
标签<aop:aspect>用来定义切面，其中的ref用来引用切面支持类的方法。
4、<aop:before pointcut-ref="pointcut" method="beforeAdvice()"/>
这里定义的是前置通知，包含切点和通知里面的具体方法。其中定义切点有两种方式：pointcut-ref="pointcut"或者pointcut="execution(* aop..*.*(..))"，两者只能选择其一。而method用来引用切面通知实现类中的方法。
5、测试类：
public class AopTest { public static void main(String[] args) throws Exception { ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); IHelloWorldService bean = ctx.getBean("helloWorldService",IHelloWorldService.class); bean.sayHello(); } }
6、执行结果：
=======before advice: =======Hello World: ========after advice
从结果可以看出来，尽管DEMO很简单，但是实现了关联组件的解耦。可以通过定义切面的方式，让目标方法在执行前后，执行我们的通知方法。
四、Spring的通知类型
在前面的实例中，用到了前置通知和后置最终通知两种类型。在现实情况中，组件组合的方式不仅要有很多种，而且还要很灵活。这就要求Spring对切面有不同形式的定义，所以Spring给我们带来了如下几种通知：
1、前置通知：在切入点选择的连接点处的方法执行之前的通知，该通知不影响正常程序的执行流程。
2、后置最终通知：在切入点选择的连接点处的方法返回时执行的通知，不管业务方法是否抛出异常，都会调用该通知，相当于finally块。
3、后置返回通知：在切入点选择的连接点处的方法正常执行完毕时执行的通知（连接点处方法执行完毕后没有抛出任何异常才会去执行该通知）
4、后置异常通知：在切入点选择的连接点处的方法抛出异常返回时执行的通知。（连接点处的方法抛异常才会执行该通知）
5、环绕通知：环绕着在切入点选择的连接点处的方法所执行的通知，环绕通知可以在方法调用之前和之后自定义任何行为，并且可以决定是否执行连接点处的方法、替换返回值、抛出异常等等。
我们现在看来下这几种通知的具体实现：
1）前置通知
这次演示前置通知如何传递参数：
目标类：
public class HelloWorldService implements IHelloWorldService { public boolean sayHello(String str) { System.out.println("=======Hello World: str=" + str); return true; } }
切面支持类：
public class HelloWorldAspect { public void beforeAdvice(String str) { System.out.println("=======before advice: str=" + str); } public void afterFinalAdvice() { System.out.println("========after advice" ); } }
切面定义：
<bean id="helloWorldService" class="aop.HelloWorldService"/> <bean id="aspect" class="aop.HelloWorldAspect"/> <aop:config> <aop:pointcut id="pointcut" expression="execution(* aop..*.*(..)) and args(param)"/> <aop:aspect ref="aspect"> <aop:before pointcut-ref="pointcut" method="beforeAdvice(java.lang.String)" arg-names="param"/> </aop:aspect> </aop:config>
切面的配置最关键，这里的切点的表达式定义在原有的基础上新增了一个参数，参数的类型与通知实现方式中的类型相同。
而前置通知里面方法的类型为String，arg-names="param"的作用是切入点中使用“args(param)”匹配的目标方法参数将自动传递给通知实现方法同名参数。
测试类：
public class AopTest { public static void main(String[] args) throws Exception { ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); IHelloWorldService bean = ctx.getBean("helloWorldService",IHelloWorldService.class); bean.sayHello("hangzhou"); } }
执行结果：
=======before advice: str=hangzhou
=======Hello World: str=hangzhou
2）后置返回通知
目标类：目标方法返回值为true
public class HelloWorldService implements IHelloWorldService { public boolean sayHello() { System.out.println("=======Hello World"); return true; } }
通知实现类，这里接收
public class HelloWorldAspect { public void beforeAdvice(String str) { System.out.println("=======before advice: str=" + str); } public void afterFinalAdvice(Object arg) { System.out.println("========after advice.arg=" + arg); } }
切面配置：其中arg-names="retVal"表示指定通知方法的参数名为“retVal”;returning="retVal"用于将目标方法的返回值赋给通知实现方法中参数名为“retVal”的参数
<bean id="helloWorldService" class="aop.HelloWorldService"/> <bean id="aspect" class="aop.HelloWorldAspect"/> <aop:config> <aop:pointcut id="pointcut" expression="execution(* aop..*.*(..))"/> <aop:aspect ref="aspect"> <aop:after-returning pointcut-ref="pointcut" method="afterFinalAdvice" arg-names="retVal" returning="retVal"/> </aop:aspect> </aop:config>
执行结果：
=======Hello World ========after advice.arg=true
这里可以看到目标方法的返回值赋给了通知实现方法中的参数。
3）后置异常通知
目标类：
public class HelloWorldService implements IHelloWorldService { public boolean sayHello() { System.out.println("=======Hello World"); throw new RuntimeException(); } }
通知实现类：
public class HelloWorldAspect { public void beforeAdvice(String str) { System.out.println("=======before advice: str=" + str); } public void afterFinalAdvice(Exception arg) { System.out.println("========after advice.arg=" + arg ); } }
切面定义部分：这里与参数传递类似，目标类抛出异常，通知方法才会被执行。且这里通过参数传递的方式，实现了将目标方法抛出的异常作为参数传递到通知实现方法中
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* aop..*.*(..))"/>
<aop:aspect ref="aspect">
<aop:after-throwing pointcut-ref="pointcut"
method="afterFinalAdvice" arg-names="retVal" throwing="retVal"/>
</aop:aspect>
</aop:config>
执行结果：
=======Hello World
========after advice.arg=java.lang.RuntimeException
4）环绕通知：环绕通知时十分强大，可以决定目标方法是否执行、什么时候执行、执行时是否需要替换方法参数、执行完毕后是否需要替换返回参数。
环绕通知方法中的第一个参数必须是org.aspectj.lang.ProceedingJoinPoint类型，在通知实现方法内部使用ProceedingJoinPoint的proceed()方法使目标方法执行，proceed方法可以传入可选的Object[]数组，该数组的值将作为目标方法执行时的参数。
目标类：
public class HelloWorldService implements IHelloWorldService { public boolean sayHello() { System.out.println("=======Hello World"); throw new RuntimeException(); } @Override public void around(String param) { System.out.println("======Hello Around param:" + param); } }
通知实现类片段：
public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable { Object retVal = pjp.proceed(new Object[] {"hangzhou"}); System.out.println("===========around after advice"); return retVal; }
切面定义部分：
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* aop..*.*(..))"/>
<aop:aspect ref="aspect">
<aop:around pointcut-ref="pointcut"
method="aroundAdvice"/>
</aop:aspect>
</aop:config>
测试类：
public static void main(String[] args) throws Exception { ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); IHelloWorldService bean = ctx.getBean("helloWorldService",IHelloWorldService.class); bean.around("haha"); }
执行结果：
======Hello Around param:hangzhou
===========around after advice
从结果看到，我们在测试类中传入的参数“haha”被通知实现类中的方法替换成了“hangzhou”。
这里要注意的是：Object retVal = pjp.proceed(new Object[] {"hangzhou"}); ，proceed方法用于执行目标方法，且目标方法的参数被new Object[]该数组替换，最终返回retVal字段。
引入
Spring允许为目标类引入新的接口，通过在< aop:aspect>标签内使用< aop:declare-parents>标签进行引入
引入新增接口：
public interface IProductService { public void product(); }
接口实现类：
public class ProductService implements IProductService { @Override public void product() { System.out.println("==========hello product"); } }
配置文件：types-matching表示匹配接口IHelloWorldService的实现类，如HelloWorldService；implement-interface表示引入的接口；default-impl表示引入接口的实现。
<aop:config>
<aop:aspect>
<aop:declare-parents types-matching="aop.IHelloWorldService+"
implement-interface="aop.IProductService"
default-impl="aop.ProductService"/>
</aop:aspect>
</aop:config>
测试类：ctx.getBean("helloWorldService", IProductService.class);可以直接获取到引入的接口。
public static void main(String[] args) throws Exception { ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml"); // IHelloWorldService bean = // ctx.getBean("helloWorldService",IHelloWorldService.class); // bean.around("haha"); IProductService productService = ctx.getBean("helloWorldService", IProductService.class); productService.product(); }
执行结果：
==========hello product
