1. import java.io.IOException;
  2. import java.net.URI;
  3. import java.net.http.HttpClient;
  4. import java.net.http.HttpRequest;
  5. import java.net.http.HttpResponse;
  6. import java.time.Duration;
  7. import java.util.HashMap;
  8. import java.util.Map;
  9. import java.util.concurrent.ConcurrentHashMap;
  10. import java.util.concurrent.Executors;
  11. import java.util.concurrent.ScheduledExecutorService;
  12. import java.util.concurrent.TimeUnit;
  14. public class ApiMetadataAttacher {
  16. private static final int METADATA_CHECK_INTERVAL = 60; // seconds
  17. private static final ConcurrentHashMap<String, Metadata> apiMetadataCache = new ConcurrentHashMap<>();
  18. private static final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
  20. static {
  21. scheduler.scheduleAtFixedRate(this::checkApiMetadata, 0, METADATA_CHECK_INTERVAL, TimeUnit.SECONDS);
  22. }
  25. public static void attachMetadata(String apiUrl) {
  26. // Validate API URL
  27. URI uri = URI.create(apiUrl);
  28. if (!uri.isAbsolute()) {
  29. throw new IllegalArgumentException("API URL must be absolute.");
  30. }
  32. // Create an HTTP request
  33. HttpRequest request = HttpRequest.newBuilder()
  34. .method("GET")
  35. .uri(uri)
  36. .build();
  38. // Use HttpClient to make the request
  39. HttpClient client = HttpClient.newHttpClient();
  40. try {
  41. HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
  43. if (response.statusCode() >= 200 && response.statusCode() < 300) {
  44. // Process the response body to extract metadata
  45. Metadata metadata = extractMetadata(response.body());
  46. apiMetadataCache.put(apiUrl, metadata);
  47. System.out.println("Metadata attached for: " + apiUrl);
  48. } else {
  49. System.err.println("API request failed for: " + apiUrl + " - Status Code: " + response.statusCode());
  50. }
  51. } catch (IOException e) {
  52. System.err.println("IOException while fetching metadata for: " + apiUrl + ": " + e.getMessage());
  53. } catch (InterruptedException e) {
  54. Thread.currentThread().interrupt();
  55. } catch (HttpResponseException e) {
  56. System.err.println("HttpResponseException while fetching metadata for: " + apiUrl + ": " + e.getMessage());
  57. }
  58. }
  62. private static Metadata extractMetadata(String responseBody) {
  63. // Implement your metadata extraction logic here.
  64. // This is a placeholder. Replace with your API's metadata format.
  65. Metadata metadata = new Metadata();
  66. metadata.lastUpdated = System.currentTimeMillis();
  67. metadata.statusCode = -1; // Placeholder. Implement actual parsing.
  68. metadata.headers = new HashMap<>(); //Placeholder. Implement actual parsing.
  69. return metadata;
  70. }
  73. public static Metadata getMetadata(String apiUrl) {
  74. return apiMetadataCache.get(apiUrl);
  75. }
  77. private static void checkApiMetadata() {
  78. // Periodically check and update metadata for all known APIs.
  79. for (Map.Entry<String, Metadata> entry : apiMetadataCache.entrySet()) {
  80. String apiUrl = entry.getKey();
  81. Metadata metadata = entry.getValue();
  83. try {
  84. // Re-fetch metadata. This can catch changes.
  85. attachMetadata(apiUrl);
  86. } catch (Exception e) {
  87. System.err.println("Error checking metadata for " + apiUrl + ": " + e.getMessage());
  88. }
  89. }
  90. }
  92. // Simple Metadata class
  93. public static class Metadata {
  94. public long lastUpdated;
  95. public int statusCode;
  96. public Map<String, String> headers;
  97. }
  99. public static void main(String[] args) throws InterruptedException {
  100. // Example Usage
  101. attachMetadata("https://api.example.com/data");
  102. attachMetadata("https://api.example.com/users");
  103. // ... more APIs
  104. Thread.sleep(10000); //Keep the program running for a while.
  105. }
  106. }

Add your comment