AOP理论概述
Aspect Oriented Programming 面向切面编程
业界 AOP 实际上 OOP （面向对象编程 ） 延伸 —- OOP编程语言、 AOP设计思想
AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码（性能监视、事务管理、安全检查、缓存）
横向抽取代码复用，基于代理技术，在不修改原有对象代码情况下，对原有对象方法功能进行增强！ ———- AOP 思想
Spring框架如何实现AOP
Spring1.2 版本开始 开始支持AOP技术 （传统Spring AOP ）
Spring2.0之后，为了简化AOP开发，开始支持 AspectJ （第三方框架）AOP 框架
学习重点： AspectJ AOP开发
1.3.AOP相关术语
1.Joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点.
2.Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.
3.Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
4.Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.
5.Target(目标对象):代理的目标对象
6.Weaving(织入):是指把增强应用到目标对象来创建新的代理对象的过程.
7.spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入
8.Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类
9.Aspect(切面): 是切入点和通知（引介）的结合
AOP底层实现
Spring AOP 代理实现有两种： JDK动态代理 和 Cglib框架动态代理
JDK动态代理
JDK API 内置 —- 通过 Proxy类，为目标对象创建代理 （必须面向接口代理 ）
public class JdkProxyFactory implements InvocationHandler {
// 被代理对象
private Object target;
// 在构造方法对象时，传入被代理对象
public JdkProxyFactory(Object target) {
this.target = target;
}
// 创建代理
public Object createProxy() {
// 三个参数： 类加载器、 实现接口、 invocationhandler
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("记录日志！！！！！！");
// 调用目标真实方法
// target 被代理对象， args 方法参数 ， method 被调用的方法
return method.invoke(target, args);
}
}缺点： 使用Jdk动态代理，必须要求target目标对象，实现接口 ，如果没有接口，不能使用Jdk动态代理 。
Cglib 动态代理
CGLIB(Code Generation Library)是一个开源项目！是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。
Cglib 不但可以对接口进行代理，也可以对目标类对象，实现代理 （解决了 Jdk 只能对接口代理问题 ）
下载网址： http://sourceforge.net/projects/cglib/files/
——- 在spring3.2版本 core包中内置cglib 类
public class CglibProxyFactory implements MethodInterceptor {
// 被代理目标对象
private Object target;
// 在构造工厂时传入被代理对象
public CglibProxyFactory(Object target) {
this.target = target;
}
// 创建代理对象方法
public Object createProxy() {
// 1、 创建Enhancer对象
Enhancer enhancer = new Enhancer();
// 2、 cglib创建代理，对目标对象，创建子类对象
enhancer.setSuperclass(target.getClass());
// 3、传入 callback对象，对目标增强
enhancer.setCallback(this);
return enhancer.create();
}
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("记录日志......");
// 按照JDK编程
return method.invoke(target, args);
}
}Cglib 创建代理思想： 对目标类创建子类对象
设置 superClass 对哪个类创建子类 （类似 JDK代理 接口）
设置 callback 实现增强代码 （类似 JDK代理 InvocationHandler ）
在cglib的callback函数中，要执行被代理对象的方法
method.invoke(target, args); 等价于 methodProxy.invokeSuper(proxy, args);
优先对接口代理 （使用JDK代理），如果目标没有接口，才会使用cglib代理 ！
Spring AOP 编程
传统SpringAOP 通知类型（Spring1.2版本 开始）
首先： AOP联盟定义 Advice 通知接口
org.aopalliance.aop.Interface.Advice
然后： Spring AOP 在Advice 接口基础上，扩充为五种通知类型
通过AspectJ 引入Pointcut切点定义
第一步： 实现aop编程，在项目引入 jar包
?com.springsource.org.aopalliance-1.0.0.jar AOP联盟定义规范jar包
?spring-aop-3.2.0.RELEASE.jar Spring对象AOP Advice扩展
?com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar AspectJ框架jar包
?spring-aspects-3.2.0.RELEASE.jar Spring对AspectJ支持 jar包
第二步： 配置文件 ，引入aop名称空间
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
第三步： 编写Advice
/**
* 自定义环绕通知 (传统spring AOP Advice)
*
* @author seawind
*
*/
public class MyMehtodInterceptor implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
System.out.println("环绕前增强====================");
// 调用目标方法
Object result = methodInvocation.proceed();
System.out.println("环绕后增强====================");
return result;
}
}
第四步： 定义PointCut 切面
execution(* cn.itcast.service...(..)) 拦截service包包含子包下所有类所有方法
execution(* .s(..)) 拦截以s开头的方法
<!-- 配置目标对象 -->
<bean id="orderService" class="cn.itcast.spring.c_aop.OrderServiceImpl" />
<!-- 配置自定义Advice(传统) -->
<bean id="mymethodadvice" class="cn.itcast.spring.c_aop.MyMehtodInterceptor" />
<!-- 配置切面 -->
<!-- 进行aop相关配置 -->
<aop:config>
<!--
aop:advisor: 定义spring传统AOP的切面的， 只支持一个PointCut和 一个Advice
aop:aspect : 定义AspectJ框架切面的 ，可以包含多个PointCut 和 多个Advice
aop:pointcut : 切点定义
-->
<aop:pointcut expression="execution(* cn.itcast.spring.c_aop.OrderServiceImpl.*(..))" id="mypointcut"/>
<aop:advisor advice-ref="mymethodadvice" pointcut-ref="mypointcut"/>
</aop:config>总结：
AOP Advisor ==== 传统Spring AOP Advice（一个） + 切点（一个）
AspectJ AOP 编程
AspectJ 是一个框架 （第三方AOP框架 ），提供切面编程 ，编写一个Aspect 支持多个Advice和多个PointCut 。
AspectJ 通知类型
相比Spring通知类型，多了一种 After 最终通知
Before前置通知
在目标方法执行前 进行增强代码
AspectJ 提供Advice无需实现任何借口， 可以将很多通知代码 写入一个类 （切面类）
前置通知定义方法： 无返回值，可以传入参数 JoinPoint 连接点
public class MyAspect {
public void before1() {
System.out.println("前置通知 1.....");
}
细节：
1、 默认不能阻止目标方法执行，如果抛出异常，目标方法无法执行
2、 可以传入JoinPoint 连接点参数 ， 通过该参数可以获得当前拦截对象和方法信息
<!-- 配置目标 -->
<bean id="customerService" class="cn.itcast.spring.d_aspectj.CustomerService" />
<!-- 配置切面Bean -->
<bean id="myAspect" class="cn.itcast.spring.d_aspectj.MyAspect" />
<!-- AOP切面配置 -->
<aop:config>
<!-- ref 引用定义切面类 -->
<aop:aspect ref="myAspect">
<aop:pointcut expression="execution(* cn.itcast.spring.d_aspectj.CustomerService.*(..))" id="mypointcut2"/>
<aop:before method="before1" pointcut-ref="mypointcut2"/>
<aop:before method="before2" pointcut-ref="mypointcut2"/>
</aop:aspect>
</aop:config>AfterReturning 后置通知
在目标业务方法执行后，进行代码增强
// 可以在后置通知传入两个参数 1、 连接点对象 2、目标方法返回值
public void afterReturning(JoinPoint joinPoint, Object result) {
System.out.println("后置通知.... 目标方法运行返回值 ：" + result);
}<!-- returning参数，定义后置通知 接收目标方法返回值 参数名称 -->
<aop:after-returning method="afterReturning" returning="result2" pointcut-ref="mypointcut2"/>细节：
后置通知 可以获得方法的返回值 ， 在配置文件定义返回值参数名 必须要和方法参数名一致 。
Around 环绕通知
在目标方法执行前后，进行代码增强 （阻止目标方法的执行 ）
环绕通知实现任何通知效果
// 环绕通知 (需要将目标方法 返回值 返回), 传入参数 可执行的连接点
public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
System.out.println("环绕通知 方法前执行 ....");
Object result = proceedingJoinPoint.proceed(); // 执行目标方法
System.out.println("环绕通知 方法后执行.... 方法返回值：" + result);
return result;
}<!-- 环绕通知 -->
<aop:around method="around" pointcut-ref="mypointcut2" />AfterThrowing 抛出通知
在目标方法出现异常后，通知方法会得到执行 —– 错误日志记录
// 日志记录器
private static final Logger LOG = Logger.getLogger(MyAspect.class);
// 抛出通知
// 第一个参数 JointPoint 连接点
// 第二个参数 目标方法出现异常后，捕获到异常对象
public void afterThrowing(JoinPoint joinPoint, Throwable ex) {
System.out.println("哪个方法出现异常：" + joinPoint.toLongString());
// 调用日志记录API，将异常对象 写入日志文件
LOG.error(ex.getMessage(), ex);
}方法接收两个参数 连接点和异常对象
<!-- 异常通知 -->
<!-- throwing属性，配置发生异常后，捕获的异常对象参数名称 （和方法一致） -->
<aop:after-throwing method="afterThrowing" throwing="ex" pointcut-ref="mypointcut2"/>After 最终通知
无论目标方法是否出现异常，该通知都会执行 —— 类似 finally 代码块
应用场景 ： 释放资源
// 最终通知
public void after(JoinPoint joinPoint) {
System.out.println("最终通知... 释放资源.... ");
}<!-- 最终通知 -->
<aop:after method="after" pointcut-ref="mypointcut2" />