Spring AOP

魔焰-莫言

于 2023-11-21 11:16:40 发布

阅读量53

点赞数

分类专栏：框架文章标签： spring 代理模式 java

本文链接：https://blog.csdn.net/H12345667/article/details/134433197

版权

框架专栏收录该内容

8 篇文章 0 订阅

订阅专栏

Spring AOP

1.主要内容
2.代理模式
3.静态代理
- - 静态代理的实现
4.动态代理
5.什么是AOP？
6.Spring AOP的实现
- Spring AOP环境搭建
7.Spring AOP总结

1.主要内容

在这里插入图片描述

2.代理模式

为一个委托类（目标对象）提供一个代理类（代理对象），用来控制对这个对象的访问。委托类和代理类有一个共同的父类或接口。

作用：可以通过代理对象实现目标对象的行为，并对目标对象的行为进行增强

⽣活中常⻅的代理情况：租房中介、婚庆公司等
       
代理模式的两个设计原则：
 1. 代理类 与 委托类 具有相似的⾏为（共同）
 2. 代理类增强委托类的⾏为

常⽤的代理模式：
 1. 静态代理
 2. 动态代理

3.静态代理

 代理的三要素
a、有共同的⾏为（结婚） - 接⼝
b、⽬标⻆⾊（新⼈） - 实现⾏为
c、代理⻆⾊（婚庆公司） - 实现⾏为 增强⽬标对象⾏为

 静态代理的特点
1、⽬标⻆⾊固定
2、在应⽤程序执⾏前就得到⽬标⻆⾊
3、代理对象会增强⽬标对象的⾏为
4、有可能存在多个代理 引起"类爆炸"（缺点）

静态代理的实现

1.定义⾏为（共同）定义接⼝
在这里插入图片描述
2. ⽬标对象（实现⾏为）

代理对象（实现⾏为、增强⽬标对象的⾏为）

/**
* 静态代理 ——> 代理对象
*/
public class MarryCompanyProxy implements Marry {
		 // ⽬标对象
		 private Marry marry;
		 // 通过构造器将⽬标对象传⼊
		 public MarryCompanyProxy(Marry marry) 
		 {
			 this.marry = marry;
		 }
		 // 实现⾏为
		 @Override
		 public void toMarry() 
		 {
				 // 增强⾏为
				 before();
				 
				 // 执⾏⽬标对象中的⽅法
				 marry.toMarry();
				
				// 增强⾏为
				 after();
		 }
		 /**
		 * 增强⾏为
		 */
		 private void after() {
		 		System.out.println("新婚快乐，早⽣贵⼦！");
		 }
		 /**
		 * 增强⾏为
		 */
		 private void before() {
		 		System.out.println("场地正在布置中...");
		 }
}

通过代理对象实现⽬标对象的功能

静态代理对于代理的⻆⾊是固定的，如dao层有20个dao类，如果要对⽅法的访问权限进⾏代理，此时
需要创建20个静态代理⻆⾊，引起类爆炸，⽆法满⾜⽣产上的需要，于是就催⽣了动态代理的思想。

4.动态代理

可以根据需要通过反射机制在程序运行期，动态的为目标对象创建代理对象。
  
动态代理的两种实现⽅式：
 1. JDK 动态代理
 2. CGLIB动态代理

 动态代理的特点
1. ⽬标对象不固定
2. 在应⽤程序执⾏时动态创建⽬标对象
3. 代理对象会增强⽬标对象的⾏为

JDK动态代理

注：JDK动态代理的⽬标对象必须有接⼝实现
Proxy类：
Proxy类是专⻔完成代理的操作类，可以通过此类为⼀个或多个接⼝动态地⽣成实现类，此类提供了如下操作⽅法：

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

在这里插入图片描述
获取代理对象:

public class JdkHandler implements InvocationHandler {

	 // ⽬标对象
	 private Object target; // ⽬标对象的类型不固定，创建时动态⽣成
	 
	 // 通过构造器将⽬标对象赋值
	 public JdkHandler(Object target) {
		 this.target = target;
	 }
	 //implements InvocationHandler自带的方法
	 @Override
	 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
	{
		 // 增强⾏为
		 System.out.println("==============⽅法前执⾏");
		 // 调⽤⽬标对象的⽅法（返回Object）
		 Object result = method.invoke(target,args);
		 // 增强⾏为
		 System.out.println("⽅法后执⾏==============");
		 return result;
	 }

 public Object getProxy() {
return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
	 }
}

通过代理对象实现⽬标对象的功能
在这里插入图片描述
动态代理目标是不固定的

注：JDK的动态代理依靠接⼝实现，如果有些类并没有接⼝实现，则不能使⽤JDK代理。

CGLIB 动态代理

JDK的动态代理机制只能代理实现了接⼝的类，⽽不能实现接⼝的类就不能使⽤JDK的动态代理，cglib
是针对类来实现代理的，它的原理是对指定的⽬标类⽣成⼀个⼦类，并覆盖其中⽅法实现增强，但因为
采⽤的是继承，所以不能对final修饰的类进⾏代理。
实现原理：继承思想

在pom.xml⽂件中引⼊cglib的相关依赖

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
 <groupId>cglib</groupId>
 <artifactId>cglib</artifactId>
 <version>2.2.2</version>
</dependency>

定义类
实现MethodInterceptor接⼝

public class CglibInterceptor implements MethodInterceptor {
		 // ⽬标对象
		 private Object target;
		 // 通过构造器传⼊⽬标对象
		 public CglibInterceptor(Object target) {
		 	this.target = target;
		 }
		 /**
		 * 获取代理对象
		 * @return
		 */
		 public Object getProxy() {
			 // 通过Enhancer对象的create()⽅法可以⽣成⼀个类，⽤于⽣成代理对象
			 Enhancer enhancer = new Enhancer();
			 // 设置⽗类 (将⽬标类作为其⽗类)
			 enhancer.setSuperclass(target.getClass());
			 // 设置拦截器 回调对象为本身对象
			 enhancer.setCallback(this);
		 // ⽣成⼀个代理类对象，并返回
		 return enhancer.create();
		 }
		 /**
		 * 拦截器
		 * 1、⽬标对象的⽅法调⽤
		 * 2、增强⾏为
		 * @param object 由CGLib动态⽣成的代理类实例
		 * @param method 实体类所调⽤的被代理的⽅法引⽤
		 * @param objects 参数值列表
		 * @param methodProxy ⽣成的代理类对⽅法的代理引⽤
		 * @return
		 * @throws Throwable
		 */
		 @Override
		 public Object intercept(Object object, Method method, Object[] objects,
		 MethodProxy methodProxy) throws Throwable {
				 // 增强⾏为
				 System.out.println("==============⽅法前执⾏");
				 // 调⽤⽬标对象的⽅法（返回Object）
				 Object result = methodProxy.invoke(target,objects);
				 // 增强⾏为
				 System.out.println("⽅法后执⾏==============");
				 return result;
		 }
}

调⽤⽅法

在这里插入图片描述

JDK代理与CGLIB代理的区别

JDK动态代理实现接⼝，Cglib动态代理继承思想
JDK动态代理（⽬标对象存在接⼝时）执⾏效率⾼于Ciglib
如果⽬标对象有接⼝实现，选择JDK代理，如果没有接⼝实现选择Cglib代理

5.什么是AOP？

Aspect Oriented Programing ⾯向切⾯编程，相⽐较 oop ⾯向对象编程来说，Aop关注的不再是程序代码中某个类，某些⽅法，
⽽aop考虑的更多的是⼀种⾯到⾯的切⼊，即层与层之间的⼀种切⼊，所以称之为切⾯。联想⼤家吃的汉堡（中间夹⾁）。

AOP能做什么？
AOP主要应⽤于⽇志记录，性能统计，安全控制，事务处理等⽅⾯，实现公共功能性的重复使⽤。

AOP的特点
1. 降低模块与模块之间的耦合度，提⾼业务代码的聚合度。（⾼内聚低耦合）
2. 提⾼了代码的复⽤性。
3. 提⾼系统的扩展性。（⾼版本兼容低版本）
4. 可以在不影响原有的功能基础上添加新的功能

AOP的底层实现
动态代理（JDK + CGLIB）

 Aspect（切⾯）
切⼊点与通知的结合，决定了切⾯的定义，切⼊点定义了要拦截哪些类的哪些⽅法，通知则定义了拦
截过⽅法后要做什么，切⾯则是横切关注点的抽象，与类相似，类是对物体特征的抽象，切⾯则是横切关注点抽象。

Target（⽬标对象）
被代理的⽬标对象

 Weave（织⼊）
将切⾯应⽤到⽬标对象并⽣成代理对象的这个过程即为织⼊

Introduction（引⼊）
在不修改原有应⽤程序代码的情况下，在程序运⾏期为类动态添加⽅法或者字段的过程称为引⼊

6.Spring AOP的实现

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

在这里插入图片描述

注解实现

定义切⾯

/**
* 切⾯
* 切⼊点和通知的抽象 （与⾯向对象中的 类 相似）
* 定义 切⼊点和通知 （切⼊点定义了要拦截哪些类的哪些⽅法，通知则定义了拦截过⽅法后要做什么）
*/
@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());
		 }
		 /**
		 * 声明环绕通知 并将通知应⽤到切⼊点上
		 * ⽅法执⾏前后 通过环绕通知定义相应处理
		 * 需要通过显式调⽤对应的⽅法，否则⽆法访问指定⽅法 (pjp.proceed();)
		 * @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("异常通知...");
				 }
				 System.out.println("最终通知...");
				 return object;
		 }
}

配置⽂件（spring.xml）

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

XML实现

定义切⾯

**
* 切⾯
* 切⼊点和通知的抽象 （与⾯向对象中的 类 相似）
* 定义 切⼊点和通知 （切⼊点定义了要拦截哪些类的哪些⽅法，通知则定义了拦截过⽅法后要做什么）
*/
		@Component // 将对象交给IOC容器去实例化
		public class LogCut02 {
		 public void cut(){}
		 /**
		 * 声明前置通知 并将通知应⽤到定义的切⼊点上
		 * ⽬标类⽅法执⾏前 执⾏该通知
		 *
		 */
		 public void before() {
			 System.out.println("前置通知.....");
		 }
		 /**
		 * 声明返回通知 并将通知应⽤到定义的切⼊点上
		 * ⽬标类⽅法（⽆异常）执⾏后 执⾏该通知
		 *
		 */
		 public void afterReturn() {
			 System.out.println("返回通知.....");
		 }
		 /**
		 * 声明最终通知 并将通知应⽤到定义的切⼊点上
		 * ⽬标类⽅法（⽆异常或有异常）执⾏后 执⾏该通知
		 *
		 */
		 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("异常通知...");
					 }
			System.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"/>
		 <!-- 配置异常通知 指定异常通知⽅法名 并引⽤切⼊点定义 -->
		 <aop:after-throwing method="afterThrow" throwing="e" pointcut-ref="cut"/>
		 <!-- 配置最终通知 指定最终通知⽅法名 并引⽤切⼊点定义 -->
		 <aop:after method="after" pointcut-ref="cut"/>
		 <!-- 配置环绕通知 指定环绕通知⽅法名 并引⽤切⼊点定义 -->
		 <aop:around method="around" pointcut-ref="cut"/>
	 </aop:aspect>
</aop:config>

7.Spring AOP总结

7.1. 代理模式实现三要素
	1. 接⼝定义
	2. ⽬标对象与代理对象必须实现统⼀接⼝
	3. 代理对象持有⽬标对象的引⽤ 增强⽬标对象⾏为
	
7.2. 代理模式实现分类以及对应区别
	1. 静态代理：⼿动为⽬标对象制作代理对象，即在程序编译阶段完成代理对象的创建
	2. 动态代理：在程序运⾏期动态创建⽬标对象对应代理对象。
	3. jdk动态代理：被代理⽬标对象必须实现某⼀或某⼀组接⼝ 实现⽅式 通过回调创建代理对象。
	4. cglib 动态代理：被代理⽬标对象可以不必实现接⼝，继承的⽅式实现。
	5. 动态代理相⽐较静态代理，提⾼开发效率，可以批量化创建代理，提⾼代码复⽤率。

7.3. Aop 理解
	1. ⾯向切⾯，相⽐oop 关注的是代码中的层 或⾯
	2. 解耦，提⾼系统扩展性
	3. 提⾼代码复⽤

7.4. Aop 关键词
	1. 连接点：每⼀个⽅法
	2. 切⼊点：匹配的⽅法集合
	3. 切⾯：连接点与切⼊点的集合决定了切⾯，横切关注点的抽象
	4. 通知：⼏种通知
	5. ⽬标对象：被代理对象
	6. 织⼊：程序运⾏期将切⾯应⽤到⽬标对象 并⽣成代理对象的过程
	7. 引⼊：在不修改原始代码情况下，在程序运⾏期为程序动态引⼊⽅法或字段的过程