Use Micrometer to expose metrics in Java applications. By adding dependencies and configuring Spring Boot Actuator, the application outputs monitoring data in Prometheus format at the /actuator/prometheus endpoint; 2. Configure Prometheus' scrape_configs, add job_name to the 'java-app' crawling task, specify metrics_path and targets to regularly collect Java application metrics, and verify the acquisition status through Prometheus' Targets page; 3. Start Grafana and add Prometheus as the data source, and quickly build a visual monitoring panel for key metrics such as JVM memory, threads, GC, HTTP requests, etc. by importing community templates (such as IDs 4701 and 2588); 4. Register custom business metrics (such as order processing count) through MeterRegistry, query and use Grafana to display business trends, thereby achieving comprehensive monitoring at the system and business level. This solution implements a complete monitoring link from indicator exposure, acquisition and storage to visual display of Java applications, effectively supporting system stability and performance optimization.

Monitoring of Java applications is crucial to ensuring system stability and performance. Prometheus and Grafana are the most popular open source monitoring combinations: Prometheus collects and stores metric data, while Grafana is used for visual display. Using them for Java application monitoring allows you to quickly build a powerful, flexible and scalable monitoring system.

The following are key steps and best practices for implementing Java application monitoring.

1. Expose monitoring metrics in Java applications (using Micrometer Prometheus)

To allow Prometheus to crawl metrics for Java applications, you first need to expose an HTTP interface in the application and return the format that Prometheus is readable (usually /metrics or /actuator/prometheus ).

Micrometer is recommended : It is a de facto standard metric facade in the Java field, supports multiple monitoring systems (including Prometheus), and integrates seamlessly with Spring Boot.

Add dependencies (Maven example):

 <dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-core</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

Configure Spring Boot Actuator (Spring Boot user):

 # application.yml
Management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  metrics:
    tags:
      application: ${spring.application.name}

After starting the application, visit http://localhost:8080/actuator/prometheus and you should see something like:

 # HELP jvm_memory_used_bytes
# TYPE jvm_memory_used_bytes gauge
jvm_memory_used_bytes{area="heap",id="PS Old Gen",} 2.3405672E7
...

This indicates that the indicator has been successfully exposed.

2. Configure Prometheus crawling metrics

Prometheus needs to configure a job to regularly crawl your Java application metrics.

Modify prometheus.yml :

 scrape_configs:
  - job_name: 'java-app'
    metrics_path: '/actuator/prometheus'
    static_configs:
      - targets: ['host.docker.internal:8080'] # If it is a local Docker, or using the actual IP

Note: If the Java application is running in a Docker container, targets should use an address accessible to the Docker network, such as your-service:8080 .

Start Prometheus:

 docker run -d -p 9090:9090 -v $(pwd)/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus

Visit http://localhost:9090 and confirm that your Java application status is "UP" on the "Targets" page.

3. Use Grafana to display the monitoring panel

Grafana is used to connect to Prometheus data sources and display key metrics such as JVM, HTTP requests, and GC through a graphical panel.

Start Grafana:

 docker run -d -p 3000:3000 grafana/grafana

Visit http://localhost:3000 , the default account password is admin/admin .

Add Prometheus data source:

1. Go to Configuration > Data Sources > Add data source
2. Select Prometheus
3. Fill in the URL: http://host.docker.internal:9090 (or the address where the Prometheus container is located)
4. Click Save & Test to confirm that the connection is successful

Importing Java Monitoring Panel

Recommended templates maintained by Grafana official community:

• JVM Micrometer Dashboard (ID: 4701)
• Spring Boot Statistics (ID: 2588)

Import method:

1. Enter Create > Import
2. Enter the panel ID (such as 4701 )
3. Select the Prometheus data source
4. Click Import

You will see the following monitoring information:

• JVM memory usage (heap/non-heap)
• Number of threads
• GC times and time consumption
• HTTP request latency and throughput
• CPU Usage

4. Custom business metrics (optional but recommended)

In addition to system indicators, you can also monitor business logic, such as order processing, cache hit rate, etc.

Example: Record order processing times

 @Autowired
private MeterRegistry registry;

public void processOrder(Order order) {
    Counter counter = registry.counter("orders.processed", "type", order.getType());
    counter.increment();
    // Processing logic...
}

You can query in Prometheus:

 orders_processed_total{type="premium"}

Then add a chart in Grafana to monitor business trends.

Basically that's it. The whole process is not complicated, but very practical:
Java applications expose metrics through Micrometer → Prometheus crawl storage → Grafana visualization.
Once built, you can grasp the health of the application in real time and quickly locate memory leaks, high-latency requests and other issues.

The above is the detailed content of Java Application Monitoring with Prometheus and Grafana. For more information, please follow other related articles on the PHP Chinese website!