Spring AOP notification type and practical example explanation

@Aspect
@Component
public class SecurityAspect {
    @Before("@annotation(requiresAuth)")
    public void checkAuth(JoinPoint joinPoint, RequiresAuth requiresAuth) {
        // Get current user information        ServletRequestAttributes attributes = 
            (ServletRequestAttributes) ();
        HttpServletRequest request = ();
        String token = ("Authorization");
        // Verify token        if (!(token)) {
            throw new UnauthorizedException("Invalid authentication token");
        }
        // Check permissions        String requiredRole = ();
        if (!hasRole(token, requiredRole)) {
            throw new ForbiddenException("Insufficient permissions");
        }
    }
}

@Before("execution(* .*.*(..))")
public void beforeAdvice(JoinPoint joinPoint) {
    // Get method parameters    Object[] args = ();
    // Get the method signature    MethodSignature signature = (MethodSignature) ();
    String methodName = ();
    // Get the parameter name    String[] parameterNames = ();
    // Get parameter type    Class<?>[] parameterTypes = ();
    // Print parameter information    for (int i = 0; i < ; i++) {
        ("Parameter {} ({}) = {}", parameterNames[i], parameterTypes[i].getSimpleName(), args[i]);
    }
}

@Before("@annotation(logParams)")
public void beforeWithAnnotation(JoinPoint joinPoint, LogParams logParams) {
    // Get the annotation attributes directly    String description = ();
    boolean logResult = ();
    // Get method parameters    Object[] args = ();
    //Configure logs according to annotation    if (()) {
        (args)
              .forEach(arg -> ("Parameter value: {}", arg));
    }
}

@Aspect
@Component
public class ResourceCleanupAspect {
    @After("execution(* .*(..))")
    public void cleanup(JoinPoint joinPoint) {
        try {
            // Clean up temporary files            String methodName = ().getName();
            ("Cleaning up resources after method: {}", methodName);
            cleanupTempFiles();
            // Release other resources            releaseResources();
        } catch (Exception e) {
            ("Cleanup failed", e);
        }
    }
    private void cleanupTempFiles() {
        // Specific implementation of cleaning temporary files    }
    private void releaseResources() {
        // Specific implementation of freeing resources    }
}

@After("execution(* .*.*(..)) && args(id,name,..)")
public void afterAdvice(JoinPoint joinPoint, Long id, String name) {
    // Use parameters directly    ("Method executed with ID: {} and name: {}", id, name);
    // Get target information    Class<?> targetClass = ().getClass();
    // Get agent information    Class<?> proxyClass = ().getClass();
}

@Aspect
@Component
public class ResponseHandlerAspect {
    @AfterReturning(
        pointcut = "execution(* .*.*(..))",
        returning = "result"
    )
    public void handleResponse(JoinPoint joinPoint, Object result) {
        if (result instanceof List) {
            // Desensitize the set type results            List<?> list = (List<?>) result;
            for (Object item : list) {
                if (item instanceof UserDTO) {
                    UserDTO user = (UserDTO) item;
                    (maskPhoneNumber(()));
                    (maskEmail(()));
                }
            }
        }
    }
    private String maskPhoneNumber(String phone) {
        // Mobile phone number desensitization logic        return ("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    }
    private String maskEmail(String email) {
        // Email Desensitization Logic        return ("(\\w{3})\\w+(@\\w+\\.\\w+)", "$1***$2");
    }
}

@Aspect
@Component
public class ExceptionHandlerAspect {
    @AfterThrowing(
        pointcut = "execution(* .*.*(..))",
        throwing = "ex"
    )
    public void handleException(JoinPoint joinPoint, Exception ex) {
        String methodName = ().getName();
        String className = ().getClass().getSimpleName();
        // Record detailed error information        ("Exception in {}.{}: {}", className, methodName, ());
        // Send an alarm        if (ex instanceof DataAccessException) {
            (className, methodName, ex);
        }
        // Exception classification statistics        (className, methodName, ().getSimpleName());
        // If necessary, you can convert the exception type        if (ex instanceof SQLException) {
            throw new DatabaseException("Database operation failed", ex);
        }
    }
}

@Aspect
@Component
public class CacheAspect {
    @Autowired
    private CacheManager cacheManager;
    @Around("@annotation(cacheable)")
    public Object handleCache(ProceedingJoinPoint joinPoint, Cacheable cacheable) throws Throwable {
        // Build cache key        String key = buildCacheKey(joinPoint, cacheable);
        // Try to get from cache        Object cachedValue = (key);
        if (cachedValue != null) {
            ("Cache hit for key: {}", key);
            return cachedValue;
        }
        // Execute the target method        long startTime = ();
        Object result = null;
        try {
            result = ();
            // Record execution time            long executionTime = () - startTime;
            ("Method execution time: {}ms", executionTime);
            // If the execution time exceeds the threshold, send an alarm            if (executionTime > 1000) {
                (joinPoint, executionTime);
            }
        } catch (Exception e) {
            // Exception handling            ("Method execution failed", e);
            throw e;
        }
        // Put the result into cache        if (result != null) {
            (key, result, ());
        }
        return result;
    }
    private String buildCacheKey(ProceedingJoinPoint joinPoint, Cacheable cacheable) {
        // Cache key construction logic        StringBuilder key = new StringBuilder();
        (().getDeclaringTypeName())
           .append(".")
           .append(().getName());
        Object[] args = ();
        if (args != null &&  > 0) {
            (":");
            for (Object arg : args) {
                (arg != null ? () : "null").append(",");
            }
        }
        return ();
    }
}

@Aspect
@Component
public class RateLimiterAspect {
    private final RateLimiter rateLimiter = (100.0); // 100 requests per second    @Around("@annotation(rateLimited)")
    public Object limitRate(ProceedingJoinPoint joinPoint, RateLimited rateLimited) throws Throwable {
        if (!(100, )) {
            throw new TooManyRequestsException("Requests are too frequent, please try again later");
        }
        return ();
    }
}