【Spring Framework】Spring AOP 面相切面编程

最新推荐文章于 2024-09-03 16:35:17 发布

cangloe

最新推荐文章于 2024-09-03 16:35:17 发布

阅读量881

点赞数 10

分类专栏： java 文章标签： spring java jvm

本文链接：https://blog.csdn.net/u013675821/article/details/140723102

版权

java 专栏收录该内容

36 篇文章 0 订阅

订阅专栏

Spring AOP（Aspect-Oriented Programming，面向切面编程）是 Spring 框架的重要组成部分之一，它通过在不修改业务逻辑代码的情况下提供横切关注点的处理能力，使得代码更加简洁、模块化和易于维护。AOP 可以用来处理常见的功能，如日志记录、事务管理、权限控制等。

一、Spring AOP 的基本概念

在 Spring AOP 中，以下是一些关键概念：

切面（Aspect）：模块化的横切关注点，例如日志记录、事务管理等。切面可以用类来实现，并使用 @Aspect 注解标记。
通知（Advice）：切面在特定连接点执行的动作（方法）。Spring AOP 支持以下几种类型的通知：
- 前置通知（Before Advice）：在目标方法执行之前执行。
- 后置通知（After Advice）：在目标方法执行之后执行。
- 返回通知（After Returning Advice）：在目标方法正常返回后执行。
- 异常通知（After Throwing Advice）：在目标方法抛出异常时执行。
- 环绕通知（Around Advice）：在目标方法执行之前和之后都执行，可以控制方法的执行。
连接点（Joinpoint）：程序执行的某个特定点，如方法调用或异常抛出。Spring AOP 只支持方法连接点。
切点（Pointcut）：一组连接点的集合，通过表达式来定义这些连接点。切点定义了通知应该在何时何地执行。
目标对象（Target Object）：被通知的对象，也就是实际的业务逻辑类。
代理（Proxy）：AOP 框架创建的对象，包含目标对象的功能和增强的功能。Spring AOP 使用 JDK 动态代理或 CGLIB 代理来实现。
织入（Weaving）：将切面与目标对象连接的过程。Spring AOP 是在运行时织入的。

Spring AOP 的优点

解耦业务逻辑和横切关注点：通过 AOP，将日志、事务等横切关注点从业务逻辑中分离出来，提高代码的可读性和可维护性。
提高代码复用性：将通用的逻辑提取到切面中，避免在多个地方重复相同的代码。
降低代码耦合度：业务逻辑和切面是相互独立的，修改切面不会影响业务逻辑。

二、Spring AOP 注解

Spring AOP 提供了一组注解用于定义切面、切点和通知：

@Aspect：用于定义一个类为切面类。
@Before：用于定义前置通知。
@After：用于定义后置通知。
@AfterReturning：用于定义返回通知。
@AfterThrowing：用于定义异常通知。
@Around：用于定义环绕通知。
@Pointcut：用于定义切点表达式。

切点表达式的语法

切点表达式用于匹配连接点，以下是常用的切点表达式语法：

execution(* com.example.service.*.*(..))：匹配 com.example.service 包下的所有方法。
within(com.example.service..*)：匹配 com.example.service 包及其子包下的所有方法。
@annotation(org.springframework.transaction.annotation.Transactional)：匹配所有被 @Transactional 注解的方法。
this(com.example.service.UserService)：匹配当前代理对象是 UserService 的所有方法。
target(com.example.service.UserService)：匹配目标对象是 UserService 的所有方法。

三、Spring AOP 的使用

下面是一个使用 Spring AOP 注解的完整示例。

3.1 项目结构

src
 └── main
     ├── java
     │   └── com
     │       └── example
     │           ├── aspect
     │           │   └── LoggingAspect.java
     │           ├── service
     │           │   ├── UserService.java
     │           │   └── UserServiceImpl.java
     │           └── MainApp.java
     └── resources
         └── applicationContext.xml

3.2 添加依赖

在 pom.xml 中添加 Spring AOP 依赖：

<dependencies>
    <!-- Spring Core -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.9</version>
    </dependency>
    
    <!-- Spring AOP -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.3.9</version>
    </dependency>
    
    <!-- AspectJ -->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.6</version>
    </dependency>
    
    <!-- Spring Context -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.9</version>
    </dependency>
    
    <!-- Spring Context Support -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>5.3.9</version>
    </dependency>
    
    <!-- Log4j for logging -->
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-core</artifactId>
        <version>2.17.1</version>
    </dependency>
    <dependency>
        <groupId>org.apache.logging.log4j</groupId>
        <artifactId>log4j-api</artifactId>
        <version>2.17.1</version>
    </dependency>
</dependencies>

3.3 定义业务逻辑类

UserService 接口

定义一个简单的用户服务接口 UserService：

package com.example.service;

public interface UserService {
    void addUser(String name);
    void deleteUser(String name);
    String findUser(String name);
}

UserServiceImpl 实现类

实现接口的具体类 UserServiceImpl：

package com.example.service;

import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String name) {
        System.out.println("Adding user: " + name);
    }

    @Override
    public void deleteUser(String name) {
        System.out.println("Deleting user: " + name);
    }

    @Override
    public String findUser(String name) {
        return "User found: " + name;
    }
}

3.4 定义切面类

LoggingAspect 切面

定义一个切面类 LoggingAspect，用于在方法执行之前和之后记录日志：

package com.example.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    // 定义切点，匹配com.example.service包及其子包下的所有方法
    @Pointcut("execution(* com.example.service..*(..))")
    public void serviceLayer() {}

    // 前置通知，在目标方法执行之前执行
    @Before("serviceLayer()")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().toShortString());
    }

    // 后置通知，在目标方法执行之后执行
    @After("serviceLayer()")
    public void afterAdvice(JoinPoint joinPoint) {
        System.out.println("After method: " + joinPoint.getSignature().toShortString());
    }

    // 返回通知，在目标方法正常返回后执行
    @AfterReturning(pointcut = "serviceLayer()", returning = "result")
    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
        System.out.println("After returning method: " + joinPoint.getSignature().toShortString() + " with result: " + result);
    }

    // 异常通知，在目标方法抛出异常时执行
    @AfterThrowing(pointcut = "serviceLayer()", throwing = "exception")
    public void afterThrowingAdvice(JoinPoint joinPoint, Throwable exception) {
        System.out.println("After throwing method: " + joinPoint.getSignature().toShortString() + " with exception: " + exception);
    }

    // 环绕通知，在目标方法执行之前和之后执行
    @Around("serviceLayer()")
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("Around before method: " + proceedingJoinPoint.getSignature().toShortString());
        Object result = proceedingJoinPoint.proceed();  // 调用目标方法
        System.out

.println("Around after method: " + proceedingJoinPoint.getSignature().toShortString());
        return result;
    }
}

3.5 Spring 配置

Java 配置类

使用 Java 配置类启用 AOP 功能：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackages = "com.example")
@EnableAspectJAutoProxy
public class AppConfig {
    // 可以选择在这里定义Bean
}

XML 配置

也可以通过 XML 配置启用 AOP 功能：

<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">

    <!-- 开启AOP支持 -->
    <aop:aspectj-autoproxy/>

    <!-- 扫描包，自动注册Bean -->
    <context:component-scan base-package="com.example"/>

    <!-- 注册切面Bean -->
    <bean id="loggingAspect" class="com.example.aspect.LoggingAspect"/>
</beans>

3.6 测试 AOP

MainApp 类

创建一个测试类 MainApp 来测试 AOP 功能：

package com.example;

import com.example.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean(UserService.class);

        userService.addUser("Alice");
        userService.deleteUser("Bob");
        System.out.println(userService.findUser("Charlie"));
    }
}

输出结果

Before method: UserService.addUser(..)
Adding user: Alice
After method: UserService.addUser(..)
Around before method: UserService.deleteUser(..)
Deleting user: Bob
Around after method: UserService.deleteUser(..)
Before method: UserService.findUser(..)
After returning method: UserService.findUser(..) with result: User found: Charlie
User found: Charlie

四、总结

通过上述示例，我们可以看到 Spring AOP 的强大之处：

灵活性：通过注解和切点表达式，我们可以灵活地定义切面的应用范围。
解耦性：将横切关注点从业务逻辑中分离出来，减少代码的耦合度。
可扩展性：切面可以轻松扩展和修改，不需要改变业务逻辑代码。
易用性：Spring AOP 的注解使得使用 AOP 变得简单直观。

在实际应用中，Spring AOP 常用于日志记录、事务管理、安全性、性能监控等领域，帮助开发者构建更加模块化、可维护的应用程序。

cangloe

关注

10
点赞
踩
28

收藏

觉得还不错? 一键收藏
0
评论
【Spring Framework】Spring AOP 面相切面编程

定义一个简单的用户服务接口定义一个切面类import org// 定义切点，匹配com.example.service包及其子包下的所有方法 @Pointcut("execution(* com.example.service..*(..))") public void serviceLayer() {
复制链接

扫一扫

专栏目录