1. import java.io.IOException;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import java.util.Map;
  5. import java.util.HashMap;
  7. public class ApiBatchProcessor {
  9. /**
  10. * Processes a batch of API requests, handling errors and logging them.
  11. * @param apiRequestList A list of API request objects. Each object should have a method to execute the API call.
  12. * @param batchSize The number of requests to process in each batch.
  13. */
  14. public void processBatch(List<ApiRequest> apiRequestList, int batchSize) {
  15. if (apiRequestList == null || apiRequestList.isEmpty()) {
  16. System.out.println("No API requests to process.");
  17. return;
  18. }
  20. int totalRequests = apiRequestList.size();
  21. int numBatches = (int) Math.ceil((double) totalRequests / batchSize);
  23. for (int batchNum = 0; batchNum < numBatches; batchNum++) {
  24. int start = batchNum * batchSize;
  25. int end = Math.min((batchNum + 1) * batchSize, totalRequests);
  26. List<ApiRequest> batch = apiRequestList.subList(start, end);
  28. processBatchInternally(batch);
  29. }
  30. }
  32. private void processBatchInternally(List<ApiRequest> batch) {
  33. for (ApiRequest request : batch) {
  34. try {
  35. Map<String, Object> response = request.execute(); // Execute the API request
  36. //Process response
  37. System.out.println("Request successful: " + request.getMethod() + " - " + request.getUrl());
  38. } catch (Exception e) {
  39. logError("Error processing request: " + request.getMethod() + " - " + request.getUrl(), e.getMessage());
  40. }
  41. }
  42. }
  44. private void logError(String message, Exception e) {
  45. System.err.println("ERROR: " + message);
  46. e.printStackTrace(); // Print the stack trace for detailed debugging
  47. }
  49. /**
  50. * Interface for API request objects.
  51. */
  52. public interface ApiRequest {
  53. String getMethod(); // e.g., "GET", "POST"
  54. String getUrl(); // e.g., "https://example.com/api/data"
  55. Map<String, Object> execute() throws Exception; // Executes the API request and returns the response.
  56. }
  58. public static void main(String[] args) {
  59. //Example Usage
  60. List<ApiRequest> requests = new ArrayList<>();
  61. requests.add(new MyApiRequest("GET", "https://api.example.com/users", new HashMap<>()));
  62. requests.add(new MyApiRequest("POST", "https://api.example.com/products", new HashMap<String, Object>() {{ put("name", "Test Product"); }}));
  63. requests.add(new MyApiRequest("GET", "https://api.example.com/orders", new HashMap<>()));
  64. requests.add(new MyApiRequest("GET", "https://api.example.com/nonexistent", new HashMap<>()));
  66. ApiBatchProcessor processor = new ApiBatchProcessor();
  67. processor.processBatch(requests, 2); // Process in batches of 2
  68. }
  70. static class MyApiRequest implements ApiRequest {
  71. private final String method;
  72. private final String url;
  73. private final Map<String, Object> params;
  75. public MyApiRequest(String method, String url, Map<String, Object> params) {
  76. this.method = method;
  77. this.url = url;
  78. this.params = params;
  79. }
  81. @Override
  82. public String getMethod() {
  83. return method;
  84. }
  86. @Override
  87. public String getUrl() {
  88. return url;
  89. }
  91. @Override
  92. public Map<String, Object> execute() throws Exception {
  93. // Simulate API call and response
  94. if (url.equals("https://api.example.com/nonexistent")) {
  95. throw new Exception("Simulated API error");
  96. }
  97. return new HashMap<>(); // Simulate a successful response
  98. }
  99. }
  100. }

Add your comment