Spring中AOP实现（AOP的细致解析）

小刘师

已于 2024-04-23 15:19:57 修改

阅读量1k

点赞数 24

文章标签： xml java 开发语言 spring

于 2024-04-23 13:45:42 首次发布

本文链接：https://blog.csdn.net/qq_74329022/article/details/138068952

版权

概念：

基于XML的AOP实现是一种利用XML文件来配置和管理面向切面编程（AOP）的技术。在这种实现方式中，开发人员可以通过编写XML文件来定义切面、通知和切点，以及它们之间的关系和执行顺序。这种方式使得AOP的配置更加灵活和可维护，同时也能够方便地对系统进行扩展和修改。

AOP:

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它旨在通过将横切关注点（cross-cutting concerns）从应用程序的主要业务逻辑中分离出来，以提高代码的模块化性和可重用性。横切关注点是那些会影响多个模块的功能，比如日志记录、事务管理、安全性等。

在AOP中，切面（aspect）是用来封装横切关注点的模块化单元，它定义了在何处以及如何应用横切关注点。通知（advice）是切面中定义的具体行为，比如在目标方法执行前、执行后或抛出异常时执行的操作。切点（pointcut）是一种表达式，用来指定在何处应用通知。

通过使用AOP，开发人员可以将横切关注点从业务逻辑中分离出来，提高代码的可维护性和可重用性，同时也能够降低代码的重复性和耦合度

切面（aspect）

定义： 切面是用来封装横切关注点的模块化单元，它定义了在何处以及如何应用横切关注点。
组成： 切面由以下部分组成：
- 切点表达式（pointcut expression）： 指定在何处应用通知的表达式。
- 通知类型（advice type）： 定义在切点处应用的特定行为，例如，在方法执行前、执行后或抛出异常时执行的操作。
- 通知方法（advice method）： 实际执行通知行为的方法。
作用： 切面将横切关注点从核心业务逻辑中分离出来，使其更易于维护和测试。

通知（advice）

定义： 通知是在切点处应用的特定行为，它定义了在切点处执行的操作。
类型： 通知有以下几种类型：
- 前置通知（before advice）：在目标方法执行之前执行。
- 后置通知（after advice）：在目标方法执行之后执行，无论方法是否抛出异常。
- 返回通知（returning advice）：在目标方法成功返回之后执行。
- 异常通知（throwing advice）：在目标方法抛出异常之后执行。
- 环绕通知（around advice）：环绕目标方法执行，可以在方法执行前后执行操作。
作用： 通知可以用来实现各种功能，例如，日志记录、性能监控、事务管理、安全检查等。

切点（pointcut）

定义： 切点是一种表达式，用来指定在何处应用通知。
组成： 切点表达式通常由以下部分组成：
- 方法名：指定要拦截的方法。
- 类名：指定要拦截的类。
- 包名：指定要拦截的包。
- 其他修饰符：例如，可以指定方法的访问修饰符、参数类型等。
作用： 切点表达式可以非常精确地指定要应用通知的位置，从而避免对不需要拦截的方法进行拦截。

方法实现（idea下）：

这里我们对一个业务类 ProductService实现日志LoggerAspect切面的载入，使其有指定的业务记录

1、JAR包

框架的使用，Jar包是非常重要的，所以必须要配置。不过我们之前已经将所有需要的包都导入进来了。需要用到切面,在IDEAL下，需要加载和切面有关的jar。

<dependency>
 <groupId>org.aspectj</groupId>//依赖项目
 <artifactId>aspectjrt</artifactId>
 <version>1.9.1</version>
</dependency>
<dependency>
 <groupId>org.aspectj</groupId>
 <artifactId>aspectjweaver</artifactId>
 <version>1.9.7</version>
</dependency

2、准备业务类

创建ProductService（包com.j2ee.service）类，定义方法需要完成什么工作（如注册，登录，数据的增删改查的等）

package com.j2ee.service;
public class ProductService {
 /*
 * 定义一个核心业务
 */
 public void login(){
 System.out.println("用户登录");
 }
}

3、修改ApplicationContext.xml配置文件

<?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"
 xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="
 http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/aop
 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
 http://www.springframework.org/schema/tx
 http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
 http://www.springframework.org/schema/context 
 http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
<!--这里是依赖对象的注入-->
 <bean name="s" class="com.j2ee.service.ProductService">
 </bean>

</beans>

4、添加测试文件

Test.java 测试是否正常，切面并没有添加。文件创建完成后，就可以测试。

package com.j2ee.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.j2ee.service.ProductService;
public class Test {
 public static void main(String[] args) {
 ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"ApplicationContext.xml"});
 ProductService pt = (ProductService)context.getBean("s");
 pt.login();
 }
}

在main方法中，首先创建了一个ApplicationContext对象，该对象通过ClassPathXmlApplicationContext类加载了一个名为ApplicationContext.xml的配置文件。然后通过ApplicationContext对象获取了一个名为"s"的bean对象，并将其转换为ProductService类型的对象pt。最后调用了pt对象的login方法。

若测试正常则显示：用户登录

5、准备日志切面

该日志切面的功能是在调用核心功能之前和之后分别打印日志，切面就是原理图中讲的那些辅助功能。

创建包(com.j2ee.aspect),并在其下创建日志切面类(LoggerAspect),内容：

package com.j2ee.aspect;
import org.aspectj.lang.ProceedingJoinPoint;
public class LoggerAspect {
 public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
 System.out.println("start log:" + joinPoint.getSignature().getName());
 Object object = joinPoint.proceed();
 System.out.println("end log:" + joinPoint.getSignature().getName());
 return object;
 }
}

6、修改ApplicationContext.xml配置文件，添加相关日志切面类

ideal下的配置文件如下,(就是约束有些变化)：

<?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"
 xmlns:context="http://www.springframework.org/schema/context"
 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 http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
 <context:annotation-config></context:annotation-config>

 <bean name="s" class="com.j2ee.service.ProductService"></bean>

 <bean id="loggerAspect" class="com.j2ee.aspect.LoggerAspect"/>
 <aop:config>
 <aop:pointcut id="loggerCutpoint"
 expression=
 "execution(* com.j2ee.service.ProductService.*(..)) "/>
 <aop:aspect id="logAspect" ref="loggerAspect">
 <aop:around pointcut-ref="loggerCutpoint" method="log"/>
 </aop:aspect>
 </aop:config>

</beans>

解释：

这段XML配置文件主要包含以下几个部分：

命名空间声明和schema位置指定：

xmlns 属性定义了默认命名空间为Spring Beans命名空间。
xmlns:xsi 属性定义了XML Schema实例命名空间。
xsi:schemaLocation 属性指定了各个命名空间对应的schema文件位置，以便Spring框架能够正确解析和验证XML配置文件。

<context:annotation-config>：

用来启用注解驱动的Spring容器，使得Spring可以识别和处理注解。

<bean>：

定义了一个名为 s 的bean，它是一个 com.j2ee.service.ProductService 类的实例。

AOP配置：

<bean id="loggerAspect" class="com.j2ee.aspect.LoggerAspect"/>：

定义了一个名为 loggerAspect 的bean，它是一个com.j2ee.aspect.LoggerAspect类的实例。这个bean表示一个切面，用于定义横切关注点（cross-cutting concerns），在这里是记录日志

<aop:config>：

<aop:config> 标签用于配置AOP，包含了切点和切面的定义。

<aop:pointcut id="loggerCutpoint" expression="execution(* com.j2ee.service.ProductService.*(..))"/>：

<aop:pointcut> 标签定义了一个切入点，即 loggerCutpoint，它的表达式指定了切入 com.j2ee.service.ProductService 类中的所有方法（使用通配符 * 表示匹配所有方法）。

<aop:aspect id="logAspect" ref="loggerAspect">：

<aop:aspect> 标签定义了一个切面，即 logAspect，它引用了前面定义的 loggerAspect 切面。
ref="loggerAspect" 表示引用了名为 loggerAspect 的bean，即 com.j2ee.aspect.LoggerAspect 类的实例。

<aop:around pointcut-ref="loggerCutpoint" method="log"/>：

<aop:around> 标签定义了一个环绕通知，表示在切入点 loggerCutpoint 处执行 log 方法。
pointcut-ref="loggerCutpoint" 指定了在 loggerCutpoint 切点处执行环绕通知。
method="log" 指定了执行的方法为 log，即在切入点处执行 LoggerAspect 类中的 log 方法。

总的来说，这段配置文件主要用于配置Spring容器中的bean和AOP相关内容，实现了依赖注入和面向切面编程的功能。通过这样的配置，可以实现对 ProductService 类的日志记录功能的增强。

7、测试(Test.java文件不需要修改)

运行结果如下图所示：

当然这里只是简单设置了一个通知方法:环绕通知，相应的我们也可以按照格式进行对前置通知、后置通知、通知的实现---------下面具体由注解的方法简单解释

基于注解的AOP实现：

基于XML的AOP实现需要在Spring文件中配置大量的代码信息，不利于代码的阅读和维护，为了解决此问题，本实例将使用基于注解的方式实现AOP。

1.创建接口和具体类（User1类实现UserDao接口）,在com.j2ee.service包中创建UserDao和User1类。

package com.j2ee.service;
public interface UserDao {
public void insert();
public void select();
}

package com.j2ee.service;
public class User1 implements UserDao {
@Override
public void insert() {
// TODO Auto-generated method stub
System.out.println("实现添加数据...");
}
@Override
public void select() {
// TODO Auto-generated method stub
System.out.println("实现查询数据...");
}
}

2.创建切面类(或者叫通知类)(在com.j2ee.aspect包)中，创建切面类AnnoAdvice。

这里的注解方式相较于xml形式的aop更好理解就不多做解释

package com.j2ee.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class AnnoAdvice {
//切点
@Pointcut("execution( * com.j2ee.service.User1.*(..))")
public void pointcut(){}
//前置切点
@Before("pointcut()")
public void before(JoinPoint joinPoint){
System.out.println("这是前置通知!");
System.out.println("目标类是:"+ joinPoint.getTarget());
System.out.println("被植入的目标方法是:"+ joinPoint.getSignature().getName());
}
//返回通知
@AfterReturning("pointcut()")
public void afterReturning(JoinPoint joinPoint){
System.out.println("这是返回通知!");
System.out.println("被植入的目标方法是:"+ joinPoint.getSignature().getName());
}
//环绕通知
@Around("pointcut()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
System.out.println("这是环绕通知之前的部分!");
Object object = joinPoint.proceed();
System.out.println("这是环绕通知之后的部分!");
return object;
}
//后置通知
@After("pointcut()")
public void after(){
System.out.println("这是后置通知!");
}
}

3.修改配置文件applicationContext.xml，引入切面类。

这里开启了自动代理，即自动识别并将通知运用到业务中

<?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 name="userA" class="com.j2ee.service.User1"></bean>
<bean name="AnnoAspect" class="com.j2ee.aspect.AnnoAspect"></bean>
<!-- 开启@aspectj的自动代理支持 -->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

4.创建测试类(在com.j2ee.test包中)，创建测试文件Test1.java,内容:

package com.j2ee.test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.j2ee.service.User1;
import com.j2ee.service.UserDao;
public class Test1 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ApplicationContext context = new ClassPathXmlApplicationContext(new String[]
{"applicationContext.xml"});
UserDao user = (UserDao)context.getBean("userA");
user.insert();
System.out.println();
user.select();
}
}

结果显示：

小刘师

关注

24
点赞
踩
20

收藏

觉得还不错? 一键收藏
4
评论
Spring中AOP实现（AOP的细致解析）

AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，它旨在通过将横切关注点（cross-cutting concerns）从应用程序的主要业务逻辑中分离出来，以提高代码的模块化性和可重用性。基于XML的AOP实现需要在Spring文件中配置大量的代码信息，不利于代码的阅读和维护，为了解决此问题，本实例将使用基于注解的方式实现AOP。创建ProductService（包com.j2ee.service）类，定义方法需要完成什么工作（如注册，登录，数据的增删改查的等）
复制链接

扫一扫