@Intercepts({
    @Signature(type = ResultSetHandler.class,
               method = "handleResultSets",
               args = {Statement.class})
})

public class GuardInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 前置處理
        preProcess(invocation);
        
        // 執(zhí)行原方法
        Object result = invocation.proceed();
        
        // 后置處理
        postProcess(invocation, result);
        return result;
    }
}

<plugins>
  <plugin interceptor="com.example.GuardInterceptor">
    <property name="maxBytes" value="20971520"/>
  </plugin>
</plugins>

public class SqlExecutionMetrics {
    // 統(tǒng)一Histogram指標(biāo)
    staticfinal Histogram SQL_QUERY_STATS = Histogram.build()
        .name("sql_query_stats")
        .help("SQL執(zhí)行綜合統(tǒng)計(jì)")
        .labelNames("dao_method", "row_level", "byte_level")
        .buckets(10, 50, 100, 500, 1000, 5000) // 耗時(shí)桶
        .register();
    
    // 行數(shù)等級(jí)映射規(guī)則
    privatestaticfinalint[] ROW_LEVELS = {0, 100, 1000, 10000, 50000};
    
    // 字節(jié)等級(jí)映射規(guī)則 (單位: KB)
    privatestaticfinalint[] BYTE_LEVELS = {0, 100, 1024, 10240, 102400, 1024000};
}

@Slf4j
@Intercepts({
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
        @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class})

})
public class EnhancedMemoryGuardInterceptor implements Interceptor {
   // 雙閾值配置  
   privateint rowWarnThreshold = 3000;
   privateint rowBlockThreshold = 10000;
   privatelong byteWarnThreshold = 5 * 1024 * 1024; // 5MB  
   privatelong byteBlockThreshold = 10 * 1024 * 1024; // 10MB  

   @Override
   public Object intercept(Invocation invocation) throws Throwable {
      long startTime = System.currentTimeMillis();
      // 執(zhí)行原始SQL
      Object result = invocation.proceed();
      long endTime = System.currentTimeMillis();
      try {
         long duration = endTime - startTime;
         String sqlId = getSqlId(invocation);
         // 結(jié)果集行數(shù)
         int rowCount;
         if (result instanceof Collection) {
            rowCount = ((Collection<?>) result).size();
         } else {
            rowCount = result == null ? 0 : 1;
         }

         // 結(jié)果字節(jié)數(shù)
         long byteSize = MemoryMeasurer.measureBytes(result);

         // 等級(jí)映射
         int rowLevel = mapToLevel(rowCount, SqlExecutionMetrics.ROW_LEVELS);
         int byteLevel = mapToLevel(byteSize / 1024, SqlExecutionMetrics.BYTE_LEVELS);

         // Prometheus埋點(diǎn)
         recordMetrics(sqlId, rowLevel, byteLevel, duration);

         // 雙閾值檢測(cè)
         checkRowThresholds(sqlId, rowCount, duration);
         checkByteThresholds(sqlId, byteSize, duration);
      } catch (MemoryGuardException e) {
         throw e;
      } catch (Exception e) {
         log.error("EnhancedMemoryGuardInterceptor unknow error", e);
      }

      return result;
   }

   // 等級(jí)映射算法  
   private int mapToLevel(long value, int[] thresholds) {
      for (int i = 0; i < thresholds.length; i++) {
         if (value <= thresholds[i]) {
            return i;
         }
      }

      return thresholds.length;
   }

   // 行數(shù)閾值檢測(cè)  
   private void checkRowThresholds(String sqlId, int rowCount, long duration) {
      if (rowCount > rowWarnThreshold) {
         String warnMsg = String.format(
                 "[行數(shù)告警] SQL:%s 返回%d行(閾值:%d) 耗時(shí):%dms",
                 sqlId, rowCount, rowWarnThreshold, duration
         );
         // 發(fā)送企微告警
         WeComAlarm.send(warnMsg);

         if (rowCount >= rowBlockThreshold) {
            thrownew MemoryGuardException(warnMsg + "\n[已熔斷] 超過(guò)阻斷閾值:" + rowBlockThreshold);
         }
      }
   }

   // 字節(jié)閾值檢測(cè)  
   private void checkByteThresholds(String sqlId, long byteSize, long duration) {
      if (byteSize > byteWarnThreshold) {
         String warnMsg = String.format(
                 "[字節(jié)告警] SQL:%s 占用%.2fMB(閾值:%dMB) 耗時(shí):%dms",
                 sqlId, byteSize / (1024.0 * 1024.0),
                 byteWarnThreshold / (1024 * 1024), duration
         );
         // 發(fā)送企微告警
         WeComAlarm.send(warnMsg);

         if (byteSize >= byteBlockThreshold) {
            thrownew MemoryGuardException(warnMsg + "\n[已熔斷] 超過(guò)阻斷閾值:" +
                    byteBlockThreshold / (1024 * 1024) + "MB");
         }
      }
   }

   // 記錄Prometheus指標(biāo)  
   private void recordMetrics(String sqlId, int rowLevel, int byteLevel, long duration) {
      SqlExecutionMetrics.SQL_QUERY_STATS.labels(sqlId, String.valueOf(rowLevel), String.valueOf(byteLevel))
                                         .observe(duration);
   }
}

public abstractclass MemoryMeasurer {

    /**
     * 對(duì)象大小計(jì)算器接口
     */
    @FunctionalInterface
    publicinterface SizeCalculator {
        long calculate(Object obj);
    }

    // 類型估算器注冊(cè)表
    privatestaticfinal Map<Class<?>, SizeCalculator> SIZE_CALCULATORS = new ConcurrentHashMap<>();

    static {
        // 注冊(cè)基本類型估算器
        SIZE_CALCULATORS.put(Byte.class, obj -> 1);
        SIZE_CALCULATORS.put(Short.class, obj -> 2);
        SIZE_CALCULATORS.put(Integer.class, obj -> 4);
        SIZE_CALCULATORS.put(Long.class, obj -> 8);
        SIZE_CALCULATORS.put(Float.class, obj -> 4);
        SIZE_CALCULATORS.put(Double.class, obj -> 8);
        SIZE_CALCULATORS.put(Boolean.class, obj -> 1);
        SIZE_CALCULATORS.put(Character.class, obj -> 2);

        // 注冊(cè)常用對(duì)象類型估算器
        SIZE_CALCULATORS.put(String.class, obj ->
                ((String) obj).getBytes(StandardCharsets.UTF_8).length);

        SIZE_CALCULATORS.put(BigDecimal.class, obj ->
                obj.toString().getBytes(StandardCharsets.UTF_8).length);

        // 注冊(cè)日期時(shí)間類型估算器
        SIZE_CALCULATORS.put(Date.class, obj -> 8);
        SIZE_CALCULATORS.put(java.sql.Date.class, obj -> 8);
        SIZE_CALCULATORS.put(java.sql.Time.class, obj -> 8);
        SIZE_CALCULATORS.put(java.sql.Timestamp.class, obj -> 8);
        SIZE_CALCULATORS.put(LocalDate.class, obj -> 6);
        SIZE_CALCULATORS.put(LocalTime.class, obj -> 5);
        SIZE_CALCULATORS.put(LocalDateTime.class, obj -> 12);
        SIZE_CALCULATORS.put(Instant.class, obj -> 12);
        SIZE_CALCULATORS.put(ZonedDateTime.class, obj -> 20);
        SIZE_CALCULATORS.put(OffsetDateTime.class, obj -> 16);

        // 注冊(cè)字節(jié)數(shù)組類型
        SIZE_CALCULATORS.put(byte[].class, obj -> ((byte[]) obj).length);
    }

    /**
     * 估算結(jié)果集大小
     */
    public static long measureBytes(Object result) {
        if (result == null) {
            return0;
        }

        if (result instanceof List) {
            List<?> list = (List<?>) result;
            if (list.isEmpty()) {
                return0;
            }

            // 遍歷所有行進(jìn)行估算
            long totalSize = 0;
            for (Object row : list) {
                totalSize += estimateRowSize(row);
            }
            return totalSize;
        }

        // 單個(gè)對(duì)象結(jié)果
        return estimateRowSize(result);
    }

    /**
     * 估算單行大小
     */
    private static long estimateRowSize(Object row) {
        if (row == null)
            return0;

        long rowSize = 0;

        if (row instanceof Map) {
            // Map類型結(jié)果（如selectMap）
            Map<?, ?> rowMap = (Map<?, ?>) row;
            for (Object value : rowMap.values()) {
                rowSize += estimateValueSize(value);
            }
        } else {
            // 實(shí)體對(duì)象類型
            List<Field> cachedFields = getCachedFields(row.getClass());
            for (Field field : cachedFields) {
                try {
                    field.setAccessible(true);
                    Object value = field.get(row);
                    rowSize += estimateValueSize(value);
                } catch (IllegalAccessException e) {
                    // 忽略無(wú)法訪問(wèn)的字段
                }
            }
        }

        // 加上對(duì)象頭開(kāi)銷（約16字節(jié)）
        return rowSize + 16;
    }

    /**
     * 估算單個(gè)值的大小
     */
    private static long estimateValueSize(Object value) {
        if (value == null) {
            return0;
        }

        Class<?> valueClass = value.getClass();
        // 查找精確匹配的估算器
        SizeCalculator calculator = SIZE_CALCULATORS.get(valueClass);
        if (calculator != null) {
            return calculator.calculate(value);
        }

        // 嘗試父類或接口匹配
        for (Map.Entry<Class<?>, SizeCalculator> entry : SIZE_CALCULATORS.entrySet()) {
            if (entry.getKey().isAssignableFrom(valueClass)) {
                return entry.getValue().calculate(value);
            }
        }

        // 默認(rèn)處理：使用toString的字節(jié)長(zhǎng)度
        return value.toString().getBytes(StandardCharsets.UTF_8).length;
    }

    // 緩存字段反射結(jié)果
    privatestaticfinal Map<Class<?>, List<Field>> FIELD_CACHE = new ConcurrentHashMap<>();

    /**
     * 獲取類的字段映射（包括父類）
     */
    private static List<Field> getCachedFields(Class<?> clazz) {
        return FIELD_CACHE.computeIfAbsent(clazz, k -> {
            List<Field> fields = new ArrayList<>();
            Class<?> current = clazz;
            while (current != Object.class) {
                Collections.addAll(fields, current.getDeclaredFields());
                current = current.getSuperclass();
            }

            return fields;
        });
    }
}

public void adjustLevelThresholds() {
    // 獲取最近7天行數(shù)P95值
    double p95Rows = queryThresholdP95FromPrometheus();
    
    // 調(diào)整行數(shù)等級(jí)閾值
    ROW_LEVELS[3] = (int)(p95Rows * 0.8);  // 降低20%
    ROW_LEVELS[4] = (int)(p95Rows * 1.2);  // 提高20%
    
    // 調(diào)整字節(jié)等級(jí)閾值...
}

// 行數(shù)+字節(jié)雙維度熔斷策略
for (LevelConfig config : levelConfigs) {
   if (byteLevel >= config.byteLevel && rowLevel >= config.rowLevel) {
       blockAndAlert("高危組合: 行數(shù)" + rowCount + " 字節(jié)" + byteSize + "MB");
   }
}

# L3+行數(shù)等級(jí)且L3+字節(jié)數(shù)等級(jí)的查詢
sum by (dao_method) (
rate(sql_query_stats{row_level=~"[3-5]", byte_level=~"[3-5]"}[5m])
        ) > 10