custom annotations trong java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RateLimited {
    int rpm() default 60;
    String key();
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@PostMapping // Meta-annotation của Spring
public @interface AuditedPostMapping {
 
    // Tạo alias cho thuộc tính path của @PostMapping
    @AliasFor(annotation = PostMapping.class, attribute = "path")
    String[] path() default {};
 
    // Thuộc tính riêng của audit
    String auditAction();
    boolean maskSensitiveData() default true;
}

package com.company.common.ratelimit;
 
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.TimeUnit;
 
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DistributedRateLimit {
 
    /**
     * SpEL Expression để xác định định danh rate limit.
     * Ví dụ: "#userId", "#request.customerId", hoặc "#ip"
     */
    String key();
 
    /**
     * Số lượng request tối đa trong cửa sổ thời gian.
     */
    int limit() default 100;
 
    /**
     * Độ dài của cửa sổ thời gian.
     */
    long duration() default 60;
 
    /**
     * Đơn vị thời gian (mặc định: SECONDS).
     */
    TimeUnit timeUnit() default TimeUnit.SECONDS;
 
    /**
     * Thông báo lỗi khi bị chặn.
     */
    String message() default "Hệ thống đang bận. Vui lòng thử lại sau!";
}

package com.company.common.ratelimit;
 
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.expression.MethodBasedEvaluationContext;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.core.ParameterNameDiscoverer;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.stereotype.Component;
 
import java.lang.reflect.Method;
import java.time.Duration;
 
@Aspect
@Component
public class DistributedRateLimitAspect {
 
    private static final Logger log = LoggerFactory.getLogger(DistributedRateLimitAspect.class);
 
    private final StringRedisTemplate redisTemplate;
    private final ExpressionParser spelParser = new SpelExpressionParser();
    private final ParameterNameDiscoverer paramDiscoverer = new DefaultParameterNameDiscoverer();
 
    public DistributedRateLimitAspect(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
 
    @Around("@annotation(rateLimit)")
    public Object enforceRateLimit(ProceedingJoinPoint joinPoint, DistributedRateLimit rateLimit) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
 
        // 1. Phân giải SpEL để trích xuất Dynamic Key từ method parameters
        String evaluatedKey = evaluateSpelExpression(rateLimit.key(), method, joinPoint.getArgs(), joinPoint.getTarget());
        String redisKey = String.format("ratelimit:%s:%s", method.getName(), evaluatedKey);
 
        // 2. Kiểm tra token với Redis (Atomic Increment & Expire)
        long durationSeconds = rateLimit.timeUnit().toSeconds(rateLimit.duration());
        Long currentRequests = redisTemplate.opsForValue().increment(redisKey);
 
        if (currentRequests != null && currentRequests == 1) {
            // Đặt TTL cho key ngay ở request đầu tiên
            redisTemplate.expire(redisKey, Duration.ofSeconds(durationSeconds));
        }
 
        if (currentRequests != null && currentRequests > rateLimit.limit()) {
            log.warn("Rate limit breached for key: {} (count: {}/{})", redisKey, currentRequests, rateLimit.limit());
            throw new RateLimitExceededException(rateLimit.message());
        }
 
        // 3. Tiến hành gọi method thực tế
        return joinPoint.proceed();
    }
 
    private String evaluateSpelExpression(String expressionStr, Method method, Object[] args, Object target) {
        if (!expressionStr.startsWith("#")) {
            return expressionStr; // Static key thuần túy
        }
 
        MethodBasedEvaluationContext context = new MethodBasedEvaluationContext(
            target, method, args, this.paramDiscoverer
        );
 
        Object val = spelParser.parseExpression(expressionStr).getValue(context);
        return val != null ? val.toString() : "anonymous";
    }
}

@Service
public class PaymentProcessingService {
 
    /**
     * Giới hạn mỗi User chỉ được thực hiện tối đa 5 giao dịch thanh toán trong vòng 60 giây.
     * Khóa rate-limit được trích xuất trực tiếp từ trường customerId của object request!
     */
    @DistributedRateLimit(
        key = "#request.customerId",
        limit = 5,
        duration = 60,
        timeUnit = TimeUnit.SECONDS,
        message = "Bạn đã thực hiện quá nhiều giao dịch. Vui lòng chờ 1 phút!"
    )
    public TransactionReceipt processPayment(PaymentRequest request) {
        // Business logic an toàn tuyệt đối, không cần bận tâm về rate-limiting code
        return executePayment(request);
    }
}

@Service
public class OrderService {
 
    public void processAll() {
        // GỌI NỘI BỘ (this.executeSingle): Proxy BỊ BYPASS HOÀN TOÀN!
        // Annotation @DistributedRateLimit trên executeSingle() sẽ KHÔNG CHẠY!
        this.executeSingle();
    }
 
    @DistributedRateLimit(key = "'fixed'", limit = 2)
    public void executeSingle() {
        // ...
    }
}