一、什么是AOP？

Aspect Oriented Programing 面向切面编程，相比较 oop 面向对象编程来说，Aop关注的不再是程

序代码中某个类，某些方法，而aop考虑的更多的是一种面到面的切入，即层与层之间的一种切入，所

以称之为切面。联想大家吃的汉堡（中间夹肉）。那么aop是怎么做到拦截整个面的功能呢？考虑前面

学到的servlet filter /* 的配置 ，实际上也是aop 的实现。

二、AOP能做什么？

AOP主要应用于日志记录，性能统计，安全控制,事务处理等方面，实现公共功能性的重复使用。

三、AOP的特点

1. 降低模块与模块之间的耦合度，提高业务代码的聚合度。（高内聚低耦合）

2. 提高了代码的复用性。

3. 提高系统的扩展性。（高版本兼容低版本）

4. 可以在不影响原有的功能基础上添加新的功能

四、AOP的理解和关键词

1. 面向切面，相比oop 关注的是代码中的层 或面

2. 解耦，提高系统扩展性

3. 提高代码复用

Aop 关键词

1. 连接点:每一个方法

2. 切入点:匹配的方法集合

3. 切面：连接点与切入点的集合决定了切面，横切关注点的抽象

4. 通知:几种通知

5. 目标对象:被代理对象

6. 织入：程序运行期将切面应用到目标对象 并生成代理对象的过程

7. 引入:在不修改原始代码情况下，在程序运行期为程序动态引入方法或字段的过程

五、Spring AOP的实现

5.1 Spring AOP环境搭建

坐标依赖引入

<!--Spring AOP-->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.9</version>
</dependency>

添加spring.xml的配置

添加命名空间

xmlns:aop="http://www.springframework.org/schema/aop"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

5.2 注解实现

定义切面

/**
* 切面
* 切入点和通知的抽象 （与面向对象中的 类 相似）
* 定义 切入点和通知 （切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么）
*/
@Component // 将对象交给IOC容器去实例化
@Aspect // 声明当前类是一个切面
public class LogCut {
/**
* 切入点：
* 匹配规则。规定什么方法被拦截、需要处理什么方法
* 定义切入点
* @Pointcut("匹配规则")
* *
Aop 切入点表达式简介
* 1. 执行任意公共方法：
* execution(public *(..))
* 2. 执行任意的set方法
* execution(* set*(..))
* 3. 执行com.xxxx.service包下任意类的任意方法
* execution(* com.xxxx.service.*.*(..))
* 4. 执行com.xxxx.service 包 以及子包下任意类的任意方法
* execution(* com.xxxx.service..*.*(..))
* *
注：表达式中的第一个* 代表的是方法的修饰范围
* 可选值：private、protected、public （* 表示所有范围）
*/
@Pointcut("execution (* com.xxxx.service..*.*(..) )")
public void cut(){}

/**
* 声明前置通知 并将通知应用到定义的切入点上
* 目标类方法执行前 执行该通知
* *
/
@Before(value = "cut()")
public void before() {
System.out.println("前置通知.....");
} /
**
* 声明返回通知 并将通知应用到定义的切入点上
* 目标类方法（无异常）执行后 执行该通知
* *
/
@AfterReturning(value = "cut()")
public void afterReturn() {
System.out.println("返回通知.....");
} /
**
* 声明最终通知 并将通知应用到定义的切入点上
* 目标类方法（无异常或有异常）执行后 执行该通知
* *
/
@After(value = "cut()")
public void after() {
System.out.println("最终通知.....");
} /
**
* 声明异常通知 并将通知应用到定义的切入点上
* 目标类方法出现异常时 执行该通知
*/
@AfterThrowing(value="cut()",throwing = "e")
public void afterThrow(Exception e) {
System.out.println("异常通知....." + " 异常原因：" + e.getCause());
} /
**
* 声明环绕通知 并将通知应用到切入点上
* 方法执行前后 通过环绕通知定义相应处理
* 需要通
* @param pjp
* @return
*/
@Around(value = "cut()")
public Object around(ProceedingJoinPoint pjp) {
System.out.println("前置通知...");
Object object = null;
try {
object = pjp.proceed();
System.out.println(pjp.getTarget() + "======" + pjp.getSignature());
// System.out.println("返回通知...");
} catch (Throwable throwable) {
throwable.printStackTrace();
System.out.println("异常通知...");6.2.2. 配置文件（spring.xml）
6.3. XML实现
6.3.1. 定义切面
}
S
ystem.out.println("最终通知...");
return object;
}
}

配置文件（spring.xml）

<!--配置AOP代理-->
<aop:aspectj-autoproxy/>

5.3 XML实现

定义切面

**
* 切面
* 切入点和通知的抽象 （与面向对象中的 类 相似）
* 定义 切入点和通知 （切入点定义了要拦截哪些类的哪些方法，通知则定义了拦截过方法后要做什么）
*/
@Component // 将对象交给IOC容器去实例化
public class LogCut02 {
public void cut(){}
/**
* 声明前置通知 并将通知应用到定义的切入点上
* 目标类方法执行前 执行该通知
* *
/
public void before() {
System.out.println("前置通知.....");
} /
**
* 声明返回通知 并将通知应用到定义的切入点上
* 目标类方法（无异常）执行后 执行该通知
* *
/
public void afterReturn() {
System.out.println("返回通知.....");
} /
**
* 声明最终通知 并将通知应用到定义的切入点上
* 目标类方法（无异常或有异常）执行后 执行该通知
* *
/6.3.2. 配置文件（spring.xml）
public void after() {
System.out.println("最终通知.....");
} /
**
* 声明异常通知 并将通知应用到定义的切入点上
* 目标类方法出现异常时 执行该通知
*/
public void afterThrow(Exception e) {
System.out.println("异常通知....." + " 异常原因：" + e.getCause());
} /
**
* 声明环绕通知 并将通知应用到切入点上
* 方法执行前后 通过环绕通知定义相应处理
* 需要通过显式调用对应的方法，否则无法访问指定方法 (pjp.proceed();)
* @param pjp
* @return
*/
public Object around(ProceedingJoinPoint pjp) {
System.out.println("前置通知...");
Object object = null;
try {
object = pjp.proceed();
System.out.println(pjp.getTarget() + "======" + pjp.getSignature());
// System.out.println("返回通知...");
} catch (Throwable throwable) {
throwable.printStackTrace();
System.out.println("异常通知...");
} S
ystem.out.println("最终通知...");
return object;
}
}

配置文件（spring.xml）

<!--aop相关配置-->
<aop:config>
<!--aop切面-->
<aop:aspect ref="logCut02">
<!-- 定义aop 切入点 -->
<aop:pointcut id="cut" expression="execution(* com.xxxx.service..*.*
(..))"/>
<!-- 配置前置通知 指定前置通知方法名 并引用切入点定义 -->
<aop:before method="before" pointcut-ref="cut"/>
<!-- 配置返回通知 指定返回通知方法名 并引用切入点定义 -->
<aop:after-returning method="afterReturn" pointcut-ref="cut"/>
<!-- 配置异常通知 指定异常通知方法名 并引用切入点定义 -->7. Spring AOP总结
7.1. 代理模式实现三要素
1. 接口定义
2. 目标对象与代理对象必须实现统一接口
3. 代理对象持有目标对象的引用 增强目标对象行为
7.2. 代理模式实现分类以及对应区别
1. 静态代理：手动为目标对象制作代理对象，即在程序编译阶段完成代理对象的创建
2. 动态代理：在程序运行期动态创建目标对象对应代理对象。
3. jdk动态代理：被代理目标对象必须实现某一或某一组接口 实现方式 通过回调创建代理对象。
4. cglib 动态代理：被代理目标对象可以不必实现接口，继承的方式实现。
动态代理相比较静态代理，提高开发效率，可以批量化创建代理，提高代码复用率。
7.3. Aop 理解
1. 面向切面，相比oop 关注的是代码中的层 或面
2. 解耦，提高系统扩展性
3. 提高代码复用
7.4. Aop 关键词
1. 连接点:每一个方法
2. 切入点:匹配的方法集合
3. 切面：连接点与切入点的集合决定了切面，横切关注点的抽象
4. 通知:几种通知
5. 目标对象:被代理对象
6. 织入：程序运行期将切面应用到目标对象 并生成代理对象的过程
7. 引入:在不修改原始代码情况下，在程序运行期为程序动态引入方法或字段的过程
<aop:after-throwing method="afterThrow" throwing="e" pointcutref="cut"/>
<!-- 配置最终通知 指定最终通知方法名 并引用切入点定义 -->
<aop:after method="after" pointcut-ref="cut"/>
<!-- 配置环绕通知 指定环绕通知方法名 并引用切入点定义 -->
<aop:around method="around" pointcut-ref="cut"/>
</aop:aspect>
</aop:config>

六、Spring AOP总结

6.1. 代理模式实现三要素

1. 接口定义

2. 目标对象与代理对象必须实现统一接口

3. 代理对象持有目标对象的引用 增强目标对象行为

6.2. 代理模式实现分类以及对应区别

1. 静态代理：手动为目标对象制作代理对象，即在程序编译阶段完成代理对象的创建

2. 动态代理：在程序运行期动态创建目标对象对应代理对象。

3. jdk动态代理：被代理目标对象必须实现某一或某一组接口 实现方式 通过回调创建代理对象。

4. cglib 动态代理：被代理目标对象可以不必实现接口，继承的方式实现。

动态代理相比较静态代理，提高开发效率，可以批量化创建代理，提高代码复用率。