Spring AOP

最新推荐文章于 2023-10-05 16:24:25 发布

小李爱睡觉.

最新推荐文章于 2023-10-05 16:24:25 发布

阅读量132

点赞数 1

分类专栏： SSM框架文章标签： spring

本文链接：https://blog.csdn.net/Lixintong0708/article/details/108959159

版权

SSM框架专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、OOP和AOP

OOP是一种面向对象的程序设计。“对象”在显式支持面向对象的语言中，一般指类在内存中装载的实例，具有相关的成员变量和成员函数（也称为方法）。我们通过抽象的方式把对象的共同特性总结出来构造类（共同模型），主要关系对象包含哪些属性及行为，但是不关心具体的细节，从而达到软件工程的要求：重用性、灵活性和扩展性。

AOP（面向切面编程）可以说是OOP的补充和完善。OOP通过引用封装、继承和多态性等概念来建立一种对象的层次结构，用于模拟公共行为的一种集合，但在需要为分散的对象引入公共行为时就显得无能为力了。例如日志功能，因为日志代码往往水平地分布在所有对象的层次中，却与它所在对象的核心功能毫无关系；以及其他类型如安全性、异常处理等非业务代码。也就是说，OOP允许我们定义从上到下的关系，但并不适合定义从左到右的关系。这种散布在各处的毫无关系的代码被称为横切代码。在OOP的设计中有大量的重复代码，不利于各个模块的重用。

二、AOP的适用场景

（1）组件代码与业务代码解耦。例如日志功能、事务功能、异常处理、统一拦截、数据提取等。很多开源组件都是利用AOP的面向切面编程特性实现零侵入的。

（2）代码高度复用、功能可配置。在部分逻辑相同但需要覆盖的业务场景比较丰富时，可以先通过定义切面实现通用逻辑，然后把需要实现实现这部分通过逻辑的业务代码配置在切面范围内。同时代码可高度复用，当通用逻辑发生变更甚至删除或按配置切换部分过度代码时，可以进行统一处理，避免漏改、漏配等。

三、AOP术语

（1）连接点（Joinpoint）

程序执行的某个特定位置：如类开始初始化前、类初始化后、类某个方法调用前、调用后、方法抛出异常后。一个类或一段程序代码拥有一些具有边界性质的特定点，这些点中的特定点就称为“连接点”。Spring仅支持方法的连接点，即仅能在方法调用前、方法调用后、方法抛出异常时以及方法调用前后这些程序执行点织入增强。连接点由两个信息确定：第一是用方法表示的程序执行点；第二是用相对点表示的方位。

（2）切点（Pointcut）

每个程序类都拥有多个连接点，如一个拥有两个方法的类，这两个方法都是连接点，即连接点是程序类中客观存在的事物。AOP通过“切点”定位特定的连接点。连接点相当于数据库中的记录，而切点相当于查询条件。切点和连接点不是一对一的关系，一个切点可以匹配多个连接点。在Spring中，切点通过org.springframework.aop.Pointcut接口进行描述，它使用类和方法作为连接点的查询条件，Spring AOP的规则解析引擎负责切点所设定的查询条件，找到对应的连接点。其实确切地说，不能称之为查询连接点，因为连接点是方法执行前、执行后等包括方位信息的具体程序执行点，而切点只定位到某个方法上，所以如果希望定位到具体连接点上，还需要提供方位信息。

（3）通知/增强（Advice）

增强是织入到目标类连接点上的一段程序代码，在Spring中，增强除用于描述一段程序代码外，还拥有另一个和连接点相关的信息，这便是执行点的方位。结合执行点方位信息和切点信息，我们就可以找到特定的连接点。

（4）目标对象（Target）

增强逻辑的织入目标类。如果没有AOP，目标业务类需要自己实现所有逻辑，而在AOP的帮助下，目标业务类只实现那些非横切逻辑的程序逻辑，而性能监视和事务管理等这些横切逻辑则可以使用AOP动态织入到特定的连接点上。

（5）引介（Introduction）

引介是一种特殊的增强，它为类添加一些属性和方法。这样，即使一个业务类原本没有实现某个接口，通过AOP的引介功能，我们可以动态地为该业务类添加接口的实现逻辑，让业务类成为这个接口的实现类。

（6）织入（Weaving）

织入是将增强添加对目标类具体连接点上的过程。AOP像一台织布机，将目标类、增强或引介通过AOP这台织布机天衣无缝地编织到一起。根据不同的实现技术，AOP有三种织入的方式：

a、编译期织入，这要求使用特殊的Java编译器。

b、类装载期织入，这要求使用特殊的类装载器。

c、动态代理织入，在运行期为目标类添加增强生成子类的方式。

Spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。

（7）代理（Proxy）

一个类被AOP织入增强后，就产出了一个结果类，它是融合了原类和增强逻辑的代理类。根据不同的代理方式，代理类既可能是和原类具有相同接口的类，也可能就是原类的子类，所以我们可以采用调用原类相同的方式调用代理类。

（8）切面（Aspect）

切面由切点和增强（引介）组成，它既包括了横切逻辑的定义，也包括了连接点的定义，Spring AOP就是负责实施切面的框架，它将切面所定义的横切逻辑织入到切面所指定的连接点中。

四、使用Spring AOP功能

 /**  *	
 		用户业务类  
 */
 	 public class UserService { 	
 		public void add() {
       	System.out.println("user添加方法"); 
       	} 	 
      }

 /*** 
	用户切面类
 */
	public class UserAspect {
 
		public void log() {
			System.out.println("打印用户操作日志");
		}
	}

applicationContext.xml配置

需要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-4.3.xsd
	default-autowire="byName" default-lazy-init="true">
	
	
<!-- 	注入用户业务类 -->
	<bean id="userService" class="com.buba.service.UserService"></bean>
<!-- 	注入切面 -->
	<bean id="userAspect" class="com.buba.aspect.UserAspect"></bean>
	
	<aop:config>
        <!-- 切入点表达式
        execution	选择方法
        (* com.buba.service.*.*(..))
        * 返回值任意
        com.buba.service 包路径
        .* 类名任意
        .* 方法名任意
        (..) 参数任意
         -->
        <aop:pointcut expression="execution(* com.buba.service.*.*(..))" id="myPointCut"/>
<!--         ref 指定切面  -->
        <aop:aspect ref="userAspect">
            <!-- 配置前置通知，注意 method 的值要和 对应切面的类方法名称相同 -->
            <aop:before method="log" pointcut-ref="myPointCut"></aop:before>
        </aop:aspect>
    </aop:config>
 
</beans>

测试

public class AopTest {
	
	@Test
	public void aopTest() {
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserService bean = context.getBean("userService",UserService.class);
		bean.add();
	}
}

在这里插入图片描述
springAOP 的具体加载步骤：

1、当 spring 容器启动的时候，加载了 spring 的配置文件

2、为配置文件中的所有 bean 创建对象

3、spring 容器会解析 aop:config 的配置

解析切入点表达式，用切入点表达式和纳入 spring 容器中的 bean 做匹配

   　　　　如果匹配成功，则会为该 bean 创建代理对象，代理对象的方法=目标方法+通知

   　　　　如果匹配不成功，不会创建代理对象

4、在客户端利用 context.getBean() 获取对象时，如果该对象有代理对象，则返回代理对象；如果没有，则返回目标对象

说明：如果目标类没有实现接口，则 spring 容器会采用 cglib 的方式产生代理对象，如果实现了接口，则会采用 jdk 的方式

五、通知/增强（Advice）

（1）通知类型

Spring按照通知Advice在目标类方法的连接点位置，可以分为5类：

1.前置通知 org.springframework.aop.MethodBeforeAdvice

        在目标方法执行前实施增强，比如上面例子的 before()方法

2.后置通知 org.springframework.aop.AfterReturningAdvice

           在目标方法执行后实施增强，比如上面例子的 after()方法

3.环绕通知 org.aopalliance.intercept.MethodInterceptor

           在目标方法执行前后实施增强

4.异常抛出通知 org.springframework.aop.ThrowsAdvice

           在方法抛出异常后实施增强

5.引介通知 org.springframework.aop.IntroductionInterceptor

在目标类中添加一些新的方法和属性

（2）注解配置AOP
`

<!-- spring注解扫描 -->
	<context:component-scan
		base-package="com.buba.*" />
<!-- 	aop注解支持 -->
	<aop:aspectj-autoproxy/>

@Service
	public class UserService 
 
@Component
@Aspect // 用于定义AOP切面
	public class UserAspect

@Service、@Component相当于

<bean id="userService" class="com.buba.service.UserService"></bean>
<bean id="userAspect" class="com.buba.aspect.UserAspect"></bean>

@Aspect 相当于

<aop:config>
    <aop:aspect ref="userAspect">

@Before 配置前置通知

@Before("execution(* com.buba.service.*.*(..))")
	public void log(JoinPoint joinPoint) {
		System.out.println("打印用户操作日志");
	}

JoinPoint对象封装了SpringAop中切面方法的信息,在切面方法中添加JoinPoint参数,就可以获取到封装了该方法信息的JoinPoint对象。

方法名	功能
Signature getSignature();	获取封装了署名信息的对象,在该对象中可以获取到目标方法
Object[] getArgs();	获取传入目标方法的参数对象
Object getTarget();	获取被代理的对象
Object getThis();	获取被代理的对象

@AfterReturning 后置通知（方法没有抛出异常时执行）

	public void log(JoinPoint joinPoint,Object ret) {
		System.out.println("打印用户操作日志");
	}

后置通知有个 returning=“ret” 配置，这是用来获得目标方法的返回值的。方法参数需要和returning属性值相同。

@AfterThrowing 抛出异常执行

@After 最终（方法不管有没有抛出异常都会最终执行）

@Around 环绕

@Around(value = "execution(* com.buba.service.*.*(..))")
	public Object log(ProceedingJoinPoint pjd) throws Throwable {
		System.out.println("打印用户操作日志");
		// 执行目标方法
		// Object result = pjd.proeed();
		// 用新的参数值执行目标方法
		Object result = pjd.proceed(new Object[] { "newSpring", "newAop" });
 
		return result;
	}

ProceedingJoinPoint对象是JoinPoint的子接口,该对象只用在@Around的切面方法中, 添加了
Object proceed() throws Throwable //执行目标方法
Object proceed(Object[] var1) throws Throwable //传入的新的参数去执行目标方法
两个方法，而且环绕通知必须有返回值，返回值即为目标方法的返回值

@PointCut ，修饰方法 public void xxx(){} 之后通过“方法名”获得切入点引用


@Pointcut("execution(* com.buba.service.*.*(..))")
	public void myPointCut() {}
	
	@Before(value = "myPointCut()")
	public void log2(){
		System.out.println("测试打印用户操作日志2");
 
	}
	
	@Around(value = "myPointCut()")
	public Object log(ProceedingJoinPoint pjd) throws Throwable {
		System.out.println("打印用户操作日志");
		// 执行目标方法
		// Object result = pjd.proeed();
		// 用新的参数值执行目标方法
		Object result = pjd.proceed(new Object[] { "newSpring", "newAop" });
 
		return result;
	}