// 獲取內(nèi)存管理MBean
MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
// 獲取堆內(nèi)存使用情況
MemoryUsage heapUsage = memoryMXBean.getHeapMemoryUsage();

內(nèi)存使用率 = (已用內(nèi)存 / 最大內(nèi)存) × 100%

┌─────────────────────────────────────────────────────────────┐
│                     Spring Boot應(yīng)用                          │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌──────────────┐         ┌──────────────┐                  │
│  │   定時任務(wù)   │         │  REST接口    │                  │
│  │ @Scheduled   │         │  手動觸發(fā)    │                  │
│  └──────┬───────┘         └──────┬───────┘                  │
│         │                        │                          │
│         └────────┬───────────────┘                          │
│                  │                                          │
│         ┌────────▼────────┐                                 │
│         │ OomAlertService │  ?── 預(yù)警核心服務(wù)                │
│         └────────┬────────┘                                 │
│                  │                                          │
│         ┌────────▼────────┐                                 │
│         │MemoryMonitor    │  ?── 內(nèi)存數(shù)據(jù)采集                │
│         │Service         │                                 │
│         └────────┬────────┘                                 │
│                  │                                          │
│         ┌────────▼────────┐                                 │
│         │  JVM MBean      │  ?── 底層數(shù)據(jù)源                  │
│         │  (JMX)          │                                 │
│         └─────────────────┘                                 │
│                                                              │
│         預(yù)警通道                                              │
│    ┌─────┴─────┬─────┬─────┐                               │
│    ▼           ▼     ▼     ▼                               │
│  日志        控制臺  郵件  (可擴展)                         │
│                                                              │
└─────────────────────────────────────────────────────────────┘
                         │
                         ▼
              ┌──────────────────┐
              │   Prometheus     │  ?── 企業(yè)級監(jiān)控
              │   + Grafana      │
              └──────────────────┘

package com.example.monitor.service;

import org.springframework.stereotype.Service;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;

/**
 * 內(nèi)存監(jiān)測核心服務(wù)
 * 
 * <p>基于JVM MBean（Management Bean）實現(xiàn)內(nèi)存數(shù)據(jù)采集，
 * 提供堆內(nèi)存、非堆內(nèi)存的使用情況查詢，以及使用率計算。
 * 
 * <p><b>設(shè)計要點：</b>
 * <ul>
 *   <li>單例設(shè)計：MemoryMXBean本身是JVM級單例，無需額外同步</li>
 *   <li>輕量級：采集操作耗時<1ms，對應(yīng)用性能無影響</li>
 *   <li>無狀態(tài)：不保存歷史數(shù)據(jù)，僅提供實時查詢</li>
 * </ul>
 * 
 * @author 技術(shù)團隊
 * @since 1.0
 */
@Service
public class MemoryMonitorService {

    /**
     * JVM內(nèi)存管理MBean
     * 
     * <p>通過ManagementFactory獲取，是JVM提供的標(biāo)準(zhǔn)管理接口。
     * 獲取堆內(nèi)存和非堆內(nèi)存的實時使用數(shù)據(jù)。
     * 
     * <p><b>注意：</b>
     * <ul>
     *   <li>堆內(nèi)存：存儲Java對象實例，是OOM的高發(fā)區(qū)域</li>
     *   <li>非堆內(nèi)存：包括Metaspace（類元數(shù)據(jù)）、CodeCache（編譯代碼）等</li>
     * </ul>
     */
    private static final MemoryMXBean MEMORY_MX_BEAN = ManagementFactory.getMemoryMXBean();

    /**
     * 預(yù)定義的MB字節(jié)數(shù)，用于避免重復(fù)計算
     */
    private static final long BYTES_PER_MB = 1024L * 1024L;

    /**
     * 獲取堆內(nèi)存使用情況
     * 
     * <p><b>堆內(nèi)存：</b>存儲Java對象實例，由GC進(jìn)行垃圾回收。
     * 通過-Xms和-Xmx參數(shù)控制初始大小和最大大小。
     * 
     * @return MemoryUsage對象，包含init、used、committed、max四個指標(biāo)
     */
    public MemoryUsage getHeapMemoryUsage() {
        return MEMORY_MX_BEAN.getHeapMemoryUsage();
    }

    /**
     * 獲取非堆內(nèi)存使用情況
     * 
     * <p><b>非堆內(nèi)存：</b>包括Metaspace（類元數(shù)據(jù)）、CodeCache（JIT編譯后的代碼）等。
     * Metaspace溢出通常由加載類過多或動態(tài)生成類導(dǎo)致。
     * 
     * @return MemoryUsage對象，包含非堆內(nèi)存的使用數(shù)據(jù)
     */
    public MemoryUsage getNonHeapMemoryUsage() {
        return MEMORY_MX_BEAN.getNonHeapMemoryUsage();
    }

    /**
     * 計算堆內(nèi)存使用率（百分比）
     * 
     * <p><b>計算公式：</b>
     * <pre>使用率 = (已用內(nèi)存 / 最大內(nèi)存) × 100%</pre>
     * 
     * <p><b>邊界情況處理：</b>
     * <ul>
     *   <li>當(dāng)max ≤ 0時（JVM未設(shè)置-Xmx），返回0.0避免除零錯誤</li>
     *   <li>返回值保留雙精度浮點數(shù)，便于精確比較</li>
     * </ul>
     * 
     * @return 堆內(nèi)存使用率，范圍[0, 100]
     */
    public double getHeapMemoryUsagePercentage() {
        MemoryUsage usage = getHeapMemoryUsage();
        long max = usage.getMax();
        
        // 邊界處理：JVM未設(shè)置-Xmx時max可能為-1或0
        if (max <= 0) {
            return 0.0;
        }
        
        long used = usage.getUsed();
        return (double) used / max * 100.0;
    }

    /**
     * 判斷是否觸發(fā)OOM預(yù)警
     * 
     * <p>比較當(dāng)前使用率與設(shè)定的閾值，當(dāng)使用率≥閾值時返回true。
     * 
     * @param threshold 閾值（百分比），如85.0表示85%
     * @return true表示存在OOM風(fēng)險，false表示正常
     * @throws IllegalArgumentException 如果threshold不在[0, 100]范圍內(nèi)
     */
    public boolean isOomRisk(double threshold) {
        // 參數(shù)校驗
        if (threshold < 0 || threshold > 100) {
            throw new IllegalArgumentException("閾值必須在[0, 100]范圍內(nèi)，當(dāng)前值: " + threshold);
        }
        
        double usage = getHeapMemoryUsagePercentage();
        return usage >= threshold;
    }

    /**
     * 獲取詳細(xì)的內(nèi)存使用信息（用于日志輸出）
     * 
     * <p>返回格式化的字符串，包含：
     * <ul>
     *   <li>堆內(nèi)存：已用、已提交、最大、使用率</li>
     *   <li>非堆內(nèi)存：已用、已提交</li>
     * </ul>
     * 
     * <p><b>單位轉(zhuǎn)換：</b>所有字節(jié)數(shù)轉(zhuǎn)換為MB，便于閱讀。
     * 
     * @return 格式化的內(nèi)存信息字符串
     */
    public String getMemoryInfo() {
        MemoryUsage heap = getHeapMemoryUsage();
        MemoryUsage nonHeap = getNonHeapMemoryUsage();

        return String.format(
            "堆內(nèi)存 - 已用: %dMB, 已提交: %dMB, 最大: %dMB, 使用率: %.2f%% | " +
            "非堆內(nèi)存 - 已用: %dMB, 已提交: %dMB",
            heap.getUsed() / BYTES_PER_MB,
            heap.getCommitted() / BYTES_PER_MB,
            heap.getMax() / BYTES_PER_MB,
            getHeapMemoryUsagePercentage(),
            nonHeap.getUsed() / BYTES_PER_MB,
            nonHeap.getCommitted() / BYTES_PER_MB
        );
    }
}

package com.example.monitor.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.locks.ReentrantLock;

/**
 * OOM預(yù)警服務(wù)
 * 
 * <p>負(fù)責(zé)定時檢查內(nèi)存狀態(tài)，當(dāng)內(nèi)存使用率超過閾值時觸發(fā)預(yù)警。
 * 支持多渠道通知（日志、控制臺、郵件），并具備冷卻機制避免頻繁報警。
 * 
 * <p><b>核心特性：</b>
 * <ul>
 *   <li>定時檢查：基于Spring @Scheduled實現(xiàn)，默認(rèn)30秒檢查一次</li>
 *   <li>智能冷卻：觸發(fā)預(yù)警后進(jìn)入冷卻期，避免消息轟炸</li>
 *   <li>自動恢復(fù)：內(nèi)存使用率下降后自動退出冷卻狀態(tài)</li>
 *   <li>多渠道通知：日志ERROR級別 + 控制臺高亮 + 郵件通知</li>
 * </ul>
 * 
 * @author 技術(shù)團隊
 * @since 1.0
 */
@Service
@ConditionalOnProperty(name = "monitor.oom.enabled", havingValue = "true", matchIfMissing = true)
public class OomAlertService {

    private static final Logger logger = LoggerFactory.getLogger(OomAlertService.class);
    
    /**
     * 預(yù)編譯的日期時間格式化器，避免重復(fù)創(chuàng)建對象
     */
    private static final DateTimeFormatter DATE_TIME_FORMATTER = 
        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    
    /**
     * 退出冷卻狀態(tài)的緩沖區(qū)，避免在閾值附近頻繁切換
     */
    private static final double COOLDOWN_EXIT_BUFFER = 5.0;
    
    // ==================== 配置參數(shù) ====================
    
    /**
     * OOM預(yù)警閾值（百分比）
     * 
     * <p>當(dāng)堆內(nèi)存使用率達(dá)到此值時觸發(fā)預(yù)警。
     * 推薦值：開發(fā)環(huán)境90%，測試環(huán)境85%，生產(chǎn)環(huán)境80%。
     */
    @Value("${monitor.oom.threshold:85.0}")
    private double oomThreshold;
    
    /**
     * 內(nèi)存檢查間隔（毫秒）
     * 
     * <p>定時任務(wù)的執(zhí)行頻率，默認(rèn)30秒一次。
     * 生產(chǎn)環(huán)境建議30-60秒，過于頻繁會增加系統(tǒng)開銷。
     */
    @Value("${monitor.oom.check-interval:30000}")
    private long checkInterval;
    
    /**
     * 預(yù)警冷卻時間（毫秒）
     * 
     * <p>觸發(fā)一次預(yù)警后，在冷卻期內(nèi)不再觸發(fā)新的預(yù)警。
     * 默認(rèn)5分鐘，避免同一問題頻繁報警。
     */
    @Value("${monitor.oom.cooldown-time:300000}")
    private long cooldownTime;
    
    /**
     * 是否啟用預(yù)警功能
     */
    @Value("${monitor.oom.alert-enabled:true}")
    private boolean alertEnabled;
    
    /**
     * 是否啟用郵件通知
     */
    @Value("${spring.mail.enabled:false}")
    private boolean mailEnabled;
    
    /**
     * 預(yù)警郵件接收人
     */
    @Value("${monitor.oom.alert-to:admin@example.com}")
    private String alertTo;
    
    // ==================== 依賴注入 ====================
    
    private final MemoryMonitorService memoryMonitorService;
    
    /**
     * 郵件發(fā)送器（延遲注入）
     */
    @org.springframework.context.annotation.Lazy
    private JavaMailSender mailSender;
    
    // ==================== 狀態(tài)管理 ====================
    
    /**
     * 上次觸發(fā)預(yù)警的時間戳
     */
    private volatile long lastAlertTime = 0;
    
    /**
     * 是否處于冷卻狀態(tài)
     */
    private volatile boolean isInCooldown = false;
    
    /**
     * 可重入鎖，用于保證冷卻狀態(tài)的原子性切換
     */
    private final ReentrantLock cooldownLock = new ReentrantLock();

    public OomAlertService(MemoryMonitorService memoryMonitorService) {
        this.memoryMonitorService = memoryMonitorService;
    }

    @PostConstruct
    public void init() {
        validateConfig();
        logger.info("OOM監(jiān)控初始化 - 閾值: {}%, 檢查間隔: {}ms, 冷卻時間: {}ms, 預(yù)警啟用: {}, 郵件啟用: {}",
            oomThreshold, checkInterval, cooldownTime, alertEnabled, mailEnabled);
    }

    /**
     * 配置參數(shù)校驗
     */
    private void validateConfig() {
        if (oomThreshold < 0 || oomThreshold > 100) {
            throw new IllegalArgumentException(
                String.format("閾值必須在[0, 100]范圍內(nèi)，當(dāng)前值: %.2f", oomThreshold));
        }
        if (checkInterval <= 0) {
            throw new IllegalArgumentException(
                String.format("檢查間隔必須大于0，當(dāng)前值: %d", checkInterval));
        }
        if (cooldownTime <= 0) {
            throw new IllegalArgumentException(
                String.format("冷卻時間必須大于0，當(dāng)前值: %d", cooldownTime));
        }
    }

    /**
     * 定時檢查內(nèi)存狀態(tài)
     */
    @Scheduled(fixedRateString = "${monitor.oom.check-interval:30000}")
    public void checkMemoryStatus() {
        if (!alertEnabled) {
            return;
        }

        double currentUsage = memoryMonitorService.getHeapMemoryUsagePercentage();
        
        if (logger.isDebugEnabled()) {
            logger.debug("當(dāng)前內(nèi)存使用率: {:.2f}%, 閾值: {}%", currentUsage, oomThreshold);
        }

        // 檢查是否觸發(fā)預(yù)警
        if (memoryMonitorService.isOomRisk(oomThreshold)) {
            handleOomAlert(currentUsage);
        } else if (isInCooldown) {
            // 內(nèi)存使用率低于閾值，檢查是否退出冷卻狀態(tài)
            checkCooldownExit(currentUsage);
        }
    }

    /**
     * 檢查是否可以退出冷卻狀態(tài)
     */
    private void checkCooldownExit(double currentUsage) {
        if (currentUsage < oomThreshold - COOLDOWN_EXIT_BUFFER) {
            cooldownLock.lock();
            try {
                // 雙重檢查：避免并發(fā)修改
                if (isInCooldown && currentUsage < oomThreshold - COOLDOWN_EXIT_BUFFER) {
                    isInCooldown = false;
                    logger.info("內(nèi)存使用率已恢復(fù)正常（{:.2f}%），退出預(yù)警冷卻狀態(tài)", currentUsage);
                }
            } finally {
                cooldownLock.unlock();
            }
        }
    }

    /**
     * 處理OOM預(yù)警
     */
    private void handleOomAlert(double currentUsage) {
        long currentTime = System.currentTimeMillis();
        
        // 檢查是否在冷卻期
        if (isInCooldown) {
            if (currentTime - lastAlertTime >= cooldownTime) {
                cooldownLock.lock();
                try {
                    // 雙重檢查
                    if (isInCooldown && currentTime - lastAlertTime >= cooldownTime) {
                        sendAlert(currentUsage, currentTime);
                    } else {
                        logger.warn("OOM預(yù)警處于冷卻期，跳過本次通知");
                    }
                } finally {
                    cooldownLock.unlock();
                }
            } else {
                logger.debug("OOM預(yù)警處于冷卻期，剩余時間: {}ms", 
                    cooldownTime - (currentTime - lastAlertTime));
            }
        } else {
            sendAlert(currentUsage, currentTime);
        }
    }

    /**
     * 發(fā)送預(yù)警
     */
    private void sendAlert(double currentUsage, long currentTime) {
        // 設(shè)置冷卻狀態(tài)
        isInCooldown = true;
        lastAlertTime = currentTime;
        
        // 構(gòu)建預(yù)警消息
        String alertMessage = buildAlertMessage(currentUsage);
        
        // 多渠道預(yù)警
        if (logger.isErrorEnabled()) {
            logger.error("{}", alertMessage);
        }
        consoleAlert(alertMessage);
        
        if (mailEnabled) {
            sendEmailAlertAsync(alertMessage);
        }
    }

    /**
     * 構(gòu)建預(yù)警消息
     */
    private String buildAlertMessage(double currentUsage) {
        String timestamp = LocalDateTime.now().format(DATE_TIME_FORMATTER);
        
        return String.format(
            "【OOM預(yù)警】%s\n" +
            "===========================\n" +
            "??  內(nèi)存使用率過高！\n" +
            "===========================\n" +
            "當(dāng)前使用率: %.2f%%\n" +
            "預(yù)警閾值: %.2f%%\n" +
            "內(nèi)存詳情: %s\n" +
            "===========================\n" +
            "建議立即檢查應(yīng)用狀態(tài)！\n",
            timestamp,
            currentUsage,
            oomThreshold,
            memoryMonitorService.getMemoryInfo()
        );
    }

    /**
     * 控制臺預(yù)警（開發(fā)環(huán)境快速響應(yīng)）
     */
    private void consoleAlert(String message) {
        System.err.println("\n========================================");
        System.err.println(message);
        System.err.println("========================================\n");
    }

    /**
     * 異步發(fā)送郵件預(yù)警
     */
    private void sendEmailAlertAsync(final String message) {
        Thread emailThread = new Thread(() -> {
            try {
                if (mailSender == null) {
                    logger.warn("郵件發(fā)送器未初始化，跳過郵件通知");
                    return;
                }
                
                SimpleMailMessage mailMessage = new SimpleMailMessage();
                mailMessage.setTo(alertTo);
                mailMessage.setSubject("【緊急】Spring Boot應(yīng)用OOM預(yù)警");
                mailMessage.setText(message);
                
                mailSender.send(mailMessage);
                logger.info("OOM預(yù)警郵件已發(fā)送至: {}", alertTo);
            } catch (Exception e) {
                logger.error("發(fā)送OOM預(yù)警郵件失敗", e);
            }
        }, "oom-alert-email-sender");
        
        emailThread.setDaemon(true);
        emailThread.start();
    }

    /**
     * 手動觸發(fā)一次內(nèi)存檢查（用于測試）
     */
    public void manualCheck() {
        logger.info("手動觸發(fā)內(nèi)存檢查");
        checkMemoryStatus();
    }

    /**
     * 重置冷卻狀態(tài)（用于測試或緊急情況）
     */
    public void resetCooldown() {
        cooldownLock.lock();
        try {
            isInCooldown = false;
            lastAlertTime = 0;
            logger.info("冷卻狀態(tài)已重置");
        } finally {
            cooldownLock.unlock();
        }
    }

    /**
     * 獲取當(dāng)前冷卻狀態(tài)（用于監(jiān)控）
     */
    public boolean isInCooldown() {
        return isInCooldown;
    }

    /**
     * 獲取剩余冷卻時間（用于監(jiān)控）
     */
    public long getRemainingCooldownTime() {
        if (!isInCooldown) {
            return 0;
        }
        long elapsed = System.currentTimeMillis() - lastAlertTime;
        return Math.max(0, cooldownTime - elapsed);
    }
}

package com.example.monitor.config;

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;

/**
 * 監(jiān)控配置類
 * 
 * <p>負(fù)責(zé)啟用定時任務(wù)，支持通過配置控制監(jiān)控功能的開關(guān)。
 * 
 * @author 技術(shù)團隊
 * @since 1.0
 */
@Configuration
@EnableScheduling
@ConditionalOnProperty(
    name = "monitor.oom.enabled", 
    havingValue = "true", 
    matchIfMissing = true
)
public class MonitorConfig {
    // 配置類，啟用定時任務(wù)
}

package com.example.monitor.controller;

import com.example.monitor.service.MemoryMonitorService;
import com.example.monitor.service.OomAlertService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

/**
 * OOM監(jiān)控接口
 * 
 * <p>提供RESTful API，支持手動觸發(fā)檢查和實時查詢內(nèi)存使用情況。
 * 
 * @author 技術(shù)團隊
 * @since 1.0
 */
@RestController
@RequestMapping("/api/monitor")
@Tag(name = "OOM監(jiān)控", description = "內(nèi)存監(jiān)控與預(yù)警接口")
@ConditionalOnProperty(name = "monitor.oom.enabled", havingValue = "true", matchIfMissing = true)
public class OomMonitorController {

    @Autowired
    private MemoryMonitorService memoryMonitorService;

    @Autowired
    private OomAlertService oomAlertService;

    /**
     * 獲取當(dāng)前內(nèi)存使用情況
     */
    @GetMapping("/memory")
    @Operation(summary = "獲取內(nèi)存使用情況", description = "返回詳細(xì)的堆內(nèi)存和非堆內(nèi)存信息")
    public ResponseEntity<Map<String, Object>> getMemoryStatus() {
        Map<String, Object> result = new HashMap<>();
        
        Map<String, Object> heap = new HashMap<>();
        heap.put("used", memoryMonitorService.getHeapMemoryUsage().getUsed() / (1024L * 1024L));
        heap.put("committed", memoryMonitorService.getHeapMemoryUsage().getCommitted() / (1024L * 1024L));
        heap.put("max", memoryMonitorService.getHeapMemoryUsage().getMax() / (1024L * 1024L));
        heap.put("usageRate", memoryMonitorService.getHeapMemoryUsagePercentage());
        
        Map<String, Object> nonHeap = new HashMap<>();
        nonHeap.put("used", memoryMonitorService.getNonHeapMemoryUsage().getUsed() / (1024L * 1024L));
        nonHeap.put("committed", memoryMonitorService.getNonHeapMemoryUsage().getCommitted() / (1024L * 1024L));
        
        result.put("heap", heap);
        result.put("nonHeap", nonHeap);
        
        return ResponseEntity.ok(result);
    }

    /**
     * 獲取內(nèi)存使用率
     */
    @GetMapping("/memory/usage")
    @Operation(summary = "獲取內(nèi)存使用率", description = "返回堆內(nèi)存使用率百分比")
    public ResponseEntity<Map<String, Object>> getMemoryUsage() {
        double usage = memoryMonitorService.getHeapMemoryUsagePercentage();
        double roundedUsage = Math.round(usage * 100) / 100.0;
        
        Map<String, Object> result = new HashMap<>();
        result.put("usageRate", roundedUsage);
        result.put("status", getMemoryStatus(roundedUsage));
        
        return ResponseEntity.ok(result);
    }

    /**
     * 手動觸發(fā)一次內(nèi)存檢查
     */
    @GetMapping("/check")
    @Operation(summary = "手動觸發(fā)內(nèi)存檢查", description = "立即執(zhí)行一次內(nèi)存檢查并觸發(fā)預(yù)警（如需要）")
    public ResponseEntity<Map<String, Object>> manualCheck() {
        oomAlertService.manualCheck();
        
        Map<String, Object> result = new HashMap<>();
        result.put("message", "內(nèi)存檢查已觸發(fā)，請查看日志輸出");
        result.put("timestamp", System.currentTimeMillis());
        
        return ResponseEntity.ok(result);
    }

    /**
     * 獲取冷卻狀態(tài)
     */
    @GetMapping("/cooldown")
    @Operation(summary = "獲取冷卻狀態(tài)", description = "返回預(yù)警冷卻狀態(tài)和剩余冷卻時間")
    public ResponseEntity<Map<String, Object>> getCooldownStatus() {
        Map<String, Object> result = new HashMap<>();
        result.put("isInCooldown", oomAlertService.isInCooldown());
        result.put("remainingTime", oomAlertService.getRemainingCooldownTime());
        
        return ResponseEntity.ok(result);
    }

    /**
     * 重置冷卻狀態(tài)
     */
    @GetMapping("/cooldown/reset")
    @Operation(summary = "重置冷卻狀態(tài)", description = "強制重置預(yù)警冷卻狀態(tài)")
    public ResponseEntity<Map<String, Object>> resetCooldown() {
        oomAlertService.resetCooldown();
        
        Map<String, Object> result = new HashMap<>();
        result.put("message", "冷卻狀態(tài)已重置");
        result.put("timestamp", System.currentTimeMillis());
        
        return ResponseEntity.ok(result);
    }

    private String getMemoryStatus(double usageRate) {
        if (usageRate >= 90) {
            return "CRITICAL";
        } else if (usageRate >= 80) {
            return "WARNING";
        } else if (usageRate >= 60) {
            return "NORMAL";
        } else {
            return "GOOD";
        }
    }
}

<dependencies>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Actuator（必須） -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <!-- Mail（可選，用于郵件預(yù)警） -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-mail</artifactId>
        <optional>true</optional>
    </dependency>
    <!-- Swagger（可選，用于API文檔） -->
    <dependency>
        <groupId>org.springdoc</groupId>
        <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
        <version>2.0.2</version>
    </dependency>
</dependencies>

server:
  port: 8080
spring:
  application:
    name: oom-monitor-demo
  # ==================== 郵件配置 ====================
  mail:
    # 是否啟用郵件預(yù)警（總開關(guān)）
    enabled: false
    # SMTP服務(wù)器配置
    host: smtp.example.com
    port: 587
    username: your-email@example.com
    password: your-password
    # SMTP協(xié)議配置
    properties:
      mail:
        smtp:
          auth: true
          starttls:
            enabled: true
          connectiontimeout: 5000
          timeout: 10000
          writetimeout: 10000
# ==================== OOM監(jiān)控配置 ====================
monitor:
  oom:
    # 是否啟用OOM監(jiān)控（總開關(guān)）
    enabled: true
    # 內(nèi)存使用率閾值（百分比），超過此值觸發(fā)預(yù)警
    # 推薦值：開發(fā)環(huán)境90%、測試環(huán)境85%、生產(chǎn)環(huán)境80%
    threshold: 85.0
    # 內(nèi)存檢查間隔（毫秒），默認(rèn)30秒
    # 生產(chǎn)環(huán)境建議30-60秒
    check-interval: 30000
    # 預(yù)警冷卻時間（毫秒），防止頻繁預(yù)警
    # 默認(rèn)5分鐘，可根據(jù)實際情況調(diào)整
    cooldown-time: 300000
    # 是否啟用預(yù)警通知
    alert-enabled: true
    # 預(yù)警郵件接收人（多個用逗號分隔）
    alert-to: admin@example.com,ops@example.com
# ==================== Spring Task調(diào)度配置 ====================
spring:
  task:
    scheduling:
      # 調(diào)度線程池大小
      pool:
        size: 1
      # 線程名稱前綴
      thread-name-prefix: oom-monitor-
      # 是否等待任務(wù)執(zhí)行完成后再關(guān)閉應(yīng)用
      shutdown:
        await-termination: true
        await-termination-period: 60s
# ==================== Actuator配置 ====================
# 用于Prometheus集成
management:
  endpoints:
    web:
      # 暴露的端點列表
      exposure:
        include: health,info,metrics,prometheus
      # Actuator基礎(chǔ)路徑
      base-path: /actuator
  endpoint:
    health:
      # 健康檢查詳情展示級別
      show-details: when-authorized
      # 顯示組件詳情
      show-components: always
  metrics:
    export:
      prometheus:
        # 是否啟用Prometheus指標(biāo)導(dǎo)出
        enabled: true
    # 指標(biāo)標(biāo)簽
    tags:
      application: ${spring.application.name}
      environment: ${spring.profiles.active:default}
# ==================== 日志配置 ====================
logging:
  level:
    root: INFO
    # 監(jiān)控相關(guān)日志級別
    com.example.monitor: INFO
  pattern:
    # 控制臺日志格式
    console: "%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"
  # 日志文件配置（可選）
  file:
    name: logs/oom-monitor.log
    max-size: 10MB
    max-history: 7
    total-size-cap: 100MB

java -jar app.jar \
  # 堆內(nèi)存配置
  -Xms512m \
  -Xmx1024m \
  -Xmn256m \
  # OOM時的自動Dump
  -XX:+HeapDumpOnOutOfMemoryError \
  -XX:HeapDumpPath=/logs/heapdump.hprof \
  # GC日志
  -XX:+PrintGCDetails \
  -XX:+PrintGCDateStamps \
  -Xloggc:/logs/gc.log \
  # Metaspace配置（防止類加載溢出）
  -XX:MetaspaceSize=128m \
  -XX:MaxMetaspaceSize=256m \
  # 性能優(yōu)化
  -XX:+UseG1GC \
  -XX:MaxGCPauseMillis=200

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  metrics:
    export:
      prometheus:
        enabled: true
    tags:
      application: ${spring.application.name}

global:
  scrape_interval: 15s
  evaluation_interval: 15s
scrape_configs:
  - job_name: 'spring-boot-oom-monitor'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['localhost:8080']
        labels:
          application: 'oom-monitor-demo'
          environment: 'production'
# 引用告警規(guī)則文件
rule_files:
  - 'prometheus_alert_rules.yml'

groups:
  - name: oom_alerts
    interval: 30s
    rules:
      # 堆內(nèi)存使用率過高預(yù)警（警告級別）
      - alert: HighHeapMemoryUsage
        expr: |
          (
            jvm_memory_used_bytes{area="heap"} / 
            jvm_memory_max_bytes{area="heap"}
          ) * 100 > 85
        for: 2m
        labels:
          severity: warning
          team: ops
        annotations:
          summary: "JVM堆內(nèi)存使用率過高"
          description: "{{ $labels.instance }} 應(yīng)用 {{ $labels.application }} 堆內(nèi)存使用率達(dá)到 {{ $value | humanizePercentage }}，請及時排查"
      # 堆內(nèi)存使用率嚴(yán)重預(yù)警（嚴(yán)重級別）
      - alert: CriticalHeapMemoryUsage
        expr: |
          (
            jvm_memory_used_bytes{area="heap"} / 
            jvm_memory_max_bytes{area="heap"}
          ) * 100 > 95
        for: 1m
        labels:
          severity: critical
          team: ops
        annotations:
          summary: "JVM堆內(nèi)存使用率嚴(yán)重過高！"
          description: "{{ $labels.instance }} 應(yīng)用 {{ $labels.application }} 堆內(nèi)存使用率達(dá)到 {{ $value | humanizePercentage }}，即將發(fā)生OOM，請立即處理！"
      # 非堆內(nèi)存使用率過高
      - alert: HighNonHeapMemoryUsage
        expr: |
          (
            jvm_memory_used_bytes{area="nonheap"} / 
            jvm_memory_max_bytes{area="nonheap"}
          ) * 100 > 90
        for: 5m
        labels:
          severity: warning
          team: ops
        annotations:
          summary: "JVM非堆內(nèi)存使用率過高"
          description: "{{ $labels.instance }} 應(yīng)用 {{ $labels.application }} 非堆內(nèi)存使用率達(dá)到 {{ $value | humanizePercentage }}，可能存在Metaspace溢出風(fēng)險"
      # GC頻率過高預(yù)警
      - alert: HighGcFrequency
        expr: |
          rate(jvm_gc_pause_seconds_count[5m]) > 10
        for: 5m
        labels:
          severity: warning
          team: ops
        annotations:
          summary: "GC頻率過高"
          description: "{{ $labels.instance }} 應(yīng)用 {{ $labels.application }} 最近5分鐘GC頻率達(dá)到 {{ $value }}/秒，可能存在內(nèi)存泄漏"
      # GC耗時過長預(yù)警
      - alert: LongGcPause
        expr: |
          rate(jvm_gc_pause_seconds_sum[5m]) / rate(jvm_gc_pause_seconds_count[5m]) > 0.5
        for: 5m
        labels:
          severity: warning
          team: ops
        annotations:
          summary: "GC平均耗時過長"
          description: "{{ $labels.instance }} 應(yīng)用 {{ $labels.application }} 最近5分鐘GC平均耗時達(dá)到 {{ $value }}秒，嚴(yán)重影響應(yīng)用性能"
      # Full GC頻繁預(yù)警
      - alert: FrequentFullGc
        expr: |
          increase(jvm_gc_pause_seconds_count{action="end of major GC"}[10m]) > 3
        for: 2m
        labels:
          severity: warning
          team: ops
        annotations:
          summary: "Full GC頻繁發(fā)生"
          description: "{{ $labels.instance }} 應(yīng)用 {{ $labels.application }} 最近10分鐘發(fā)生了 {{ $value }} 次Full GC，可能存在內(nèi)存泄漏或堆內(nèi)存不足"

management:
  endpoints:
    web:
      exposure:
        # 只暴露必要的端點
        include: health,metrics,prometheus
  endpoint:
    health:
      show-details: when-authorized  # 只對授權(quán)用戶顯示詳情