IT技术社区_专业开发者平台_最新编程教程与解决方案 -沐辰社区

Java案例如何实现服务监控？

wen python案例 1

本文目录导读：

Java案例如何实现服务监控？

  1. 方案一：使用 Spring Boot Actuator + Micrometer （最主流、最推荐）
  2. 方案二：纯 JDK 内置工具 （轻量级、无需框架）
  3. 方案三：配合外部监控系统 （生产级完整体系）
  4. 方案四：基于 AOP 实现方法级监控 （扩展案例）
  5. 监控的核心指标清单
  6. 总结选择建议

在Java中实现服务监控,通常有四个核心步骤：数据采集 → 指标暴露 → 数据存储/展示 → 告警。

下面为你介绍从简单到专业的几种实现方案,并提供具体代码案例。

使用 Spring Boot Actuator + Micrometer （最主流、最推荐）

这是Spring Boot项目监控的标准方案，Actuator负责暴露接口，Micrometer负责收集各类指标（内存、CPU、线程、HTTP请求等）。

引入依赖

<!-- Spring Boot Actuator -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!-- Micrometer 核心，Prometheus 注册表 -->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

配置文件 (application.yml)

management:
  endpoints:
    web:
      exposure:
        include: "*"  # 暴露所有端点（生产环境建议缩小范围）
  metrics:
    tags:
      application: ${spring.application.name}  # 添加服务名标签

启动并验证

启动项目后访问 http://localhost:8080/actuator 可看到所有端点列表。

  • 健康检查：/actuator/health
  • 详细指标：/actuator/metrics
  • Prometheus格式：/actuator/prometheus

输出示例（prometheus格式）：

jvm_memory_used_bytes{area="heap",id="G1 Eden Space",} 2.4E7
http_server_requests_seconds_count{method="GET",status="200",uri="/api/users",} 15.0

自定义业务指标 （关键案例）

import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.Timer;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
@Service
public class OrderService {
    private final Counter orderCreatedCounter;
    private final Timer orderCreateTimer;
    // 通过构造器注入 MeterRegistry
    public OrderService(MeterRegistry registry) {
        this.orderCreatedCounter = Counter.builder("orders.created.total")
                .description("总订单创建数")
                .tag("app", "my-service")
                .register(registry);
        this.orderCreateTimer = Timer.builder("orders.create.duration")
                .description("订单创建耗时")
                .publishPercentiles(0.5, 0.95, 0.99) // P50, P95, P99
                .register(registry);
    }
    public void createOrder() {
        Timer.Sample sample = Timer.start(); // 开始计时
        try {
            // 业务逻辑
            orderCreatedCounter.increment(); // 计数+1
        } finally {
            sample.stop(orderCreateTimer); // 记录耗时
        }
    }
}

纯 JDK 内置工具 （轻量级、无需框架）

如果项目不是Spring Boot，可以用JDK自带工具做基础监控。

使用 JMX （Java Management Extensions）

import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.ThreadMXBean;
public class SimpleMonitor {
    private final MemoryMXBean memoryBean;
    private final ThreadMXBean threadBean;
    public SimpleMonitor() {
        this.memoryBean = ManagementFactory.getMemoryMXBean();
        this.threadBean = ManagementFactory.getThreadMXBean();
    }
    public void printMetrics() {
        // 堆内存
        var heap = memoryBean.getHeapMemoryUsage();
        System.out.printf("Heap: used=%d MB, max=%d MB%n", 
                heap.getUsed() / (1024*1024), heap.getMax() / (1024*1024));
        // 活跃线程
        int threadCount = threadBean.getThreadCount();
        System.out.println("Active threads: " + threadCount);
        // 可以定期执行并写入日志或暴露HTTP接口
    }
}

配合简单的 HTTP Server 暴露指标

import com.sun.net.httpserver.HttpServer;
import java.net.InetSocketAddress;
public class PrometheusExporter {
    public static void main(String[] args) throws Exception {
        HttpServer server = HttpServer.create(new InetSocketAddress(8081), 0);
        server.createContext("/metrics", exchange -> {
            String metrics = collectMetricsAsString(); // 自行拼接Prometheus格式
            exchange.sendResponseHeaders(200, metrics.length());
            exchange.getResponseBody().write(metrics.getBytes());
            exchange.close();
        });
        server.start();
    }
    private static String collectMetricsAsString() {
        // 收集内存、线程、GC、自定义指标等
        return "# HELP heap_used 堆内存使用量\nheap_used 256000000\n";
    }
}

配合外部监控系统 （生产级完整体系）

将采集到的指标发送到监控后台,形成可视化和告警。

架构图

flowchart LR
    A[Java应用<br/>Micrometer/Actuator] -->|/actuator/prometheus| B[Prometheus<br/>时间序列数据库]
    B --> C[Grafana<br/>可视化仪表盘]
    B --> D[Alertmanager<br/>告警通知]
    D --> E[钉钉/邮件/短信]

配置示例

  • Prometheus配置文件 (prometheus.yml):

    scrape_configs:
- job_name: 'java-app'
  metrics_path: '/actuator/prometheus'
  static_configs:
    - targets: ['localhost:8080']

  • Grafana：导入 JVM (Micrometer) 官方仪表盘模板 ID：12856。

基于 AOP 实现方法级监控 （扩展案例）

当需要无侵入地监控所有 @RestController 或特定 Service 方法时。

@Aspect
@Component
public class MethodMonitorAspect {
    private final MeterRegistry registry;
    public MethodMonitorAspect(MeterRegistry registry) {
        this.registry = registry;
    }
    @Around("@annotation(org.springframework.web.bind.annotation.GetMapping)") // 拦截所有GET请求
    public Object monitorMethod(ProceedingJoinPoint pjp) throws Throwable {
        String methodName = pjp.getSignature().toShortString();
        // 创建计数器
        Counter.builder("method.calls")
                .tag("method", methodName)
                .register(registry)
                .increment();
        // 计时
        Timer.Sample sample = Timer.start();
        try {
            return pjp.proceed();
        } catch (Exception e) {
            // 记录异常
            Counter.builder("method.errors")
                    .tag("method", methodName)
                    .register(registry)
                    .increment();
            throw e;
        } finally {
            sample.stop(Timer.builder("method.duration")
                    .tag("method", methodName)
                    .register(registry));
        }
    }
}

监控的核心指标清单

分类 具体指标 监控目的
JVM 堆/非堆内存、GC次数/耗时、线程数、类加载数 内存泄漏、GC停顿、死锁
系统 CPU使用率、磁盘IO、网络流量 系统是否过载
应用 QPS、请求耗时P99、错误率、慢SQL 接口性能、故障发现
中间件 连接池活跃数、队列积压、缓存命中率 数据库、MQ、Redis状态

总结选择建议

  • 单体应用快速使用 → 方案一（Spring Boot Actuator + Micrometer）
  • 老旧项目无Spring → 方案二（JDK JMX + 自定义HTTP接口）
  • 完整生产环境 → 方案一 + 集成Prometheus + Grafana + 告警
  • 方法级细粒度监控 → 方案四（AOP）作为补充

代码中使用的核心库（均可从Maven中央仓库获取）：

<!-- Spring Boot 2.x/3.x 均已内置 acturator -->
<!-- Micrometer 核心 -->
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-core</artifactId>
</dependency>

如果需要了解特定中间件（如数据库连接池、Kafka消费者）的监控代码，可以进一步说明。

上一篇指标采集怎么做？

下一篇Java案例如何实现服务自愈？

相关文章

抱歉，评论功能暂时关闭!