Springboot - 6.AOP

yueerba126

已于 2023-09-03 18:02:18 修改

阅读量311

点赞数 1

于 2023-09-03 17:38:02 首次发布

本文链接：https://blog.csdn.net/yueerba126/article/details/132652590

版权

Spring Boot 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

👀概念

当谈论AOP（面向切面编程）时，我们在软件设计中引入了一种编程范式，用于解决关注点分离的问题。关注点分离是将一个应用程序的不同关注点（例如日志记录、事务管理、安全性等）从业务逻辑中分离出来，以便提高代码的模块化和可维护性。

✌`以下是AOP的主要概念和特性：`

✍1. 切面（Aspect）：

切面是一个包含横切关注点逻辑的模块。它定义了在何处（切点）以及何时（通知）执行关注点的逻辑。在实际场景中，我们可以创建一个日志记录切面来记录方法的调用和执行时间。

@Aspect
@Component
public class LoggingAspect {

    @Around("execution(* com.example.myapp.service.*.*(..))")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long endTime = System.currentTimeMillis();
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Method " + methodName + " executed in " + (endTime - startTime) + "ms");
        return result;
    }
}

在这个示例中，@Aspect注解标记了该类为切面，@Around通知定义了在哪个切点上执行日志记录逻辑。切点表达式execution(* com.example.myapp.service.*.*(..))匹配了com.example.myapp.service包下的所有方法。

✍2. 切点（Pointcut）：

切点定义了哪些方法将会被影响，即在哪些方法上应用切面的通知。在实际应用中，我们可以定义一个切点，用于匹配所有UserService类的方法。
在这个示例中，我们定义了三个不同的切点并应用了不同类型的通知。serviceMethods()切点匹配com.example.myapp.service包中的所有方法。afterRepositoryMethods()切点匹配com.example.myapp.repository包中的所有方法。loggableMethods()切点匹配带有@Loggable注解的方法。

@Aspect
@Component
public class LoggingAspect {

    @Pointcut("execution(* com.example.myapp.service.*.*(..))")
    public void serviceMethods() {}

    @Before("serviceMethods()")
    public void beforeAdvice() {
        System.out.println("Before method execution");
    }

    @After("execution(* com.example.myapp.repository.*.*(..))")
    public void afterRepositoryMethods() {
        System.out.println("After repository method execution");
    }

    @Around("@annotation(com.example.myapp.annotation.Loggable)")
    public Object loggableMethods(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Before method execution");
        Object result = joinPoint.proceed();
        System.out.println("After method execution");
        return result;
    }
}

在这个示例中，@Pointcut注解定义了一个切点，其切点表达式指定了匹配UserService类的所有方法。你可以在通知中引用这个切点来应用切面逻辑。

✍3. 通知（Advice）：

通知是切面在特定切点处执行的代码。在实际场景中，我们可以创建一个记录日志的切面，其中包括在目标方法执行前后记录日志的通知。

@Aspect
@Component
public class LoggingAspect {

    @Before("userServiceMethods()")
    public void beforeAdvice() {
        System.out.println("Before method execution");
    }

    @After("userServiceMethods()")
    public void afterAdvice() {
        System.out.println("After method execution");
    }
}

在这个示例中，@Before和@After注解定义了通知，它们分别在切点匹配的方法执行前和执行后执行。userServiceMethods()是之前定义的切点。

✍4. 引入（Introduction）：

引入是一种增强方式，允许在现有的类中添加新的方法和属性。在实际应用中，我们可以为现有的类引入一个新的接口，以添加新的功能，而无需修改现有代码。

@Aspect
@Component
public class IntroductionAspect {

    @DeclareParents(value = "com.example.myapp.service.*+", defaultImpl = AuditableServiceImpl.class)
    private AuditableService auditableService;
}

在这个示例中，我们通过@DeclareParents注解将AuditableService接口引入到com.example.myapp.service包下的所有类中。这使得这些类都具备了AuditableService接口的功能。

AOP的引入（Introduction）和依赖注入

依赖注入（Dependency Injection）：

依赖注入是一种设计模式，旨在通过将依赖关系从一个类转移到另一个类，以实现解耦和可测试性。
在依赖注入中，我们将某个类所需的依赖通过构造函数、方法参数或属性注入到该类中，而不是在类内部直接创建它们。
依赖注入的目的是将组件的依赖关系集中管理，以提高模块的灵活性和可替换性。

AOP的引入（Introduction）：

AOP的引入是一种通过在现有类中添加新接口、方法或属性的方式来增加类的功能，而无需修改现有代码。
引入功能使我们能够在不破坏现有类的情况下，向类中引入新的行为或功能。
AOP的引入与依赖注入的目的不同，主要是为了在不修改现有代码的情况下添加新的功能，从而实现关注点的分离。

尽管AOP的引入和依赖注入都涉及在类中添加新功能，但它们的重点和用途是不同的。依赖注入更关注解耦和和可测试性，而AOP的引入更关注在不破坏现有代码的情况下添加新功能。

✍5. 织入（Weaving）：

织入是将切面与应用程序代码结合的过程。在实际应用中，织入将切面的通知插入到切点处，从而实现关注点分离。

@Aspect
@Component
public class LoggingAspect {

    @Around("userServiceMethods()")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Before method execution");
        Object result = joinPoint.proceed();
        System.out.println("After method execution");
        return result;
    }
}

✍6. 连接点（Joinpoint）:

连接点是程序执行的某个位置，如方法的调用或异常的抛出。

示例：
```
@AfterReturning(pointcut = "serviceMethods()", returning = "result")
public void logAfterReturning(JoinPoint joinPoint, Object result) {
    // ...
}
```
在这个示例中，logAfterReturning方法的joinPoint参数是一个连接点。

在这个示例中，@Around注解定义了织入的通知。它在目标方法执行前后执行，并将日志记录的逻辑织入到目标方法中。

✍7. 目标对象（Target Object）:

目标对象是被一个或多个切面通知的对象。

示例：

@Service
public class ExampleService {

    public String doSomething(String name) {
        return "Hello, " + name;
    }

}

在这个示例中，ExampleService是一个目标对象，它被LoggingAspect切面通知。

✍8. AopProxyUtils:

AopProxyUtils类是Spring AOP框架的一个工具类，它提供了一些静态方法，用于处理代理对象和目标对象。

getSingletonTarget(Object candidate):
这个方法用于获取单例bean的目标对象。

示例：
```
ExampleService targetObject = (ExampleService) AopProxyUtils.getSingletonTarget(exampleService);
```
在这个示例中，exampleService是ExampleService的代理对象。我们使用AopProxyUtils.getSingletonTarget方法获取exampleService的目标对象。

注意：这个方法只适用于单例bean。如果bean的作用域不是单例，这个方法将返回null。
getTargetClass(Object candidate):
这个方法用于获取代理对象的目标类。

示例：
```
Class<?> targetClass = AopProxyUtils.getTargetClass(exampleService);
```
在这个示例中，exampleService是ExampleService的代理对象。我们使用AopProxyUtils.getTargetClass方法获取exampleService的目标类。

注意：这个方法返回的是目标类，而不是目标对象。
ultimateTargetClass(Object candidate):
这个方法用于获取代理对象的最终目标类。

示例：
```
Class<?> ultimateTargetClass = AopProxyUtils.ultimateTargetClass(exampleService);
```
在这个示例中，exampleService是ExampleService的代理对象。我们使用AopProxyUtils.ultimateTargetClass方法获取exampleService的最终目标类。

注意：这个方法返回的是最终目标类，而不是目标对象。如果代理对象有多层代理，这个方法将返回最终的目标类。

这些是AopProxyUtils类的一些常用方法。这个类还有一些其他方法，但它们通常不需要在应用程序代码中直接使用。

注意：通常我们不需要直接访问目标对象。代理对象会将调用转发到目标对象，并在调用之前或之后执行通知。所以，通常我们应该使用代理对象，而不是目标对象。直接访问目标对象会绕过代理，这意味着切面的通知将不会被执行。

这个类还包含一些其他的方法，但是它们主要用于内部使用，通常不需要在应用程序代码中直接使用。例如，AopProxyUtils.completeProxiedInterfaces方法用于确定给定的代理配置的完整代理接口集，包括从目标类继承的接口。这个方法通常用于在创建代理对象时确定代理接口。

✌`AOP在实际开发中的应用场景包括：`

日志记录：记录方法的调用、参数和返回值，以便进行调试和性能监控。
事务管理：在方法调用前后控制事务的开始和提交、回滚。
安全性：实现访问控制、认证和授权等安全相关的功能。
性能优化：在关键方法中添加性能监控和优化逻辑。
缓存管理：在方法中添加缓存逻辑，提高应用程序的响应速度。

当涉及到AOP的实际应用场景时，让我们从五个不同的方面来示例化讲解：

✍1. 日志记录：

示例：在一个Web应用中，记录每个请求的处理时间和请求参数。

@Aspect
@Component
public class LoggingAspect {

    @Around("execution(* com.example.myapp.controller.*.*(..))")
    public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long endTime = System.currentTimeMillis();
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Method " + methodName + " executed in " + (endTime - startTime) + "ms");
        return result;
    }
}

✍2. 事务管理：

示例：确保在调用服务方法时，事务在适当的时候启动、提交或回滚。

@Aspect
@Component
public class TransactionAspect {

    @Around("@annotation(org.springframework.transaction.annotation.Transactional)")
    public Object manageTransaction(ProceedingJoinPoint joinPoint) throws Throwable {
        TransactionStatus transactionStatus = transactionManager.getTransaction(new DefaultTransactionDefinition());
        try {
            Object result = joinPoint.proceed();
            transactionManager.commit(transactionStatus);
            return result;
        } catch (Exception ex) {
            transactionManager.rollback(transactionStatus);
            throw ex;
        }
    }
}

✍3. 安全性：

示例：在敏感操作前，检查用户是否有足够的权限执行操作。

@Aspect
@Component
public class SecurityAspect {

    @Before("@annotation(com.example.myapp.annotation.RequiresAdminRole)")
    public void checkAdminRole() {
        if (!currentUserHasAdminRole()) {
            throw new SecurityException("Admin role required");
        }
    }
}

✍4. 性能优化：

示例：在关键方法中添加性能监控和优化逻辑，如数据库查询。

@Aspect
@Component
public class PerformanceAspect {

    @Around("execution(* com.example.myapp.repository.*.*(..))")
    public Object measureQueryPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long endTime = System.currentTimeMillis();
        if (endTime - startTime > 1000) {
            System.out.println("Query execution took more than 1 second");
        }
        return result;
    }
}

✍5. 缓存管理：

示例：在方法中添加缓存逻辑，提高应用程序的响应速度。

@Aspect
@Component
public class CachingAspect {

    private Map<String, Object> cache = new HashMap<>();

    @Around("execution(* com.example.myapp.service.*.*(..))")
    public Object applyCaching(ProceedingJoinPoint joinPoint) throws Throwable {
        String methodName = joinPoint.getSignature().getName();
        if (cache.containsKey(methodName)) {
            return cache.get(methodName);
        } else {
            Object result = joinPoint.proceed();
            cache.put(methodName, result);
            return result;
        }
    }
}

👀导入依赖

在Spring Boot应用中使用AOP，你需要导入以下核心依赖以支持AOP功能：

spring-boot-starter-aop： 这个starter提供了Spring AOP的支持，使你可以在应用程序中使用AOP功能。

在Maven项目中，你可以将这些依赖添加到pom.xml文件中：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
</dependencies>

👀启用AOP

当涉及到在Spring Boot应用程序中启用AOP时，你可以将@EnableAspectJAutoProxy注解放置在两个位置：配置类上或入口函数所在的主类上。以下是这两种方式的合并输出：

✌方式1：将`@EnableAspectJAutoProxy`注解放置在配置类上：

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

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
    // 配置类的其他内容
}

✌方式2：将`@EnableAspectJAutoProxy`注解放置在入口函数所在的主类上：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@SpringBootApplication
@EnableAspectJAutoProxy
public class MyAppApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyAppApplication.class, args);
    }
}

无论你选择哪种方式，它们都会启用AspectJ自动代理，使AOP切面能够正常应用于Spring Boot应用程序中的Bean。根据你的偏好和项目结构，选择合适的位置来放置@EnableAspectJAutoProxy注解。

👀切点表达式

切点表达式（Pointcut Expression）是AOP中一个重要的概念，用于指定在哪些方法上应用通知。切点表达式使用AspectJ的语法，它允许你定义一组匹配方法的规则。这些规则可以基于方法的名称、参数、返回类型等来进行匹配。以下是切点表达式的详细说明和示例：

✌切点表达式的语法：

切点表达式的基本语法是使用关键字execution，后面跟着方法的返回类型、类名、方法名和参数列表。通配符可以用来匹配不同的部分。

execution([可见性] 返回类型 [类全名.]方法名(参数列表) [异常模式])

其中，方括号内的部分是可选的，具体的匹配规则如下：

可见性：方法的可见性，如public、private等。
返回类型：方法的返回类型，使用*通配符表示任意类型。
类全名：类的全名，使用*通配符表示任意包名，省略则表示当前包下的所有类。
方法名：方法的名称，使用*通配符表示任意方法名。
参数列表：方法的参数列表，使用..表示任意数量和类型的参数。
异常模式：方法可能抛出的异常。

✌切点表达式示例：

假设我们有以下服务类：

package com.example.myapp.service;

@Service
public class UserService {

    public void createUser(String username) {
        System.out.println("User created: " + username);
    }

    public void deleteUser(String username) {
        System.out.println("User deleted: " + username);
    }
}

我们来定义一些切点表达式示例：

✍1. 匹配所有`UserService`类的方法：

@Pointcut("execution(* com.example.myapp.service.UserService.*(..))")
public void userServiceMethods() {}

✍2. 匹配所有公共方法：

@Pointcut("execution(public * *(..))")
public void publicMethods() {}

✍3. 匹配任何以`create`开头的方法：

@Pointcut("execution(* create*(..))")
public void createMethods() {}

✍4. 匹配任何返回类型是`void`的方法：

@Pointcut("execution(void *(..))")
public void voidReturnMethods() {}

✍5. 匹配参数列表包含一个`String`类型参数的方法：

@Pointcut("execution(* *(String))")
public void stringParameterMethods() {}

✍6. 匹配参数列表包含两个参数的方法，第一个参数是`int`类型，第二个参数是任意类型：

@Pointcut("execution(* *(int, ..))")
public void intAndAnyParameterMethods() {}

👀切面注解

✌1. @Aspect：

标记一个类为切面类，其中包含切点和通知。
在类级别上使用。
表示这个类将包含切点和通知。

示例：定义一个用于日志记录的切面类。

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

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.myapp.service.*.*(..))")
    public void beforeAdvice() {
        System.out.println("Before method execution");
    }

    @After("execution(* com.example.myapp.service.*.*(..))")
    public void afterAdvice() {
        System.out.println("After method execution");
    }
}

✌2. @Pointcut：

定义切点，可以在通知中引用。
在切面类中定义一个无返回值的方法，并使用@Pointcut注解。
切点表达式被写入@Pointcut注解的方法体中。

示例：定义一个切点来匹配服务类中的所有方法。

@Pointcut("execution(* com.example.myapp.service.*.*(..))")
public void serviceMethods() {}

✌3. @Before：

在目标方法执行之前执行通知。
通知方法会在切点方法之前被调用。

示例：在调用服务方法之前打印日志。

@Before("serviceMethods()")
public void beforeAdvice() {
    System.out.println("Before method execution");
}

✌4. @After：

在目标方法执行之后（不论是否发生异常）执行通知。
通知方法会在切点方法之后被调用。

示例：在调用服务方法之后打印日志。

@After("serviceMethods()")
public void afterAdvice() {
    System.out.println("After method execution");
}

✌5. @AfterReturning：

在目标方法成功执行之后执行通知。
通知方法会在切点方法成功执行后被调用。

示例：在调用服务方法成功执行后打印日志。

@AfterReturning(pointcut = "serviceMethods()", returning = "result")
public void afterReturningAdvice(Object result) {
    System.out.println("Method returned: " + result);
}

✌6. @AfterThrowing：

在目标方法抛出异常后执行通知。
通知方法会在切点方法抛出异常后被调用。

示例：在调用服务方法抛出异常后打印日志。

@AfterThrowing(pointcut = "serviceMethods()", throwing = "exception")
public void afterThrowingAdvice(Exception exception) {
    System.out.println("Exception thrown: " + exception.getMessage());
}

✌7. @Around：

包围通知，可以在目标方法执行前后执行自定义逻辑。
通知方法需要接受一个ProceedingJoinPoint参数，通过调用其proceed()方法来执行目标方法。

示例：在调用服务方法前后记录执行时间。

@Around("serviceMethods()")
public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
    long startTime = System.currentTimeMillis();
    Object result = joinPoint.proceed();
    long endTime = System.currentTimeMillis();
    System.out.println("Method execution time: " + (endTime - startTime) + "ms");
    return result;
}

✌8. @Order：

控制多个切面的执行顺序。
值越小，优先级越高。

示例：定义切面的执行顺序。

@Aspect
@Component
@Order(1)
public class FirstAspect {
    // ...
}

@Aspect
@Component
@Order(2)
public class SecondAspect {
    // ...
}

👀使用注解做切点

当谈论AOP中的切面注解时，除了基于切点表达式匹配方法外，还可以使用注解作为切点。这种方式允许你在特定注解被使用时触发通知，从而实现一种基于注解的AOP。以下是涉及切面注解和监听注解的解释和示例：

✌ 示例：

假设我们有一个使用了自定义注解@Loggable的服务类：

package com.example.myapp.service;

import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Loggable
    public void createUser(String username) {
        System.out.println("User created: " + username);
    }

    @Loggable
    public void deleteUser(String username) {
        System.out.println("User deleted: " + username);
    }
}

我们可以创建一个切面来监听使用了@Loggable注解的方法，并在这些方法执行前后记录日志：

package com.example.myapp.aspect;

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

@Aspect
@Component
public class LoggingAspect {

    @Around("@annotation(com.example.myapp.annotation.Loggable)")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("Before method execution");
        Object result = joinPoint.proceed();
        System.out.println("After method execution");
        return result;
    }
}

在上述示例中，我们使用了@Around注解并指定切点表达式为@annotation(com.example.myapp.annotation.Loggable)，这将匹配使用了@Loggable注解的方法。在切面的logAround方法中，我们在方法执行前后记录了日志。

yueerba126

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Springboot - 6.AOP

在这个示例中，AOP的织入过程是在Spring容器完成Bean的初始化之后，也就是在。通知是切面的一部分，它是在特定的连接点上执行的代码。方法用于确定给定的代理配置的完整代理接口集，包括从目标类继承的接口。在Spring Boot中，AOP的织入过程是在Spring容器完成Bean的初始化之后，也就是在。类是Spring AOP框架的一个工具类，它提供了一些静态方法，用于处理代理对象和目标对象。代理是一个对象，它是目标对象的代理，它将调用转发到目标对象，并在调用之前或之后执行通知。切点是一组连接点的集合。
复制链接

扫一扫