@Aspect
@Component
public class SecurityAspect {
    @Before("@annotation(requiresAuth)")
    public void checkAuth(JoinPoint joinPoint, RequiresAuth requiresAuth) {
        // 獲取當前用戶信息
        ServletRequestAttributes attributes = 
            (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        String token = request.getHeader("Authorization");
        // 驗證token
        if (!tokenService.isValid(token)) {
            throw new UnauthorizedException("無效的認證令牌");
        }
        // 檢查權限
        String requiredRole = requiresAuth.role();
        if (!hasRole(token, requiredRole)) {
            throw new ForbiddenException("權限不足");
        }
    }
}

@Before("execution(* com.example.service.*.*(..))")
public void beforeAdvice(JoinPoint joinPoint) {
    // 獲取方法參數(shù)
    Object[] args = joinPoint.getArgs();
    // 獲取方法簽名
    MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    String methodName = signature.getName();
    // 獲取參數(shù)名稱
    String[] parameterNames = signature.getParameterNames();
    // 獲取參數(shù)類型
    Class<?>[] parameterTypes = signature.getParameterTypes();
    // 打印參數(shù)信息
    for (int i = 0; i < args.length; i++) {
        logger.info("Parameter {} ({}) = {}", parameterNames[i], parameterTypes[i].getSimpleName(), args[i]);
    }
}

@Before("@annotation(logParams)")
public void beforeWithAnnotation(JoinPoint joinPoint, LogParams logParams) {
    // 直接獲取注解屬性
    String description = logParams.description();
    boolean logResult = logParams.logResult();
    // 獲取方法參數(shù)
    Object[] args = joinPoint.getArgs();
    // 根據注解配置記錄日志
    if (logParams.includeParameters()) {
        Arrays.stream(args)
              .forEach(arg -> logger.info("Parameter value: {}", arg));
    }
}

@Aspect
@Component
public class ResourceCleanupAspect {
    @After("execution(* com.example.service.FileService.*(..))")
    public void cleanup(JoinPoint joinPoint) {
        try {
            // 清理臨時文件
            String methodName = joinPoint.getSignature().getName();
            logger.info("Cleaning up resources after method: {}", methodName);
            cleanupTempFiles();
            // 釋放其他資源
            releaseResources();
        } catch (Exception e) {
            logger.error("Cleanup failed", e);
        }
    }
    private void cleanupTempFiles() {
        // 清理臨時文件的具體實現(xiàn)
    }
    private void releaseResources() {
        // 釋放資源的具體實現(xiàn)
    }
}

@After("execution(* com.example.service.*.*(..)) && args(id,name,..)")
public void afterAdvice(JoinPoint joinPoint, Long id, String name) {
    // 直接使用參數(shù)
    logger.info("Method executed with ID: {} and name: {}", id, name);
    // 獲取目標類信息
    Class<?> targetClass = joinPoint.getTarget().getClass();
    // 獲取代理類信息
    Class<?> proxyClass = joinPoint.getThis().getClass();
}

@Aspect
@Component
public class ResponseHandlerAspect {
    @AfterReturning(
        pointcut = "execution(* com.example.controller.*.*(..))",
        returning = "result"
    )
    public void handleResponse(JoinPoint joinPoint, Object result) {
        if (result instanceof List) {
            // 對集合類型結果進行脫敏處理
            List<?> list = (List<?>) result;
            for (Object item : list) {
                if (item instanceof UserDTO) {
                    UserDTO user = (UserDTO) item;
                    user.setPhone(maskPhoneNumber(user.getPhone()));
                    user.setEmail(maskEmail(user.getEmail()));
                }
            }
        }
    }
    private String maskPhoneNumber(String phone) {
        // 手機號碼脫敏邏輯
        return phone.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
    }
    private String maskEmail(String email) {
        // 郵箱脫敏邏輯
        return email.replaceAll("(\\w{3})\\w+(@\\w+\\.\\w+)", "$1***$2");
    }
}

@Aspect
@Component
public class ExceptionHandlerAspect {
    @AfterThrowing(
        pointcut = "execution(* com.example.service.*.*(..))",
        throwing = "ex"
    )
    public void handleException(JoinPoint joinPoint, Exception ex) {
        String methodName = joinPoint.getSignature().getName();
        String className = joinPoint.getTarget().getClass().getSimpleName();
        // 記錄詳細錯誤信息
        logger.error("Exception in {}.{}: {}", className, methodName, ex.getMessage());
        // 發(fā)送告警
        if (ex instanceof DataAccessException) {
            alertService.sendDatabaseAlert(className, methodName, ex);
        }
        // 異常分類統(tǒng)計
        metricService.incrementExceptionCounter(className, methodName, ex.getClass().getSimpleName());
        // 如果需要，可以轉換異常類型
        if (ex instanceof SQLException) {
            throw new DatabaseException("數(shù)據庫操作失敗", ex);
        }
    }
}

@Aspect
@Component
public class CacheAspect {
    @Autowired
    private CacheManager cacheManager;
    @Around("@annotation(cacheable)")
    public Object handleCache(ProceedingJoinPoint joinPoint, Cacheable cacheable) throws Throwable {
        // 構建緩存key
        String key = buildCacheKey(joinPoint, cacheable);
        // 嘗試從緩存獲取
        Object cachedValue = cacheManager.get(key);
        if (cachedValue != null) {
            logger.debug("Cache hit for key: {}", key);
            return cachedValue;
        }
        // 執(zhí)行目標方法
        long startTime = System.currentTimeMillis();
        Object result = null;
        try {
            result = joinPoint.proceed();
            // 記錄執(zhí)行時間
            long executionTime = System.currentTimeMillis() - startTime;
            logger.debug("Method execution time: {}ms", executionTime);
            // 如果執(zhí)行時間超過閾值，發(fā)送告警
            if (executionTime > 1000) {
                alertService.sendPerformanceAlert(joinPoint, executionTime);
            }
        } catch (Exception e) {
            // 異常處理
            logger.error("Method execution failed", e);
            throw e;
        }
        // 將結果放入緩存
        if (result != null) {
            cacheManager.put(key, result, cacheable.ttl());
        }
        return result;
    }
    private String buildCacheKey(ProceedingJoinPoint joinPoint, Cacheable cacheable) {
        // 緩存key構建邏輯
        StringBuilder key = new StringBuilder();
        key.append(joinPoint.getSignature().getDeclaringTypeName())
           .append(".")
           .append(joinPoint.getSignature().getName());
        Object[] args = joinPoint.getArgs();
        if (args != null && args.length > 0) {
            key.append(":");
            for (Object arg : args) {
                key.append(arg != null ? arg.toString() : "null").append(",");
            }
        }
        return key.toString();
    }
}

@Aspect
@Component
public class RateLimiterAspect {
    private final RateLimiter rateLimiter = RateLimiter.create(100.0); // 每秒100個請求
    @Around("@annotation(rateLimited)")
    public Object limitRate(ProceedingJoinPoint joinPoint, RateLimited rateLimited) throws Throwable {
        if (!rateLimiter.tryAcquire(100, TimeUnit.MILLISECONDS)) {
            throw new TooManyRequestsException("請求過于頻繁，請稍后重試");
        }
        return joinPoint.proceed();
    }
}