👀概念

当谈论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 {@Loggablepublic void createUser(String username) {System.out.println("User created: " + username);}@Loggablepublic 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;}
}