AOP概念与Spring AOP实践-优快云博客

本文链接：https://blog.youkuaiyun.com/zyzyzyzyzyzyzyzyz/article/details/104436392

概念

1 AOP：面向切面（方面）编程。实现：扩展功能不修改源代码

2 AOP 采取横向抽取机制，取代了传统纵向继承体系重复性代码

传统纵向是指继承、接口实现这两种方式来实现代码的拓展
横向机制下面解释

3 AOP底层使用动态代理实现

（1）第一种情况，有接口情况，使用动态代理创建接口实现类代理对象

（2）第二种情况，没有接口情况，使用动态代理创建类的子类代理对象

原理

AOP：不修改代码，但想要拓展原来的功能：

最原始方法：修改代码
传统纵向机制：
继承父类
缺点：父类名称变化，子类的调用方法也要发生变化
AOP动态代理实现：
针对接口创建jdk代理，针对父类子类创建cglib动态代理

AOP方法：针对有接口的情况下
- 创建一个与实现接口类平级的对象
- 这个对象是代理对象，功能与实现接口的类相同
AOP：针对没有接口的情况
- 创建子类的代理对象
- 调用父类的方法得到增强

AOP操作术语

Joinpoint(连接点): 类里面可以被增强的方法，这些方法称为连接
Pointcut(切入点):所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.
Advice(通知/增强):所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)
Aspect(切面): 是切入点和通知（引介）的结合
Introduction(引介):引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.
Target(目标对象):代理的目标对象(要增强的类)
Weaving(织入):是把增强应用到目标的过程.
把advice 应用到 target的过程
Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类

重点

连接点：指的是可以被增强的方法
切入点：在那些可以被增强的方法中，真正实际被增强了的方法
通知/增强：让add()增加一个日志功能，这个日志功能成为增强
//下面是具体实现
1. 前置通知：在方法执行之前执行
2. 后置通知：在方法执行之后执行
3. 异常：方法出现异常
4. 最终：在后置的后面执行
5. 环绕：在方法执行之前和之后
切面：把增强运用到具体的方法【即切入点】上的过程；

Spring的AOP操作

操作准备

除了导入基本的jar包之外，还需要导入aop相关的jar包
创建spring核心配置文件，导入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"> <!-- bean definitions here -->

       
       </beans>

使用表达式配置切入点

切入点：实际增强的方法

常用的表达式
execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)
（1）execution(* cn.itcast.aop.Book.add(…))
：只增强cn.itcast.aop.Book类里面的add方法
（2）execution(* cn.itcast.aop.Book.*(…))
： cn.itcast.aop.Book.*所有方法
（3）execution(* .(…))
：所有类的所有方法
（4） execution(* save*(…))：匹配所有save开头的方法

Aspectj的aop操作

目的：

想要对Book类中的add方法进行加强
创建myBook的before1方法，并且在add()方法执行之前，执行before方法（前置通知）

在目标方法执行之前执行

myBook的方法对Book的add方法进行前置增强

     <!-- 1 配置两个对象 -->
        <bean id="book" class="cn.itclass.Aop.Book"></bean>
        <bean id="myBook" class="cn.itclass.Aop.MyBook"></bean>
        
        <!-- 2 配置AOP操作 -->
        <aop:config>
             <!-- 2.1 配置切入点 【被增强的方法】-->
             <aop:pointcut expression="execution(* cn.itclass.Aop.Book.add(..))" id="cutPoint1"/>
             
             <!-- 2.2 配置切面 ： 把增强的方法（myBook)用到方法上
                                 ref:指的是增强的方法 （用myBook来增强Book，ref=myBook-->
             <aop:aspect ref="myBook">
                    <!-- 配置增强的类型
                          将增强和被增强的方法对应起来
                         method：使用增强类里面具体哪个方法作为前置（or后置等等）
                         pointcut-ref:指的是切入点
                     -->
                       <!-- 前置增强 -->
                     <aop:before method="before1" pointcut-ref="cutPoint1"/>
                     <!-- 环绕增强 -->
                     <aop:around method="around" pointcut-ref="cutPoint1"/>
                     <!-- 后置增强 -->
                     <aop:after-returning method="after1" pointcut-ref="cutPoint1"/>
             </aop:aspect>
        </aop:config>
</beans>



public class MyBook {
	//前置增强
	public void before1() {
		System.out.println("before.......");
	}
	//环绕增强
	
	public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
		/*
		 * 1.先执行第一个
		 * 2. 执行原来的功能
		 * 3.执行添加的第二个功能
		 */
		//功能之前：
		System.out.println("我在环绕之前执行");
		//执行原有功能
		proceedingJoinPoint.proceed();
		//执行之后的功能
		System.out.println("我是之后的功能");
	}
	//后置增强
	public void after1() {
		System.out.println("after........");
	}
}