Absolutely! You don’t have to reinvent the wheel here—there are several robust Java and Spring-focused libraries that wrap Prometheus’ REST API, making it way easier to fetch metrics without building everything from scratch. Below are the most popular and reliable options:

1. Official Prometheus Java HTTP Client #

This is the official, maintained client from the Prometheus team, designed specifically to interact with Prometheus' API endpoints. It handles all the heavy lifting: HTTP requests, JSON parsing, and error handling for endpoints like instant queries, range queries, and metadata lookups.

Setup & Example #

Add the Maven dependency first:

<dependency>
    <groupId>io.prometheus</groupId>
    <artifactId>prometheus-http-client</artifactId>
    <version>0.16.0</version> <!-- Always check for the latest stable version -->
</dependency>

Then use it in your code:

import io.prometheus.client.http.PrometheusHttpClient;
import io.prometheus.client.http.QueryResponse;
import java.net.URI;

public class PrometheusQueryDemo {
    public static void main(String[] args) throws Exception {
        // Initialize the client with your Prometheus instance URL
        try (PrometheusHttpClient client = PrometheusHttpClient.builder()
                .baseUrl(URI.create("http://your-prometheus-host:9090"))
                .build()) {
            
            // Run an instant query to check if targets are up
            QueryResponse response = client.query("up", System.currentTimeMillis() / 1000);
            
            // Process the results
            response.getData().getResult().forEach(result -> 
                System.out.printf("Instance %s is %s%n", 
                    result.getMetric().get("instance"), 
                    result.getValue().get(1))
            );
        }
    }
}

2. Micrometer Prometheus Query Client (For Spring Boot) #

If you’re already using Spring Boot with Micrometer (the de facto standard for metrics in Spring), you can leverage Micrometer’s built-in Prometheus query support. It integrates seamlessly with your existing Spring context and feels native to the ecosystem.

Setup & Example #

Add the Micrometer-Prometheus dependency to your Spring Boot project:

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
    <!-- Version is managed automatically if using Spring Boot starters -->
</dependency>

Configure the client as a Spring bean:

import io.micrometer.prometheus.PrometheusQueryClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.net.URI;

@Configuration
public class PrometheusConfig {
    @Bean
    public PrometheusQueryClient prometheusQueryClient() {
        return new PrometheusQueryClient(URI.create("http://your-prometheus-host:9090"));
    }
}

Use it in a service class:

import io.micrometer.prometheus.PrometheusQueryClient;
import org.springframework.stereotype.Service;

@Service
public class MetricFetchService {
    private final PrometheusQueryClient queryClient;

    // Constructor injection (preferred in Spring)
    public MetricFetchService(PrometheusQueryClient queryClient) {
        this.queryClient = queryClient;
    }

    public void fetchServiceLatencyMetrics() {
        try {
            // Run a range query to get latency data over the last 5 minutes
            var rangeResult = queryClient.rangeQuery(
                "rate(http_request_duration_seconds_sum[5m])",
                System.currentTimeMillis() / 1000 - 300, // Start time (5 mins ago)
                System.currentTimeMillis() / 1000,     // End time (now)
                15                                      // Step interval (15s)
            );

            // Process the time-series data
            rangeResult.getData().getResult().forEach(series -> 
                System.out.printf("Endpoint %s has average latency: %s%n",
                    series.getMetric().get("endpoint"),
                    series.getValues().get(series.getValues().size() - 1).get(1))
            );
        } catch (Exception e) {
            // Handle errors like connection issues or invalid queries
            e.printStackTrace();
        }
    }
}

3. Third-Party PromQL Client (Type-Safe Query Building) #

If you want to avoid writing raw PromQL strings and prefer type-safe query construction, libraries like promql-client are great. They let you build queries using fluent methods, reducing typos and making complex queries easier to maintain.

Setup & Example #

Add the Maven dependency:

<dependency>
    <groupId>com.github.mindjet</groupId>
    <artifactId>promql-client</artifactId>
    <version>1.0.3</version>
</dependency>

Build and execute a query:

import com.mindjet.promql.PromQL;
import com.mindjet.promql.model.QueryResult;
import com.mindjet.promql.PrometheusClient;

public class SafePromQLExample {
    public static void main(String[] args) {
        PrometheusClient client = new PrometheusClient("http://your-prometheus-host:9090");
        
        // Build a type-safe query to filter up metrics for a specific job
        String promql = PromQL.builder()
                .metric("up")
                .label("job", "spring-boot-app")
                .build();
        
        QueryResult result = client.query(promql, System.currentTimeMillis() / 1000);
        
        // Process results as needed
        result.getData().getResult().forEach(item -> 
            System.out.println("Instance status: " + item.getValue().get(1))
        );
    }
}

Final Notes #

All these libraries eliminate the need to manually handle HTTP requests, JSON serialization/deserialization, and edge cases like time formatting for Prometheus. Choose based on your stack:

• Go with the official client for pure Java projects or if you want strict alignment with Prometheus' API.
• Use Micrometer if you’re already in the Spring Boot ecosystem—it’s the most integrated option.
• Pick the third-party PromQL client if type-safe query building is a priority.

内容的提问来源于stack exchange，提问作者dev123