public class SimpleCounter {
    // 用ConcurrentHashMap保證線程安全
    private ConcurrentHashMap<String, AtomicLong> counters = new ConcurrentHashMap<>();

    // 記錄接口調(diào)用
    public void increment(String apiName) {
        counters.computeIfAbsent(apiName, k -> new AtomicLong(0)).incrementAndGet();
    }

    // 獲取接口調(diào)用次數(shù)
    public long getCount(String apiName) {
        // 用getOrDefault避免頻繁computeIfAbsent
        return counters.getOrDefault(apiName, new AtomicLong(0)).get();
    }

    // 定時任務(wù)，每分鐘執(zhí)行一次，打印并清零
    @Scheduled(fixedRate = 60000)
    public void printAndReset() {
        System.out.println("=== 接口分鐘調(diào)用統(tǒng)計 ===");
        counters.forEach((api, count) -> {
            System.out.println(api + ": " + count.getAndSet(0));
        });
    }
}

public class SlidingWindowCounter {
    // 記錄每個接口在各個時間片的調(diào)用次數(shù)
    privatefinal ConcurrentHashMap<String, CounterEntry> apiCounters = new ConcurrentHashMap<>();
    // 每個窗口的時長(秒)
    privatefinalint WINDOW_SIZE_SECONDS = 10;
    // 窗口數(shù)量（1分鐘=60秒，分成6個窗口，每個10秒）
    privatefinalint WINDOW_COUNT = 6;
    // 當(dāng)前系統(tǒng)時間片索引
    privatevolatileint currentTimeSlice;

    public SlidingWindowCounter() {
        // 計算初始時間片索引，對齊系統(tǒng)時間
        // 時間片索引公式：當(dāng)前時間秒數(shù) / 窗口大小(10秒) = 第幾個時間片
        currentTimeSlice = (int)(System.currentTimeMillis() / 1000 / WINDOW_SIZE_SECONDS);

        // 啟動定時器，每10秒滑動一次窗口
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

        // 計算第一次執(zhí)行延遲，讓窗口邊界對齊整10秒
        long initialDelay = WINDOW_SIZE_SECONDS - (System.currentTimeMillis() / 1000 % WINDOW_SIZE_SECONDS);

        scheduler.scheduleAtFixedRate(this::slideWindow,
            initialDelay, WINDOW_SIZE_SECONDS, TimeUnit.SECONDS);
    }

    // 記錄接口調(diào)用
    public void increment(String apiName) {
        // 獲取當(dāng)前時間片索引
        int timeSlice = currentTimeSlice;

        // 獲取或創(chuàng)建接口計數(shù)器，懶加載更新窗口
        CounterEntry entry = apiCounters.computeIfAbsent(apiName, k -> new CounterEntry());
        entry.increment(timeSlice);
    }

    // 獲取一分鐘內(nèi)的調(diào)用次數(shù)
    public long getMinuteCount(String apiName) {
        CounterEntry entry = apiCounters.get(apiName);
        if (entry == null) {
            return0;
        }

        // 獲取當(dāng)前時間片之前的6個窗口總和
        return entry.getTotal(currentTimeSlice);
    }

    // 窗口滑動（只更新時間片索引，窗口數(shù)據(jù)懶加載更新）
    private void slideWindow() {
        try {
            // 計算最新的時間片索引
            int newSlice = (int)(System.currentTimeMillis() / 1000 / WINDOW_SIZE_SECONDS);

            // 處理時鐘回撥情況
            if (newSlice <= currentTimeSlice) {
                // 時鐘回撥了，打日志但不更新時間片
                System.err.println("Clock skew detected: " + newSlice + " <= " + currentTimeSlice);
                return;
            }

            // 更新當(dāng)前時間片索引
            currentTimeSlice = newSlice;

            // 定期清理長時間未使用的接口統(tǒng)計
            cleanupIdleCounters();
        } catch (Exception e) {
            // 異常處理，避免定時任務(wù)中斷
            System.err.println("Error in slideWindow: " + e.getMessage());
        }
    }

    // 計數(shù)器條目內(nèi)部類，支持懶加載窗口更新
    privateclass CounterEntry {
        // 時間片計數(shù)數(shù)組
        privatefinal AtomicLong[] counters = new AtomicLong[WINDOW_COUNT];
        // 最后訪問的時間片索引
        privatevolatileint lastAccessedSlice;
        // 最后更新時間
        privatevolatilelong lastUpdateTime;

        public CounterEntry() {
            for (int i = 0; i < WINDOW_COUNT; i++) {
                counters[i] = new AtomicLong(0);
            }
            lastAccessedSlice = currentTimeSlice;
            lastUpdateTime = System.currentTimeMillis();
        }

        // 增加當(dāng)前時間片的計數(shù)
        public void increment(int timeSlice) {
            // 先更新窗口（如果需要）
            updateWindowsIfNeeded(timeSlice);

            // 增加當(dāng)前時間片的計數(shù)
            // 環(huán)形數(shù)組索引 = 時間片索引 % 窗口數(shù)量
            // 這里是關(guān)鍵：通過取模運算使得數(shù)組索引在0-5間循環(huán)，形成環(huán)形結(jié)構(gòu)
            int index = timeSlice % WINDOW_COUNT;
            counters[index].incrementAndGet();

            // 更新訪問信息
            lastAccessedSlice = timeSlice;
            lastUpdateTime = System.currentTimeMillis();
        }

        // 獲取所有窗口的總計數(shù)
        public long getTotal(int currentSlice) {
            // 先更新窗口（如果需要）
            updateWindowsIfNeeded(currentSlice);

            // 計算總和
            long total = 0;
            for (AtomicLong counter : counters) {
                total += counter.get();
            }
            return total;
        }

        // 懶加載更新窗口 - 只在實際訪問時更新
        private void updateWindowsIfNeeded(int currentSlice) {
            int sliceDiff = currentSlice - lastAccessedSlice;

            if (sliceDiff <= 0) {
                // 時間片未變或異常情況（時鐘回撥），無需更新
                return;
            }

            if (sliceDiff >= WINDOW_COUNT) {
                // 如果時間差超過窗口數(shù)，直接清零所有窗口
                for (AtomicLong counter : counters) {
                    counter.set(0);
                }
            } else {
                // 部分窗口需要清零
                for (int i = 1; i <= sliceDiff; i++) {
                    int indexToClear = (lastAccessedSlice + i) % WINDOW_COUNT;
                    counters[indexToClear].set(0);
                }
            }
        }
    }

    // 清理長時間未使用的計數(shù)器，避免內(nèi)存泄漏
    private void cleanupIdleCounters() {
        finallong IDLE_THRESHOLD_MS = 300000; // 5分鐘無調(diào)用則清理
        long now = System.currentTimeMillis();

        Iterator<Map.Entry<String, CounterEntry>> it = apiCounters.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, CounterEntry> entry = it.next();
            CounterEntry counterEntry = entry.getValue();

            if (now - counterEntry.lastUpdateTime > IDLE_THRESHOLD_MS) {
                // 如果5分鐘未更新，移除此接口的統(tǒng)計
                it.remove();
            }
        }
    }
}

@Aspect
@Component
publicclass ApiMonitorAspect {
    privatefinal Logger logger = LoggerFactory.getLogger(ApiMonitorAspect.class);

    // 依賴注入單例計數(shù)器
    @Autowired
    private SlidingWindowCounter counter;

    // 創(chuàng)建線程池，配置拒絕策略
    privatefinal ThreadPoolExecutor asyncExecutor = new ThreadPoolExecutor(
        2, 5, 60, TimeUnit.SECONDS,
        new LinkedBlockingQueue<>(1000),
        Executors.defaultThreadFactory(),
        new ThreadPoolExecutor.CallerRunsPolicy() // 拒絕策略：調(diào)用者執(zhí)行
    );

    // 定義切點，精確匹配只統(tǒng)計HTTP接口
    @Pointcut("@within(org.springframework.web.bind.annotation.RestController) || " +
              "@within(org.springframework.stereotype.Controller)")
    public void apiPointcut() {}

    @Around("apiPointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = null;
        boolean success = false;

        // 獲取完整方法簽名（包含包名），避免同名沖突
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String methodName = signature.getDeclaringType().getName() + "." + signature.getName();

        try {
            // 執(zhí)行原方法
            result = joinPoint.proceed();
            success = true;
            return result;
        } catch (Exception e) {
            // 記錄異常信息
            success = false;
            throw e;
        } finally {
            finallong executionTime = System.currentTimeMillis() - startTime;
            finalboolean finalSuccess = success;

            // 異步記錄統(tǒng)計信息，避免影響主流程性能
            asyncExecutor.execute(() -> {
                try {
                    // 記錄總調(diào)用
                    counter.increment(methodName);

                    // 成功/失敗分類
                    counter.increment(methodName + ":" + (finalSuccess ? "success" : "failure"));

                    // 執(zhí)行時間分類
                    String speedCategory;
                    if (executionTime < 100) {
                        speedCategory = "fast";
                    } elseif (executionTime < 1000) {
                        speedCategory = "medium";
                    } else {
                        speedCategory = "slow";
                    }
                    counter.increment(methodName + ":" + speedCategory);
                } catch (Exception ex) {
                    // 確保統(tǒng)計邏輯異常不影響業(yè)務(wù)
                    logger.error("Failed to record API metrics", ex);
                }
            });
        }
    }

    // 提供查詢接口
    public long getApiCallCount(String apiName) {
        return counter.getMinuteCount(apiName);
    }
}

@Service
publicclass RedisTimeSeriesCounter {
    @Autowired
    private StringRedisTemplate redisTemplate;

    // Redis連接池配置（在應(yīng)用配置文件中設(shè)置）
    // spring.redis.jedis.pool.max-active=100
    // spring.redis.jedis.pool.max-idle=20
    // spring.redis.jedis.pool.min-idle=5
    // spring.redis.jedis.pool.max-wait=1000ms

    // 重試配置
    privatefinalint MAX_RETRIES = 3;
    privatefinallong[] RETRY_DELAYS = {10L, 50L, 200L}; // 指數(shù)退避延遲

    // 記錄接口調(diào)用
    public void increment(String apiName) {
        long timestamp = System.currentTimeMillis();
        String key = getBaseKey(apiName);

        // 使用Lua腳本原子操作：將當(dāng)前分鐘的調(diào)用記錄到有序集合中
        String script =
            "local minute = math.floor(ARGV[1]/60000)*60000; " + // 取整到分鐘
            "redis.call('ZINCRBY', KEYS[1], 1, minute); " +      // 增加計數(shù)
            "redis.call('EXPIRE', KEYS[1], 86400); " +           // 設(shè)置24小時過期
            "return 1;";

        // 帶重試的執(zhí)行Lua腳本
        Exception lastException = null;
        for (int attempt = 0; attempt < MAX_RETRIES; attempt++) {
            try {
                redisTemplate.execute(
                    new DefaultRedisScript<>(script, Long.class),
                    Collections.singletonList(key),
                    String.valueOf(timestamp)
                );
                return; // 成功則直接返回
            } catch (Exception e) {
                lastException = e;
                // 重試前等待一段時間（指數(shù)退避）
                if (attempt < MAX_RETRIES - 1) {
                    try {
                        Thread.sleep(RETRY_DELAYS[attempt]);
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
        }

        // 所有重試都失敗，降級處理
        try {
            logger.warn("Failed to execute Redis script after {} retries, falling back to basic operations", MAX_RETRIES, lastException);
            String minuteKey = String.valueOf(Math.floor(timestamp/60000)*60000);
            redisTemplate.opsForZSet().incrementScore(key, minuteKey, 1);
            redisTemplate.expire(key, 1, TimeUnit.DAYS);
        } catch (Exception e) {
            logger.error("Failed to increment API counter for {}", apiName, e);
            // 本地計數(shù)器備份可以在這里實現(xiàn)
        }
    }

    // 獲取當(dāng)前分鐘的調(diào)用次數(shù)
    public long getCurrentMinuteCount(String apiName) {
        long currentMinute = Math.floor(System.currentTimeMillis()/60000)*60000;
        return getCountByMinute(apiName, currentMinute);
    }

    // 獲取指定分鐘的調(diào)用次數(shù)
    public long getCountByMinute(String apiName, long minuteTimestamp) {
        String key = getBaseKey(apiName);
        Double score = redisTemplate.opsForZSet().score(key, String.valueOf(minuteTimestamp));
        return score == null ? 0 : score.longValue();
    }

    // 獲取一段時間內(nèi)的調(diào)用趨勢
    public Map<Long, Long> getCountTrend(String apiName, long startTime, long endTime) {
        String key = getBaseKey(apiName);

        // 將時間戳取整到分鐘
        long startMinute = Math.floor(startTime/60000)*60000;
        long endMinute = Math.floor(endTime/60000)*60000;

        // 查詢Redis中的時間序列數(shù)據(jù)
        Set<ZSetOperations.TypedTuple<String>> results = redisTemplate.opsForZSet()
            .rangeByScoreWithScores(key, startMinute, endMinute);

        // 構(gòu)建結(jié)果Map
        Map<Long, Long> trend = new TreeMap<>();
        if (results != null) {
            for (ZSetOperations.TypedTuple<String> tuple : results) {
                trend.put(Long.parseLong(tuple.getValue()), tuple.getScore().longValue());
            }
        }

        return trend;
    }

    // 生成Redis基礎(chǔ)key
    private String getBaseKey(String apiName) {
        return"api:timeseries:" + apiName;
    }
}

@Configuration
publicclass MetricsConfig {
    @Bean
    public MeterRegistry meterRegistry() {
        // 定義通用標簽，如應(yīng)用名、環(huán)境等
        returnnew PrometheusMeterRegistry(
            PrometheusConfig.DEFAULT,
            new CollectorRegistry(),
            Clock.SYSTEM,
            new CommonTags("application", "my-app", "env", "prod")
        );
    }

    // 添加維度標簽過濾器，防止基數(shù)爆炸
    @Bean
    public MeterFilter dimensionFilter() {
        // 一個指標最多100個uri維度，避免內(nèi)存爆炸
        return MeterFilter.maximumAllowableTags("api.calls", "uri", 100);
    }

    // 基數(shù)控制：限制name標簽組合不超過5000個
    @Bean
    public MeterFilter cardinalityLimiter() {
        returnnew MeterFilter() {
            @Override
            public Meter.Id map(Meter.Id id) {
                if (id.getName().equals("api.calls") &&
                    meterRegistry.find(id.getName()).tagKeys().size() > 5000) {
                    // 當(dāng)標簽組合超過5000時，歸入"other"類別
                    return id.withTag("name", "other");
                }
                return id;
            }
        };
    }
}

@Component
publicclass ApiMetricsInterceptor implements HandlerInterceptor {
    privatefinal MeterRegistry meterRegistry;
    privatefinal ThreadLocal<Long> startTimeHolder = new ThreadLocal<>();

    // 路徑參數(shù)解析器 - 避免誤判合法數(shù)字
    privatefinal PathParameterResolver pathResolver = new PathParameterResolver();

    public ApiMetricsInterceptor(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        startTimeHolder.set(System.currentTimeMillis());

        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            // 使用全限定類名避免沖突
            String apiName = handlerMethod.getBeanType().getName() + "." + handlerMethod.getMethod().getName();

            // 路徑參數(shù)標準化
            String uri = pathResolver.standardizePath(request.getRequestURI());

            // 記錄接口調(diào)用次數(shù)，使用標簽而非字符串拼接
            meterRegistry.counter("api.calls",
                "name", apiName,
                "method", request.getMethod(),
                "uri", uri
            ).increment();
        }
        returntrue;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        if (handler instanceof HandlerMethod && startTimeHolder.get() != null) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            String apiName = handlerMethod.getBeanType().getName() + "." + handlerMethod.getMethod().getName();

            // 記錄響應(yīng)狀態(tài)碼
            String status = String.valueOf(response.getStatus());

            // 記錄執(zhí)行耗時
            long executionTime = System.currentTimeMillis() - startTimeHolder.get();
            meterRegistry.timer("api.latency",
                "name", apiName,
                "status", status
            ).record(executionTime, TimeUnit.MILLISECONDS);

            // 清理ThreadLocal避免內(nèi)存泄漏
            startTimeHolder.remove();
        }
    }

    // 路徑參數(shù)解析器內(nèi)部類
    privatestaticclass PathParameterResolver {
        // 路徑參數(shù)模式，如/user/{id}中的{id}
        privatefinal Pattern pathParamPattern = Pattern.compile("/\d+(/|$)");

        // 需要保留的數(shù)字路徑（避免誤判合法數(shù)字路徑）
        privatefinal Set<String> preservedNumberPaths = Set.of(
            "/v1", "/v2", "/v3", // API版本
            "/2fa", "/oauth2"    // 特定路徑
        );

        public String standardizePath(String uri) {
            // 對于需要保留的數(shù)字路徑，直接返回
            for (String path : preservedNumberPaths) {
                if (uri.contains(path)) {
                    return uri;
                }
            }

            // 替換疑似ID參數(shù)，如/users/123 -> /users/{id}
            Matcher matcher = pathParamPattern.matcher(uri);
            StringBuffer sb = new StringBuffer();
            while (matcher.find()) {
                String match = matcher.group(0);
                String replacement = match.endsWith("/") ? "/{id}/" : "/{id}";
                matcher.appendReplacement(sb, replacement);
            }
            matcher.appendTail(sb);
            return sb.toString();
        }
    }
}

management.endpoints.web.exposure.include=prometheus,health,info
management.metrics.export.prometheus.enabled=true
management.metrics.tags.application=${spring.application.name}
management.metrics.distribution.percentiles-histogram.http.server.requests=true
# 設(shè)置Prometheus抓取間隔與數(shù)據(jù)保留時間
# prometheus.yml中設(shè)置:
# scrape_interval: 15s
# storage.tsdb.retention.time: 15d

# 查詢UserService.getUser接口每分鐘調(diào)用率
rate(api_calls_total{name="UserService.getUser"}[1m])

# 查詢接口95分位延遲
histogram_quantile(0.95, sum(rate(api_latency_seconds_bucket{name="UserService.getUser"}[5m])) by (le))

# 按狀態(tài)碼統(tǒng)計接口調(diào)用
sum(rate(api_calls_total{name="UserService.getUser"}[5m])) by (status)

@Service
publicclass HybridApiMonitor {
    @Autowired
    private SlidingWindowCounter localCounter;

    @Autowired
    private RedisTimeSeriesCounter redisCounter;

    @Autowired
    private MeterRegistry meterRegistry;

    // 記錄API調(diào)用
    public void recordApiCall(String apiName) {
        // 本地滑動窗口統(tǒng)計 - 實時查詢用
        localCounter.increment(apiName);

        // Redis異步批量寫入 - 本地緩沖后批量寫Redis
        batchRedisWriter.add(apiName);

        // Prometheus長期趨勢 - 加標簽維度
        meterRegistry.counter("api.calls", "name", apiName).increment();
    }

    // 定時任務(wù)：每分鐘將滑動窗口數(shù)據(jù)寫入Redis
    @Scheduled(fixedRate = 60000)
    public void flushToRedis() {
        // 獲取所有接口的分鐘統(tǒng)計，批量寫入Redis
        // 實現(xiàn)略
    }

    // 查詢接口（提供多級統(tǒng)計數(shù)據(jù)）
    public ApiStats getApiStats(String apiName) {
        return ApiStats.builder()
            .realtimeQps(localCounter.getMinuteCount(apiName) / 60.0) // 實時QPS
            .last5MinutesTrend(redisCounter.getCountTrend(apiName, /* 時間范圍 */)) // 分鐘級趨勢
            .prometheusQueryUrl("/grafana/d/apis?var-name=" + apiName) // 長期趨勢查詢鏈接
            .build();
    }
}

// 解決方案：使用Guava Cache限制Map大小
private LoadingCache<String, AtomicLong> counters = CacheBuilder.newBuilder()
    .maximumSize(10000)  // 最多存儲10000個接口
    .expireAfterAccess(30, TimeUnit.MINUTES)  // 30分鐘未訪問自動清除
    .build(new CacheLoader<String, AtomicLong>() {
        @Override
        public AtomicLong load(String key) {
            return new AtomicLong(0);
        }
    });

// 解決方案：時鐘同步方案對比
// 1. NTP同步（物理機最佳）：apt install ntp
// 2. Redis時間服務(wù)（混合環(huán)境推薦）
@Service
publicclass RedisClockService implements ClockService {
    @Autowired
    private StringRedisTemplate redisTemplate;

    @Override
    public long currentTimeMillis() {
        return redisTemplate.execute((RedisCallback<Long>) connection ->
            connection.time()
        );
    }
}
// 3. K8s環(huán)境（容器集群最佳）：使用PTP協(xié)議和NodeTime DaemonSet

// 解決方案：本地緩沖+批量寫入
publicclass BufferedRedisCounter {
    privatefinal ConcurrentHashMap<String, AtomicLong> buffer = new ConcurrentHashMap<>();
    privatefinal ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public BufferedRedisCounter() {
        // 每秒批量寫入Redis
        scheduler.scheduleAtFixedRate(this::flushToRedis, 1, 1, TimeUnit.SECONDS);
    }

    public void increment(String apiName) {
        // 本地增加計數(shù)
        buffer.computeIfAbsent(apiName, k -> new AtomicLong(0)).incrementAndGet();
    }

    private void flushToRedis() {
        if (buffer.isEmpty()) {
            return;
        }

        // 創(chuàng)建Redis管道，批量執(zhí)行命令
        redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
            buffer.forEach((api, count) -> {
                long value = count.getAndSet(0); // 重置緩沖區(qū)
                if (value > 0) {
                    String key = "api:counter:" + api + ":" +
                        ZonedDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ofPattern("yyyyMMddHHmm"));
                    connection.incrBy(key.getBytes(), value);
                    connection.expire(key.getBytes(), 3600); // 1小時過期
                }
            });
            returnnull;
        });
    }
}