AWS API Gateway: Complete Guide with Load Balancer Comparison, Microservices Architecture, and Java Implementation

 1<dependencies>
 2    <!-- AWS SDK for API Gateway -->
 3    <dependency>
 4        <groupId>software.amazon.awssdk</groupId>
 5        <artifactId>apigateway</artifactId>
 6        <version>2.21.29</version>
 7    </dependency>
 8
 9    <!-- AWS SDK for Lambda (for backend integration) -->
10    <dependency>
11        <groupId>software.amazon.awssdk</groupId>
12        <artifactId>lambda</artifactId>
13        <version>2.21.29</version>
14    </dependency>
15
16    <!-- Spring Boot for API development -->
17    <dependency>
18        <groupId>org.springframework.boot</groupId>
19        <artifactId>spring-boot-starter-web</artifactId>
20    </dependency>
21
22    <!-- Spring Cloud AWS -->
23    <dependency>
24        <groupId>io.awspring.cloud</groupId>
25        <artifactId>spring-cloud-starter-aws</artifactId>
26        <version>2.4.4</version>
27    </dependency>
28
29    <!-- For API Gateway custom authorizers -->
30    <dependency>
31        <groupId>com.amazonaws</groupId>
32        <artifactId>aws-lambda-java-events</artifactId>
33        <version>3.11.0</version>
34    </dependency>
35
36    <!-- JSON processing -->
37    <dependency>
38        <groupId>com.fasterxml.jackson.core</groupId>
39        <artifactId>jackson-databind</artifactId>
40    </dependency>
41
42    <!-- Validation -->
43    <dependency>
44        <groupId>org.springframework.boot</groupId>
45        <artifactId>spring-boot-starter-validation</artifactId>
46    </dependency>
47</dependencies>

  1@Service
  2@Slf4j
  3public class ApiGatewayService {
  4
  5    private final ApiGatewayClient apiGatewayClient;
  6    private final String region;
  7    private final String accountId;
  8
  9    public ApiGatewayService(@Value("${aws.region}") String region,
 10                           @Value("${aws.account-id}") String accountId) {
 11        this.region = region;
 12        this.accountId = accountId;
 13        this.apiGatewayClient = ApiGatewayClient.builder()
 14            .region(Region.of(region))
 15            .build();
 16    }
 17
 18    public String createRestApi(String apiName, String description) {
 19        try {
 20            CreateRestApiRequest request = CreateRestApiRequest.builder()
 21                .name(apiName)
 22                .description(description)
 23                .endpointConfiguration(EndpointConfiguration.builder()
 24                    .types(EndpointType.REGIONAL)
 25                    .build())
 26                .policy(createApiPolicy())
 27                .build();
 28
 29            CreateRestApiResponse response = apiGatewayClient.createRestApi(request);
 30            String restApiId = response.id();
 31
 32            log.info("Created REST API: {} with ID: {}", apiName, restApiId);
 33            return restApiId;
 34
 35        } catch (Exception e) {
 36            log.error("Failed to create REST API: {}", apiName, e);
 37            throw new RuntimeException("API creation failed", e);
 38        }
 39    }
 40
 41    public String createResource(String restApiId, String parentId, String pathPart) {
 42        try {
 43            CreateResourceRequest request = CreateResourceRequest.builder()
 44                .restApiId(restApiId)
 45                .parentId(parentId)
 46                .pathPart(pathPart)
 47                .build();
 48
 49            CreateResourceResponse response = apiGatewayClient.createResource(request);
 50            String resourceId = response.id();
 51
 52            log.info("Created resource: {} under parent: {}", pathPart, parentId);
 53            return resourceId;
 54
 55        } catch (Exception e) {
 56            log.error("Failed to create resource: {}", pathPart, e);
 57            throw new RuntimeException("Resource creation failed", e);
 58        }
 59    }
 60
 61    public void createMethod(String restApiId, String resourceId, String httpMethod,
 62                           boolean requireAuth, String integrationUri) {
 63        try {
 64            // Create method
 65            PutMethodRequest methodRequest = PutMethodRequest.builder()
 66                .restApiId(restApiId)
 67                .resourceId(resourceId)
 68                .httpMethod(httpMethod)
 69                .authorizationType(requireAuth ? AuthorizationType.AWS_IAM : AuthorizationType.NONE)
 70                .requestParameters(Map.of(
 71                    "method.request.header.Content-Type", false,
 72                    "method.request.header.Authorization", requireAuth
 73                ))
 74                .build();
 75
 76            apiGatewayClient.putMethod(methodRequest);
 77
 78            // Create integration
 79            PutIntegrationRequest integrationRequest = PutIntegrationRequest.builder()
 80                .restApiId(restApiId)
 81                .resourceId(resourceId)
 82                .httpMethod(httpMethod)
 83                .type(IntegrationType.HTTP_PROXY)
 84                .integrationHttpMethod("POST")
 85                .uri(integrationUri)
 86                .requestParameters(Map.of(
 87                    "integration.request.header.Content-Type", "'application/json'"
 88                ))
 89                .build();
 90
 91            apiGatewayClient.putIntegration(integrationRequest);
 92
 93            // Create method response
 94            PutMethodResponseRequest methodResponseRequest = PutMethodResponseRequest.builder()
 95                .restApiId(restApiId)
 96                .resourceId(resourceId)
 97                .httpMethod(httpMethod)
 98                .statusCode("200")
 99                .responseModels(Map.of("application/json", "Empty"))
100                .responseParameters(Map.of(
101                    "method.response.header.Access-Control-Allow-Origin", false
102                ))
103                .build();
104
105            apiGatewayClient.putMethodResponse(methodResponseRequest);
106
107            // Create integration response
108            PutIntegrationResponseRequest integrationResponseRequest = PutIntegrationResponseRequest.builder()
109                .restApiId(restApiId)
110                .resourceId(resourceId)
111                .httpMethod(httpMethod)
112                .statusCode("200")
113                .responseParameters(Map.of(
114                    "method.response.header.Access-Control-Allow-Origin", "'*'"
115                ))
116                .build();
117
118            apiGatewayClient.putIntegrationResponse(integrationResponseRequest);
119
120            log.info("Created method {} for resource {}", httpMethod, resourceId);
121
122        } catch (Exception e) {
123            log.error("Failed to create method: {} for resource: {}", httpMethod, resourceId, e);
124            throw new RuntimeException("Method creation failed", e);
125        }
126    }
127
128    public void deployApi(String restApiId, String stageName, String description) {
129        try {
130            CreateDeploymentRequest request = CreateDeploymentRequest.builder()
131                .restApiId(restApiId)
132                .stageName(stageName)
133                .description(description)
134                .build();
135
136            CreateDeploymentResponse response = apiGatewayClient.createDeployment(request);
137
138            String invokeUrl = String.format("https://%s.execute-api.%s.amazonaws.com/%s",
139                restApiId, region, stageName);
140
141            log.info("Deployed API to stage: {} with URL: {}", stageName, invokeUrl);
142
143        } catch (Exception e) {
144            log.error("Failed to deploy API: {}", restApiId, e);
145            throw new RuntimeException("API deployment failed", e);
146        }
147    }
148
149    public void createUsagePlan(String restApiId, String planName, String stageName,
150                              int throttleRate, int throttleBurst, int quotaLimit) {
151        try {
152            CreateUsagePlanRequest request = CreateUsagePlanRequest.builder()
153                .name(planName)
154                .description("Usage plan for " + planName)
155                .apiStages(ApiStage.builder()
156                    .apiId(restApiId)
157                    .stage(stageName)
158                    .build())
159                .throttle(ThrottleSettings.builder()
160                    .rateLimit(throttleRate)
161                    .burstLimit(throttleBurst)
162                    .build())
163                .quota(QuotaSettings.builder()
164                    .limit(quotaLimit)
165                    .period(QuotaPeriodType.DAY)
166                    .build())
167                .build();
168
169            CreateUsagePlanResponse response = apiGatewayClient.createUsagePlan(request);
170
171            log.info("Created usage plan: {} with ID: {}", planName, response.id());
172
173        } catch (Exception e) {
174            log.error("Failed to create usage plan: {}", planName, e);
175            throw new RuntimeException("Usage plan creation failed", e);
176        }
177    }
178
179    private String createApiPolicy() {
180        return "{\n" +
181               "  \"Version\": \"2012-10-17\",\n" +
182               "  \"Statement\": [\n" +
183               "    {\n" +
184               "      \"Effect\": \"Allow\",\n" +
185               "      \"Principal\": \"*\",\n" +
186               "      \"Action\": \"execute-api:Invoke\",\n" +
187               "      \"Resource\": \"*\"\n" +
188               "    }\n" +
189               "  ]\n" +
190               "}";
191    }
192
193    public void cleanup(String restApiId) {
194        try {
195            DeleteRestApiRequest request = DeleteRestApiRequest.builder()
196                .restApiId(restApiId)
197                .build();
198
199            apiGatewayClient.deleteRestApi(request);
200            log.info("Deleted REST API: {}", restApiId);
201
202        } catch (Exception e) {
203            log.error("Failed to delete REST API: {}", restApiId, e);
204        }
205    }
206}

  1@RestController
  2@RequestMapping("/api/gateway-demo")
  3@Slf4j
  4public class ApiGatewayDemoController {
  5
  6    private final ApiGatewayService apiGatewayService;
  7    private final MicroserviceOrchestrator orchestrator;
  8
  9    public ApiGatewayDemoController(ApiGatewayService apiGatewayService,
 10                                  MicroserviceOrchestrator orchestrator) {
 11        this.apiGatewayService = apiGatewayService;
 12        this.orchestrator = orchestrator;
 13    }
 14
 15    @PostMapping("/setup-complete-api")
 16    public ResponseEntity<ApiSetupResponse> setupCompleteApi() {
 17        try {
 18            // 1. Create REST API
 19            String restApiId = apiGatewayService.createRestApi(
 20                "E-commerce-API",
 21                "Complete e-commerce microservices API"
 22            );
 23
 24            // 2. Get root resource
 25            String rootResourceId = getRootResourceId(restApiId);
 26
 27            // 3. Setup API resources and methods
 28            setupEcommerceApi(restApiId, rootResourceId);
 29
 30            // 4. Deploy to stage
 31            apiGatewayService.deployApi(restApiId, "prod", "Production deployment");
 32
 33            // 5. Create usage plans
 34            setupUsagePlans(restApiId);
 35
 36            ApiSetupResponse response = new ApiSetupResponse(
 37                restApiId,
 38                String.format("https://%s.execute-api.%s.amazonaws.com/prod",
 39                    restApiId, "us-east-1"),
 40                "API Gateway setup completed successfully"
 41            );
 42
 43            return ResponseEntity.ok(response);
 44
 45        } catch (Exception e) {
 46            log.error("Failed to setup API Gateway", e);
 47            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
 48                .body(new ApiSetupResponse(null, null, "Setup failed: " + e.getMessage()));
 49        }
 50    }
 51
 52    private void setupEcommerceApi(String restApiId, String rootResourceId) {
 53        // Users resource
 54        String usersResourceId = apiGatewayService.createResource(restApiId, rootResourceId, "users");
 55        apiGatewayService.createMethod(restApiId, usersResourceId, "GET", true,
 56            "http://user-service.internal:8080/users");
 57        apiGatewayService.createMethod(restApiId, usersResourceId, "POST", true,
 58            "http://user-service.internal:8080/users");
 59
 60        // User by ID resource
 61        String userByIdResourceId = apiGatewayService.createResource(restApiId, usersResourceId, "{id}");
 62        apiGatewayService.createMethod(restApiId, userByIdResourceId, "GET", true,
 63            "http://user-service.internal:8080/users/{id}");
 64        apiGatewayService.createMethod(restApiId, userByIdResourceId, "PUT", true,
 65            "http://user-service.internal:8080/users/{id}");
 66        apiGatewayService.createMethod(restApiId, userByIdResourceId, "DELETE", true,
 67            "http://user-service.internal:8080/users/{id}");
 68
 69        // Orders resource
 70        String ordersResourceId = apiGatewayService.createResource(restApiId, rootResourceId, "orders");
 71        apiGatewayService.createMethod(restApiId, ordersResourceId, "GET", true,
 72            "http://order-service.internal:8080/orders");
 73        apiGatewayService.createMethod(restApiId, ordersResourceId, "POST", true,
 74            "http://order-service.internal:8080/orders");
 75
 76        // Products resource
 77        String productsResourceId = apiGatewayService.createResource(restApiId, rootResourceId, "products");
 78        apiGatewayService.createMethod(restApiId, productsResourceId, "GET", false,
 79            "http://product-service.internal:8080/products");
 80
 81        // Payments resource
 82        String paymentsResourceId = apiGatewayService.createResource(restApiId, rootResourceId, "payments");
 83        apiGatewayService.createMethod(restApiId, paymentsResourceId, "POST", true,
 84            "http://payment-service.internal:8080/payments");
 85
 86        log.info("E-commerce API resources setup completed");
 87    }
 88
 89    private void setupUsagePlans(String restApiId) {
 90        // Basic plan
 91        apiGatewayService.createUsagePlan(restApiId, "BasicPlan", "prod",
 92            100, 200, 10000); // 100 req/sec, burst 200, 10k daily quota
 93
 94        // Premium plan
 95        apiGatewayService.createUsagePlan(restApiId, "PremiumPlan", "prod",
 96            1000, 2000, 100000); // 1000 req/sec, burst 2000, 100k daily quota
 97
 98        log.info("Usage plans setup completed");
 99    }
100
101    private String getRootResourceId(String restApiId) {
102        try {
103            GetResourcesRequest request = GetResourcesRequest.builder()
104                .restApiId(restApiId)
105                .build();
106
107            GetResourcesResponse response = apiGatewayService.apiGatewayClient.getResources(request);
108
109            return response.items().stream()
110                .filter(resource -> "/".equals(resource.path()))
111                .findFirst()
112                .map(Resource::id)
113                .orElseThrow(() -> new RuntimeException("Root resource not found"));
114
115        } catch (Exception e) {
116            throw new RuntimeException("Failed to get root resource", e);
117        }
118    }
119
120    // Supporting classes
121    public static class ApiSetupResponse {
122        private final String restApiId;
123        private final String invokeUrl;
124        private final String message;
125
126        public ApiSetupResponse(String restApiId, String invokeUrl, String message) {
127            this.restApiId = restApiId;
128            this.invokeUrl = invokeUrl;
129            this.message = message;
130        }
131
132        // Getters
133        public String getRestApiId() { return restApiId; }
134        public String getInvokeUrl() { return invokeUrl; }
135        public String getMessage() { return message; }
136    }
137}

  1@Component
  2public class ApiGatewayCustomAuthorizer implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayCustomAuthorizerResponse> {
  3
  4    private final JWTVerifier jwtVerifier;
  5    private final UserService userService;
  6
  7    public ApiGatewayCustomAuthorizer() {
  8        // Initialize JWT verifier
  9        Algorithm algorithm = Algorithm.HMAC256(System.getenv("JWT_SECRET"));
 10        this.jwtVerifier = JWT.require(algorithm)
 11            .withIssuer("your-app")
 12            .build();
 13        this.userService = new UserService();
 14    }
 15
 16    @Override
 17    public APIGatewayCustomAuthorizerResponse handleRequest(APIGatewayProxyRequestEvent input, Context context) {
 18        try {
 19            String token = extractToken(input);
 20
 21            if (token == null) {
 22                return createResponse("Deny", null, input.getRequestContext().getRequestId());
 23            }
 24
 25            // Verify JWT token
 26            DecodedJWT decodedJWT = jwtVerifier.verify(token);
 27            String userId = decodedJWT.getSubject();
 28
 29            // Additional user validation
 30            if (!userService.isUserActive(userId)) {
 31                return createResponse("Deny", userId, input.getRequestContext().getRequestId());
 32            }
 33
 34            // Create policy with user context
 35            return createResponse("Allow", userId, input.getRequestContext().getRequestId());
 36
 37        } catch (JWTVerificationException e) {
 38            context.getLogger().log("JWT verification failed: " + e.getMessage());
 39            return createResponse("Deny", null, input.getRequestContext().getRequestId());
 40        } catch (Exception e) {
 41            context.getLogger().log("Authorization error: " + e.getMessage());
 42            return createResponse("Deny", null, input.getRequestContext().getRequestId());
 43        }
 44    }
 45
 46    private String extractToken(APIGatewayProxyRequestEvent input) {
 47        String authHeader = input.getHeaders().get("Authorization");
 48        if (authHeader != null && authHeader.startsWith("Bearer ")) {
 49            return authHeader.substring(7);
 50        }
 51
 52        // Try query parameter
 53        if (input.getQueryStringParameters() != null) {
 54            return input.getQueryStringParameters().get("token");
 55        }
 56
 57        return null;
 58    }
 59
 60    private APIGatewayCustomAuthorizerResponse createResponse(String effect, String userId, String requestId) {
 61        APIGatewayCustomAuthorizerResponse response = new APIGatewayCustomAuthorizerResponse();
 62
 63        // Set principal ID
 64        response.setPrincipalId(userId != null ? userId : "anonymous");
 65
 66        // Create policy document
 67        PolicyDocument policyDocument = new PolicyDocument();
 68        policyDocument.setVersion("2012-10-17");
 69
 70        Statement statement = new Statement();
 71        statement.setEffect(effect);
 72        statement.setAction("execute-api:Invoke");
 73        statement.setResource("*"); // In production, be more specific
 74
 75        policyDocument.setStatement(Arrays.asList(statement));
 76        response.setPolicyDocument(policyDocument);
 77
 78        // Add context information
 79        Map<String, Object> context = new HashMap<>();
 80        context.put("userId", userId);
 81        context.put("requestId", requestId);
 82        context.put("authorizedAt", System.currentTimeMillis());
 83        response.setContext(context);
 84
 85        return response;
 86    }
 87
 88    // Supporting classes for policy document
 89    public static class PolicyDocument {
 90        private String version;
 91        private List<Statement> statement;
 92
 93        // Getters and setters
 94        public String getVersion() { return version; }
 95        public void setVersion(String version) { this.version = version; }
 96        public List<Statement> getStatement() { return statement; }
 97        public void setStatement(List<Statement> statement) { this.statement = statement; }
 98    }
 99
100    public static class Statement {
101        private String effect;
102        private String action;
103        private String resource;
104
105        // Getters and setters
106        public String getEffect() { return effect; }
107        public void setEffect(String effect) { this.effect = effect; }
108        public String getAction() { return action; }
109        public void setAction(String action) { this.action = action; }
110        public String getResource() { return resource; }
111        public void setResource(String resource) { this.resource = resource; }
112    }
113
114    // Mock user service
115    private static class UserService {
116        public boolean isUserActive(String userId) {
117            // In real implementation, check database
118            return userId != null && !userId.isEmpty();
119        }
120    }
121}

  1@Service
  2@Slf4j
  3public class ResponseAggregationService {
  4
  5    private final RestTemplate restTemplate;
  6    private final RedisTemplate<String, Object> redisTemplate;
  7    private final MeterRegistry meterRegistry;
  8
  9    public ResponseAggregationService(RestTemplate restTemplate,
 10                                    RedisTemplate<String, Object> redisTemplate,
 11                                    MeterRegistry meterRegistry) {
 12        this.restTemplate = restTemplate;
 13        this.redisTemplate = redisTemplate;
 14        this.meterRegistry = meterRegistry;
 15    }
 16
 17    // Aggregate user profile with orders and preferences
 18    @Async
 19    public CompletableFuture<UserProfileAggregate> getUserProfileAggregate(String userId) {
 20        Timer.Sample sample = Timer.start(meterRegistry);
 21
 22        try {
 23            // Check cache first
 24            String cacheKey = "user_profile_aggregate:" + userId;
 25            UserProfileAggregate cached = (UserProfileAggregate) redisTemplate.opsForValue().get(cacheKey);
 26
 27            if (cached != null) {
 28                meterRegistry.counter("api_gateway.aggregation.cache_hit").increment();
 29                return CompletableFuture.completedFuture(cached);
 30            }
 31
 32            // Parallel calls to multiple services
 33            CompletableFuture<UserProfile> userProfileFuture = CompletableFuture.supplyAsync(() ->
 34                fetchUserProfile(userId));
 35
 36            CompletableFuture<List<Order>> ordersFuture = CompletableFuture.supplyAsync(() ->
 37                fetchUserOrders(userId));
 38
 39            CompletableFuture<UserPreferences> preferencesFuture = CompletableFuture.supplyAsync(() ->
 40                fetchUserPreferences(userId));
 41
 42            CompletableFuture<List<Recommendation>> recommendationsFuture = CompletableFuture.supplyAsync(() ->
 43                fetchRecommendations(userId));
 44
 45            // Wait for all calls to complete
 46            CompletableFuture<Void> allOf = CompletableFuture.allOf(
 47                userProfileFuture, ordersFuture, preferencesFuture, recommendationsFuture);
 48
 49            return allOf.thenApply(v -> {
 50                UserProfileAggregate aggregate = new UserProfileAggregate();
 51                aggregate.setUserProfile(userProfileFuture.join());
 52                aggregate.setRecentOrders(ordersFuture.join());
 53                aggregate.setPreferences(preferencesFuture.join());
 54                aggregate.setRecommendations(recommendationsFuture.join());
 55                aggregate.setAggregatedAt(Instant.now());
 56
 57                // Cache for 5 minutes
 58                redisTemplate.opsForValue().set(cacheKey, aggregate, Duration.ofMinutes(5));
 59                meterRegistry.counter("api_gateway.aggregation.cache_miss").increment();
 60
 61                return aggregate;
 62            });
 63
 64        } finally {
 65            sample.stop(Timer.builder("api_gateway.aggregation.duration")
 66                .tag("operation", "user_profile")
 67                .register(meterRegistry));
 68        }
 69    }
 70
 71    // Aggregate product details with reviews and inventory
 72    @Async
 73    public CompletableFuture<ProductAggregate> getProductAggregate(String productId) {
 74        Timer.Sample sample = Timer.start(meterRegistry);
 75
 76        try {
 77            String cacheKey = "product_aggregate:" + productId;
 78            ProductAggregate cached = (ProductAggregate) redisTemplate.opsForValue().get(cacheKey);
 79
 80            if (cached != null) {
 81                return CompletableFuture.completedFuture(cached);
 82            }
 83
 84            // Parallel calls
 85            CompletableFuture<Product> productFuture = CompletableFuture.supplyAsync(() ->
 86                fetchProduct(productId));
 87
 88            CompletableFuture<List<Review>> reviewsFuture = CompletableFuture.supplyAsync(() ->
 89                fetchProductReviews(productId));
 90
 91            CompletableFuture<InventoryStatus> inventoryFuture = CompletableFuture.supplyAsync(() ->
 92                fetchInventoryStatus(productId));
 93
 94            CompletableFuture<PriceInfo> priceFuture = CompletableFuture.supplyAsync(() ->
 95                fetchPriceInfo(productId));
 96
 97            return CompletableFuture.allOf(productFuture, reviewsFuture, inventoryFuture, priceFuture)
 98                .thenApply(v -> {
 99                    ProductAggregate aggregate = new ProductAggregate();
100                    aggregate.setProduct(productFuture.join());
101                    aggregate.setReviews(reviewsFuture.join());
102                    aggregate.setInventoryStatus(inventoryFuture.join());
103                    aggregate.setPriceInfo(priceFuture.join());
104                    aggregate.setAggregatedAt(Instant.now());
105
106                    // Cache for 10 minutes
107                    redisTemplate.opsForValue().set(cacheKey, aggregate, Duration.ofMinutes(10));
108
109                    return aggregate;
110                });
111
112        } finally {
113            sample.stop(Timer.builder("api_gateway.aggregation.duration")
114                .tag("operation", "product")
115                .register(meterRegistry));
116        }
117    }
118
119    // Service calls with circuit breaker pattern
120    @CircuitBreaker(name = "user-service", fallbackMethod = "fallbackUserProfile")
121    @TimeLimiter(name = "user-service")
122    @Retry(name = "user-service")
123    private UserProfile fetchUserProfile(String userId) {
124        try {
125            ResponseEntity<UserProfile> response = restTemplate.getForEntity(
126                "http://user-service/users/" + userId, UserProfile.class);
127
128            meterRegistry.counter("api_gateway.service_calls", "service", "user", "status", "success").increment();
129            return response.getBody();
130
131        } catch (Exception e) {
132            meterRegistry.counter("api_gateway.service_calls", "service", "user", "status", "error").increment();
133            throw e;
134        }
135    }
136
137    @CircuitBreaker(name = "order-service", fallbackMethod = "fallbackUserOrders")
138    private List<Order> fetchUserOrders(String userId) {
139        try {
140            ResponseEntity<Order[]> response = restTemplate.getForEntity(
141                "http://order-service/orders?userId=" + userId, Order[].class);
142
143            meterRegistry.counter("api_gateway.service_calls", "service", "order", "status", "success").increment();
144            return Arrays.asList(response.getBody());
145
146        } catch (Exception e) {
147            meterRegistry.counter("api_gateway.service_calls", "service", "order", "status", "error").increment();
148            throw e;
149        }
150    }
151
152    @CircuitBreaker(name = "preference-service", fallbackMethod = "fallbackUserPreferences")
153    private UserPreferences fetchUserPreferences(String userId) {
154        try {
155            ResponseEntity<UserPreferences> response = restTemplate.getForEntity(
156                "http://preference-service/preferences/" + userId, UserPreferences.class);
157
158            meterRegistry.counter("api_gateway.service_calls", "service", "preference", "status", "success").increment();
159            return response.getBody();
160
161        } catch (Exception e) {
162            meterRegistry.counter("api_gateway.service_calls", "service", "preference", "status", "error").increment();
163            throw e;
164        }
165    }
166
167    @CircuitBreaker(name = "recommendation-service", fallbackMethod = "fallbackRecommendations")
168    private List<Recommendation> fetchRecommendations(String userId) {
169        try {
170            ResponseEntity<Recommendation[]> response = restTemplate.getForEntity(
171                "http://recommendation-service/recommendations/" + userId, Recommendation[].class);
172
173            meterRegistry.counter("api_gateway.service_calls", "service", "recommendation", "status", "success").increment();
174            return Arrays.asList(response.getBody());
175
176        } catch (Exception e) {
177            meterRegistry.counter("api_gateway.service_calls", "service", "recommendation", "status", "error").increment();
178            throw e;
179        }
180    }
181
182    @CircuitBreaker(name = "product-service", fallbackMethod = "fallbackProduct")
183    private Product fetchProduct(String productId) {
184        try {
185            ResponseEntity<Product> response = restTemplate.getForEntity(
186                "http://product-service/products/" + productId, Product.class);
187            return response.getBody();
188        } catch (Exception e) {
189            throw e;
190        }
191    }
192
193    private List<Review> fetchProductReviews(String productId) {
194        try {
195            ResponseEntity<Review[]> response = restTemplate.getForEntity(
196                "http://review-service/reviews?productId=" + productId, Review[].class);
197            return Arrays.asList(response.getBody());
198        } catch (Exception e) {
199            return Collections.emptyList(); // Fail gracefully for reviews
200        }
201    }
202
203    private InventoryStatus fetchInventoryStatus(String productId) {
204        try {
205            ResponseEntity<InventoryStatus> response = restTemplate.getForEntity(
206                "http://inventory-service/inventory/" + productId, InventoryStatus.class);
207            return response.getBody();
208        } catch (Exception e) {
209            return new InventoryStatus(productId, 0, false); // Default fallback
210        }
211    }
212
213    private PriceInfo fetchPriceInfo(String productId) {
214        try {
215            ResponseEntity<PriceInfo> response = restTemplate.getForEntity(
216                "http://pricing-service/prices/" + productId, PriceInfo.class);
217            return response.getBody();
218        } catch (Exception e) {
219            return new PriceInfo(productId, BigDecimal.ZERO, null); // Default fallback
220        }
221    }
222
223    // Fallback methods
224    private UserProfile fallbackUserProfile(String userId, Exception e) {
225        log.warn("Fallback for user profile: {}", userId, e);
226        return new UserProfile(userId, "Unknown User", "user@example.com", false);
227    }
228
229    private List<Order> fallbackUserOrders(String userId, Exception e) {
230        log.warn("Fallback for user orders: {}", userId, e);
231        return Collections.emptyList();
232    }
233
234    private UserPreferences fallbackUserPreferences(String userId, Exception e) {
235        log.warn("Fallback for user preferences: {}", userId, e);
236        return new UserPreferences(userId, Collections.emptyMap());
237    }
238
239    private List<Recommendation> fallbackRecommendations(String userId, Exception e) {
240        log.warn("Fallback for recommendations: {}", userId, e);
241        return Collections.emptyList();
242    }
243
244    private Product fallbackProduct(String productId, Exception e) {
245        log.warn("Fallback for product: {}", productId, e);
246        return new Product(productId, "Product Unavailable", "Product temporarily unavailable",
247            BigDecimal.ZERO, false);
248    }
249
250    // Aggregate response classes
251    public static class UserProfileAggregate {
252        private UserProfile userProfile;
253        private List<Order> recentOrders;
254        private UserPreferences preferences;
255        private List<Recommendation> recommendations;
256        private Instant aggregatedAt;
257
258        // Constructors, getters, setters
259        public UserProfileAggregate() {}
260
261        public UserProfile getUserProfile() { return userProfile; }
262        public void setUserProfile(UserProfile userProfile) { this.userProfile = userProfile; }
263        public List<Order> getRecentOrders() { return recentOrders; }
264        public void setRecentOrders(List<Order> recentOrders) { this.recentOrders = recentOrders; }
265        public UserPreferences getPreferences() { return preferences; }
266        public void setPreferences(UserPreferences preferences) { this.preferences = preferences; }
267        public List<Recommendation> getRecommendations() { return recommendations; }
268        public void setRecommendations(List<Recommendation> recommendations) { this.recommendations = recommendations; }
269        public Instant getAggregatedAt() { return aggregatedAt; }
270        public void setAggregatedAt(Instant aggregatedAt) { this.aggregatedAt = aggregatedAt; }
271    }
272
273    public static class ProductAggregate {
274        private Product product;
275        private List<Review> reviews;
276        private InventoryStatus inventoryStatus;
277        private PriceInfo priceInfo;
278        private Instant aggregatedAt;
279
280        // Constructors, getters, setters
281        public ProductAggregate() {}
282
283        public Product getProduct() { return product; }
284        public void setProduct(Product product) { this.product = product; }
285        public List<Review> getReviews() { return reviews; }
286        public void setReviews(List<Review> reviews) { this.reviews = reviews; }
287        public InventoryStatus getInventoryStatus() { return inventoryStatus; }
288        public void setInventoryStatus(InventoryStatus inventoryStatus) { this.inventoryStatus = inventoryStatus; }
289        public PriceInfo getPriceInfo() { return priceInfo; }
290        public void setPriceInfo(PriceInfo priceInfo) { this.priceInfo = priceInfo; }
291        public Instant getAggregatedAt() { return aggregatedAt; }
292        public void setAggregatedAt(Instant aggregatedAt) { this.aggregatedAt = aggregatedAt; }
293    }
294
295    // Supporting data classes
296    public static class UserProfile {
297        private String userId;
298        private String name;
299        private String email;
300        private boolean isPremium;
301
302        public UserProfile() {}
303        public UserProfile(String userId, String name, String email, boolean isPremium) {
304            this.userId = userId;
305            this.name = name;
306            this.email = email;
307            this.isPremium = isPremium;
308        }
309
310        // Getters and setters
311        public String getUserId() { return userId; }
312        public void setUserId(String userId) { this.userId = userId; }
313        public String getName() { return name; }
314        public void setName(String name) { this.name = name; }
315        public String getEmail() { return email; }
316        public void setEmail(String email) { this.email = email; }
317        public boolean isPremium() { return isPremium; }
318        public void setPremium(boolean premium) { isPremium = premium; }
319    }
320
321    public static class Order {
322        private String orderId;
323        private String status;
324        private BigDecimal total;
325        private Instant createdAt;
326
327        // Constructors, getters, setters
328        public Order() {}
329        public String getOrderId() { return orderId; }
330        public void setOrderId(String orderId) { this.orderId = orderId; }
331        public String getStatus() { return status; }
332        public void setStatus(String status) { this.status = status; }
333        public BigDecimal getTotal() { return total; }
334        public void setTotal(BigDecimal total) { this.total = total; }
335        public Instant getCreatedAt() { return createdAt; }
336        public void setCreatedAt(Instant createdAt) { this.createdAt = createdAt; }
337    }
338
339    public static class UserPreferences {
340        private String userId;
341        private Map<String, Object> preferences;
342
343        public UserPreferences() { this.preferences = new HashMap<>(); }
344        public UserPreferences(String userId, Map<String, Object> preferences) {
345            this.userId = userId;
346            this.preferences = preferences;
347        }
348
349        // Getters and setters
350        public String getUserId() { return userId; }
351        public void setUserId(String userId) { this.userId = userId; }
352        public Map<String, Object> getPreferences() { return preferences; }
353        public void setPreferences(Map<String, Object> preferences) { this.preferences = preferences; }
354    }
355
356    public static class Recommendation {
357        private String productId;
358        private String title;
359        private double score;
360
361        // Constructors, getters, setters
362        public Recommendation() {}
363        public String getProductId() { return productId; }
364        public void setProductId(String productId) { this.productId = productId; }
365        public String getTitle() { return title; }
366        public void setTitle(String title) { this.title = title; }
367        public double getScore() { return score; }
368        public void setScore(double score) { this.score = score; }
369    }
370
371    public static class Product {
372        private String productId;
373        private String name;
374        private String description;
375        private BigDecimal price;
376        private boolean available;
377
378        public Product() {}
379        public Product(String productId, String name, String description, BigDecimal price, boolean available) {
380            this.productId = productId;
381            this.name = name;
382            this.description = description;
383            this.price = price;
384            this.available = available;
385        }
386
387        // Getters and setters
388        public String getProductId() { return productId; }
389        public void setProductId(String productId) { this.productId = productId; }
390        public String getName() { return name; }
391        public void setName(String name) { this.name = name; }
392        public String getDescription() { return description; }
393        public void setDescription(String description) { this.description = description; }
394        public BigDecimal getPrice() { return price; }
395        public void setPrice(BigDecimal price) { this.price = price; }
396        public boolean isAvailable() { return available; }
397        public void setAvailable(boolean available) { this.available = available; }
398    }
399
400    public static class Review {
401        private String reviewId;
402        private String productId;
403        private int rating;
404        private String comment;
405
406        // Constructors, getters, setters
407        public Review() {}
408        public String getReviewId() { return reviewId; }
409        public void setReviewId(String reviewId) { this.reviewId = reviewId; }
410        public String getProductId() { return productId; }
411        public void setProductId(String productId) { this.productId = productId; }
412        public int getRating() { return rating; }
413        public void setRating(int rating) { this.rating = rating; }
414        public String getComment() { return comment; }
415        public void setComment(String comment) { this.comment = comment; }
416    }
417
418    public static class InventoryStatus {
419        private String productId;
420        private int quantity;
421        private boolean inStock;
422
423        public InventoryStatus() {}
424        public InventoryStatus(String productId, int quantity, boolean inStock) {
425            this.productId = productId;
426            this.quantity = quantity;
427            this.inStock = inStock;
428        }
429
430        // Getters and setters
431        public String getProductId() { return productId; }
432        public void setProductId(String productId) { this.productId = productId; }
433        public int getQuantity() { return quantity; }
434        public void setQuantity(int quantity) { this.quantity = quantity; }
435        public boolean isInStock() { return inStock; }
436        public void setInStock(boolean inStock) { this.inStock = inStock; }
437    }
438
439    public static class PriceInfo {
440        private String productId;
441        private BigDecimal currentPrice;
442        private BigDecimal discountPrice;
443
444        public PriceInfo() {}
445        public PriceInfo(String productId, BigDecimal currentPrice, BigDecimal discountPrice) {
446            this.productId = productId;
447            this.currentPrice = currentPrice;
448            this.discountPrice = discountPrice;
449        }
450
451        // Getters and setters
452        public String getProductId() { return productId; }
453        public void setProductId(String productId) { this.productId = productId; }
454        public BigDecimal getCurrentPrice() { return currentPrice; }
455        public void setCurrentPrice(BigDecimal currentPrice) { this.currentPrice = currentPrice; }
456        public BigDecimal getDiscountPrice() { return discountPrice; }
457        public void setDiscountPrice(BigDecimal discountPrice) { this.discountPrice = discountPrice; }
458    }
459}