<think>我们
参考了站内引用中的多个例子，特别是引用[1]和引用[3]中关于
自定义注解和
AOP切面的
实现。下面将详细说明在
Spring Boot中如何通过
AOP实现自定义注解的功能。
步骤分为：
1. 创建
自定义注解
2. 创建切面类（
使用@Aspect和@Component）
3. 在切面类中定义切入点（
使用自定义注解）和通知（如@Before, @Around等）
4. 在需要的地方
使用自定义注解
下面以记录方法日志为例，逐步
实现：
第一步：创建
自定义注解
我们可以定义一个
注解，用于标记需要增强的方法。
```
java
import
java.lang.annotation.*;
@Target(ElementType.METHOD) // 该
注解只能应用在方法上
@Retention(RetentionPolicy.RUNTIME) // 在运行时保留，这样
AOP代理才能读取到
@Documented
public @interface Loggable {
// 可以定义一些属性，比如日志描述信息
String value() default "";
}
```
第二步：创建切面类
在切面类中，我们将定义通知（Advice）和切入点（Pointcut），切入点将
使用我们
自定义的
注解。
```
java
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.
springframework.stereotype.Component;
@Aspect
@Component
public class LoggingAspect {
// 定义切入点：所有被@Loggable
注解的方法
@Pointcut("@annotation(com.example.annotation.Loggable)")
public void loggableMethod() {}
// 前置通知：在目标方法执行前执行
@Before("loggableMethod()")
public void logBefore(JoinPoint joinPoint) {
// 这里可以获取方法名、
参数等信息
String methodName = joinPoint.getSignature().getName();
Object[] args = joinPoint.getArgs();
System.out.println("方法 " + methodName + " 开始执行，
参数: " + Arrays.toString(args));
}
}
```
第三步：在需要的方法上
使用自定义注解
例如，我们在一个Service的方法上
使用@Loggable
注解。
```
java
@Service
public class UserService {
@Loggable("这是一个获取用户信息的方法")
public User getUserById(Long id) {
// 业务逻辑
return new User(id, "张三");
}
}
```
这样，当调用getUserById方法时，切面中的前置通知就会执行，打印日志。
扩展：我们还可以
使用环绕通知（@Around）来
实现更复杂的逻辑，比如记录方法执行时间。
```
java
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.
springframework.stereotype.Component;
@Aspect
@Component
public class PerformanceAspect {
@Around("@annotation(com.example.annotation.Loggable)")
public Object logPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
long startTime = System.currentTimeMillis();
Object result = joinPoint.proceed(); // 执行目标方法
long endTime = System.currentTimeMillis();
System.out.println("方法 " + joinPoint.getSignature().getName() + " 执行耗时: " + (endTime
- startTime) + "ms");
return result;
}
}
```
注意事项：
1. 确保
Spring Boot项目已经添加了
AOP依赖（
spring-boot-starter
-aop）。
2.
自定义注解的路径在切面类中要写正确。
3. 切面类需要被
Spring管理（
使用@Component），同时
使用@Aspect
注解。
通过以上步骤，我们就
实现了在
Spring Boot中
使用AOP和
自定义注解来增强方法的功能。
参考引用：
[1]中提到了
自定义注解和
AOP的
使用，我们
参考了其
注解定义和切面类结构[^1]。
[3]中提到了切面类的基本结构[^3]。</think>###
Spring Boot 通过
AOP 实现自定义注解功能
在
Spring Boot 中
使用 AOP 实现自定义注解功能需要以下步骤，
参考了站内多个
实现案例[^1][^3][^4]：
---
#### 1. 添加
AOP 依赖
```xml
<dependency>
<groupId>org.
springframework.
boot</groupId>
<artifactId>
spring-boot-starter
-aop</artifactId>
</dependency>
```
---
#### 2. 创建
自定义注解
定义
注解类并指定作用范围：
```
java
import
java.lang.annotation.*;
@Target(ElementType.METHOD) // 作用于方法级别
@Retention(RetentionPolicy.RUNTIME) // 运行时保留
@Documented
public @interface CustomLog {
String value() default ""; // 可配置的
注解属性
LogType type() default LogType.OPERATION; // 枚举类型属性
}
```
定义日志类型枚举：
```
java
public enum LogType {
OPERATION,
SECURITY,
PERFORMANCE
}
```
---
#### 3. 创建切面类
实现注解的横切逻辑：
```
java
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.
springframework.stereotype.Component;
@Aspect
@Component
public class LogAspect {
// 定义切入点：所有被@CustomLog
注解的方法
@Pointcut("@annotation(com.example.annotation.CustomLog)")
public void logPointcut() {}
// 环绕通知（最常用）
@Around("logPointcut()")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
// 1. 获取方法信息
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
CustomLog annotation = method.getAnnotation(CustomLog.class);
// 2. 前置处理（记录开始时间等）
long startTime = System.currentTimeMillis();
System.out.println("【" + annotation.type() + "日志】方法开始: " + method.getName());
try {
// 3. 执行目标方法
Object result = joinPoint.proceed();
// 4. 后置处理（记录结果）
long duration = System.currentTimeMillis()
- startTime;
System.out.println("方法执行完成，耗时: " + duration + "ms");
return result;
} catch (Exception e) {
// 5. 异常处理
System.err.println("方法执行异常: " + e.getMessage());
throw e;
}
}
// 前置通知（可选）
@Before("logPointcut()")
public void logBefore(JoinPoint joinPoint) {
// 记录方法
参数等
Object[] args = joinPoint.getArgs();
System.out.println("方法
参数: " + Arrays.toString(args));
}
}
```
---
#### 4.
使用自定义注解
在业务方法上添加
注解：
```
java
@Service
public class UserService {
@CustomLog(type = LogType.OPERATION, value = "用户查询")
public User getUserById(Long id) {
// 业务逻辑
}
@CustomLog(type = LogType.SECURITY)
public void updatePassword(String newPassword) {
// 密码更新逻辑
}
}
```
---
#### 5. 高级功能
实现
##### 敏感字段加解密（
参考[^2]）
```
java
@Aspect
@Component
public class EncryptionAspect {
@Around("@annotation(SensitiveData)")
public Object encryptData(ProceedingJoinPoint pjp) throws Throwable {
Object result = pjp.proceed();
if (result instanceof User) {
User user = (User) result;
user.setPassword(encrypt(user.getPassword())); // 加密处理
}
return result;
}
}
```
##### 操作日志入库（
参考[^4]）
```
java
@Around("@annotation(OperateLog)")
public Object recordOperation(ProceedingJoinPoint pjp) throws Throwable {
OperateLog logAnnotation = getAnnotation(pjp);
LogEntity log = new LogEntity();
log.setOperationType(logAnnotation.value());
try {
Object result = pjp.proceed();
log.setStatus("SUCCESS");
return result;
} catch (Exception e) {
log.setStatus("FAILED");
throw e;
} finally {
logService.save(log); // 保存到数据库
}
}
```
---
#### 关键注意事项
1. **
注解属性访问**：通过 `method.getAnnotation()` 获取
注解配置
2. **方法信息获取**：
```
java
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
String methodName = signature.getName();
Class<?> targetClass = joinPoint.getTarget().getClass();
```
3. **代理限制**：
AOP 对 private 方法和内部调用无效
4. **执行顺序**：
使用 `@Order`
注解控制多个切面的执行顺序
5. **性能优化**：避免在切面中执行耗时操作，特别是高频方法
> 完整
实现可
参考
Spring Boot 操作日志管理[^4] 和敏感字段加解密[^2] 的案例
实现。
本文介绍了如何通过定义一个自定义注解`DataSourceFilter`，结合Spring AOP在执行方法前后动态切换数据源。在切入点`execution(*com.demo.service.impl.*.*(..))`匹配的方法中，如果类或方法带有该注解，就会调用`DataSourceFilterService`来切换数据源。需要注意的是，AOP不会对类内部调用和私有方法生效。
扫一扫
1900
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
