From 1f9454af3356f628c25c3e2e492869163731da56 Mon Sep 17 00:00:00 2001
From: puzhibing <393733352@qq.com>
Date: 星期五, 09 十月 2026 10:47:24 +0800
Subject: [PATCH] 修改bug
---
DriverFBTravel/guns-admin/src/main/java/com/stylefeng/guns/modular/system/util/GDKeyManager.java | 349 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 349 insertions(+), 0 deletions(-)
diff --git a/DriverFBTravel/guns-admin/src/main/java/com/stylefeng/guns/modular/system/util/GDKeyManager.java b/DriverFBTravel/guns-admin/src/main/java/com/stylefeng/guns/modular/system/util/GDKeyManager.java
new file mode 100644
index 0000000..e06550d
--- /dev/null
+++ b/DriverFBTravel/guns-admin/src/main/java/com/stylefeng/guns/modular/system/util/GDKeyManager.java
@@ -0,0 +1,349 @@
+package com.stylefeng.guns.modular.system.util;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.stylefeng.guns.modular.system.dao.GDKeyMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import org.springframework.web.client.RestTemplate;
+
+import javax.annotation.PostConstruct;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * 高德地图key管理器
+ * <p>
+ * 功能：
+ * 1. key池管理：从 t_gaode_account 表加载可用key（启用、未删除、未用完），轮询获取；
+ * 表为空或全部用尽时降级使用兜底key（原硬编码key）。
+ * 2. 自动切换：调用方检测到key"次数用完"后调用 reportExhausted 上报，
+ * 管理器将key移出内存池并置库表 useStatus=3（已用完）。
+ * 3. 每日凌晨重置校验：每天 00:00 将 useStatus=3 的key重置为未使用并放回池，
+ * 随后调用高德最轻量接口校验配额是否真正恢复；未恢复的key重新标记已用完，
+ * 进入延迟重试队列，每30分钟校验一次直到恢复额度。
+ * 4. 兜底key：当天用完仅内存禁用，次日凌晨自动恢复；不写库（表内无对应记录）。
+ */
+@Component
+public class GDKeyManager {
+
+ private static final Logger logger = LoggerFactory.getLogger(GDKeyManager.class);
+
+ /**
+ * 兜底key（原硬编码key）：司机端
+ */
+ public static final String FALLBACK_KEY = "39b31fa22955efa8fce9eed487241db9";
+
+ /**
+ * 配额校验接口：最轻量的通用Web服务接口，每次仅消耗1次配额
+ */
+ private static final String VERIFY_URL = "https://restapi.amap.com/v3/geocode/geo?output=JSON&address=%E5%8C%97%E4%BA%AC%E5%B8%82&key=";
+
+ @Autowired
+ private GDKeyMapper gdKeyMapper;
+
+ @Autowired
+ private RestTemplate restTemplate;
+
+ /**
+ * 内存可用key池（refreshPool整体替换，保证getKey不会看到clear/addAll中间态）
+ */
+ private volatile List<String> availableKeys = new CopyOnWriteArrayList<>();
+
+ /**
+ * 轮询下标
+ */
+ private final AtomicInteger index = new AtomicInteger(0);
+
+ /**
+ * 延迟校验队列：key -> 已重试次数（每日凌晨校验未恢复的key）
+ */
+ private final ConcurrentHashMap<String, Integer> pendingVerifyKeys = new ConcurrentHashMap<>();
+
+ /**
+ * 兜底key当日是否已用完
+ */
+ private volatile boolean fallbackExhausted = false;
+
+ /**
+ * 已标记"使用中"（useStatus=2）的key集合，避免热路径每次取用都写库
+ */
+ private final Set<String> inUseKeys = ConcurrentHashMap.newKeySet();
+
+ @PostConstruct
+ public void init() {
+ refreshPool();
+ }
+
+ /**
+ * 刷新可用key池
+ */
+ public synchronized void refreshPool() {
+ try {
+ List<String> keys = gdKeyMapper.selectAvailableKeys();
+ List<String> newPool = new CopyOnWriteArrayList<>();
+ if (keys != null) {
+ newPool.addAll(keys);
+ }
+ // 整体替换，避免clear/addAll中间态导致getKey短暂看到空池误降级兜底key
+ availableKeys = newPool;
+ logger.info("[GDKeyManager] 高德key池刷新完成，可用key数：{}", newPool.size());
+ } catch (Exception e) {
+ // 表不存在（用户端/司机端未建表时）等异常：降级使用兜底key，不影响系统运行
+ logger.warn("[GDKeyManager] 加载高德key失败（t_gaode_account表可能不存在），降级使用兜底key", e);
+ availableKeys = new CopyOnWriteArrayList<>();
+ }
+ }
+
+ /**
+ * 获取一个可用key：池非空轮询池内key；池空使用兜底key（当日未用完时）
+ */
+ public String getKey() {
+ List<String> pool = availableKeys;
+ if (!pool.isEmpty()) {
+ String key = pickFromPool(pool);
+ markInUse(key);
+ return key;
+ }
+ if (!fallbackExhausted) {
+ return FALLBACK_KEY;
+ }
+ // 兜底key当日也已用完：尝试刷新池（可能有新录入的key）
+ refreshPool();
+ pool = availableKeys;
+ if (!pool.isEmpty()) {
+ String key = pickFromPool(pool);
+ markInUse(key);
+ return key;
+ }
+ return FALLBACK_KEY;
+ }
+
+ /**
+ * 从内存池轮询取一个key（使用调用方传入的池快照，避免与定时刷新交叉导致越界）
+ */
+ private String pickFromPool(List<String> pool) {
+ int i = Math.abs(index.getAndIncrement() % pool.size());
+ return pool.get(i);
+ }
+
+ /**
+ * 将表内key标记为"使用中"（useStatus=2）：
+ * 仅key首次被取用时写库一次；兜底key不写库；写库失败不影响取key流程。
+ */
+ private void markInUse(String key) {
+ if (key == null || FALLBACK_KEY.equals(key) || inUseKeys.contains(key)) {
+ return;
+ }
+ try {
+ gdKeyMapper.updateUseStatus(key, 2);
+ inUseKeys.add(key);
+ logger.info("[GDKeyManager] 高德key[{}]开始使用，已标记为使用中", key);
+ } catch (Exception e) {
+ // 表不存在等异常：本次不标记，下次取用再尝试，不影响业务
+ logger.warn("[GDKeyManager] 标记高德key[{}]使用中失败（表可能不存在），不影响使用", key);
+ }
+ }
+
+ /**
+ * 定时刷新key池：每5分钟一次，让管理后台新录入的key及时生效
+ */
+ @Scheduled(fixedDelay = 5 * 60 * 1000, initialDelay = 60 * 1000)
+ public void scheduledRefreshPool() {
+ refreshPool();
+ }
+
+ /**
+ * 上报某个key次数用完：
+ * 表内key -> 移出内存池 + 置库表 useStatus=3；
+ * 兜底key -> 仅内存当日禁用（不写库），次日凌晨自动恢复。
+ */
+ public void reportExhausted(String usedKey) {
+ if (usedKey == null || usedKey.isEmpty()) {
+ return;
+ }
+ availableKeys.remove(usedKey);
+ inUseKeys.remove(usedKey);
+ if (FALLBACK_KEY.equals(usedKey)) {
+ fallbackExhausted = true;
+ logger.warn("[GDKeyManager] 兜底key次数已用完，今日禁用，次日凌晨自动恢复");
+ return;
+ }
+ try {
+ gdKeyMapper.updateUseStatus(usedKey, 3);
+ logger.warn("[GDKeyManager] 高德key[{}]次数用完，已标记为已用完并移出key池", usedKey);
+ } catch (Exception e) {
+ logger.warn("[GDKeyManager] 更新高德key[{}]使用状态失败（表可能不存在），仅内存剔除", usedKey);
+ }
+ }
+
+ /**
+ * 判断Web服务API响应是否为"次数用完/不可用"（依据infocode）
+ */
+ public static boolean isWebKeyExhausted(JSONObject resp) {
+ if (resp == null) {
+ return false;
+ }
+ String infocode = resp.getString("infocode");
+ if (infocode == null || infocode.isEmpty()) {
+ return false;
+ }
+ switch (infocode) {
+ case "10001": // key不正确或过期
+ case "10003": // 超过每日配额
+ case "10004": // 访问过于频繁
+ case "10005": // 超出每秒访问量限制
+ case "10010": // 权限不足
+ case "10012": // 服务未开放/权限不足
+ case "10019": // 使用配额已用尽
+ case "10020": // 并发超限
+ case "10044": // 签名错误/未开通
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ /**
+ * 判断猎鹰API响应是否为"次数用完"（依据errcode/errmsg）
+ */
+ public static boolean isFalconExhausted(JSONObject resp) {
+ if (resp == null) {
+ return false;
+ }
+ int errcode = resp.getIntValue("errcode");
+ if (errcode == 10000) {
+ return false;
+ }
+ if (errcode == 20001) {
+ return true; // 权限不足
+ }
+ String errmsg = resp.getString("errmsg");
+ if (errmsg == null) {
+ return false;
+ }
+ return errmsg.contains("配额") || errmsg.contains("上限") || errmsg.contains("次数")
+ || errmsg.contains("用完") || errmsg.contains("超限")
+ || errmsg.contains("quota") || errmsg.contains("limit");
+ }
+
+ // ==================== 每日凌晨重置 + API校验恢复额度 ====================
+
+ /**
+ * 每日凌晨 00:00 自动执行：
+ * 1. 将 useStatus=3（已用完）的key重置为未使用并放回内存池；
+ * 2. 调用高德API校验配额是否真正恢复；
+ * 3. 未恢复的key重新标记已用完，进入延迟重试队列，直到恢复额度。
+ */
+ @Scheduled(cron = "0 0 0 * * ?")
+ public void dailyResetAndVerify() {
+ logger.info("[GDKeyManager] 开始每日高德key配额重置校验");
+ // 兜底key当日禁用标记次日自动恢复
+ fallbackExhausted = false;
+ List<String> exhaustedKeys;
+ try {
+ exhaustedKeys = gdKeyMapper.selectExhaustedKeys();
+ } catch (Exception e) {
+ logger.warn("[GDKeyManager] 查询已用完key失败（表可能不存在），跳过重置校验", e);
+ return;
+ }
+ if (exhaustedKeys == null || exhaustedKeys.isEmpty()) {
+ logger.info("[GDKeyManager] 无已用完的key，跳过重置校验");
+ return;
+ }
+ for (String gdKey : exhaustedKeys) {
+ // 1. 先重置为未使用
+ try {
+ gdKeyMapper.updateUseStatus(gdKey, 1);
+ } catch (Exception e) {
+ logger.warn("[GDKeyManager] 重置key[{}]使用状态失败", gdKey, e);
+ }
+ // 2. 调用API校验是否真正恢复额度
+ boolean recovered = verifyQuota(gdKey);
+ if (recovered) {
+ if (!availableKeys.contains(gdKey)) {
+ availableKeys.add(gdKey);
+ }
+ pendingVerifyKeys.remove(gdKey);
+ logger.info("[GDKeyManager] 高德key[{}]配额已恢复，重新加入key池", gdKey);
+ } else {
+ // 未恢复：重新标记已用完，进入延迟重试队列
+ try {
+ gdKeyMapper.updateUseStatus(gdKey, 3);
+ } catch (Exception e) {
+ logger.warn("[GDKeyManager] 回写key[{}]已用完状态失败", gdKey, e);
+ }
+ availableKeys.remove(gdKey);
+ pendingVerifyKeys.put(gdKey, 0);
+ logger.warn("[GDKeyManager] 高德key[{}]配额尚未恢复，进入延迟重试队列", gdKey);
+ }
+ }
+ }
+
+ /**
+ * 延迟重试任务：每30分钟校验一次待恢复的key，直到恢复额度为止
+ */
+ @Scheduled(fixedDelay = 30 * 60 * 1000, initialDelay = 30 * 60 * 1000)
+ public void retryPendingKeys() {
+ if (pendingVerifyKeys.isEmpty()) {
+ return;
+ }
+ for (String gdKey : new ArrayList<>(pendingVerifyKeys.keySet())) {
+ boolean recovered = verifyQuota(gdKey);
+ if (recovered) {
+ try {
+ gdKeyMapper.updateUseStatus(gdKey, 1);
+ } catch (Exception e) {
+ logger.warn("[GDKeyManager] 恢复key[{}]使用状态失败", gdKey, e);
+ }
+ if (!availableKeys.contains(gdKey)) {
+ availableKeys.add(gdKey);
+ }
+ pendingVerifyKeys.remove(gdKey);
+ logger.info("[GDKeyManager] 高德key[{}]延迟校验通过，配额已恢复，重新加入key池", gdKey);
+ } else {
+ int count = pendingVerifyKeys.merge(gdKey, 1, Integer::sum);
+ logger.warn("[GDKeyManager] 高德key[{}]配额仍未恢复（已校验{}次），继续等待", gdKey, count);
+ }
+ }
+ }
+
+ /**
+ * 调用高德最轻量接口校验配额是否恢复
+ *
+ * @return true=已恢复（或无法判断，保守放行）；false=明确未恢复（配额类错误）
+ */
+ private boolean verifyQuota(String gdKey) {
+ try {
+ String resp = restTemplate.getForObject(VERIFY_URL + gdKey, String.class);
+ JSONObject json = JSON.parseObject(resp);
+ String status = json.getString("status");
+ String infocode = json.getString("infocode");
+ if ("1".equals(status) && "10000".equals(infocode)) {
+ return true;
+ }
+ // 权限类错误：该key未开通Web服务校验权限（如猎鹰专用key），无法判断配额，按已恢复处理
+ if ("10044".equals(infocode) || "10012".equals(infocode)
+ || "10002".equals(infocode) || "10010".equals(infocode)) {
+ logger.info("[GDKeyManager] 高德key[{}]无Web服务校验权限(infocode={})，按已恢复处理", gdKey, infocode);
+ return true;
+ }
+ // 配额类错误：明确未恢复
+ if ("10001".equals(infocode) || "10003".equals(infocode) || "10019".equals(infocode)) {
+ return false;
+ }
+ // 其他错误（限流/网络等）：保守放行，真实调用失败时会被自动切换机制再次标记
+ return true;
+ } catch (Exception e) {
+ logger.warn("[GDKeyManager] 校验key[{}]配额异常，按已恢复处理", gdKey, e);
+ return true;
+ }
+ }
+}
--
Gitblit v1.7.1