AWS Architecture Patterns for Java: Enterprise-Scale Production Systems

// Traditional approach - monolithic Spring Boot application
@SpringBootApplication
public class ECommerceApplication {
    
    @Autowired
    private UserService userService;
    
    @Autowired 
    private ProductService productService;
    
    @Autowired
    private OrderService orderService;
    
    // All business logic in one application
    // Scales as a single unit
    // Single point of failure
}

// User Service - Independently scalable
@SpringBootApplication
@EnableEurekaClient
public class UserServiceApplication {
    
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
    
    // Handles only user-related operations
    // Scales independently based on user traffic
    // Can be deployed without affecting other services
}

// Product Service - Optimized for read-heavy operations
@SpringBootApplication
@EnableCaching
public class ProductServiceApplication {
    
    @Cacheable("products")
    public Product getProduct(String productId) {
        // Heavy caching for product catalog
        // Read replicas for database
        // CDN for static product images
    }
}

# EKS Deployment for Java Microservice
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 10
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: your-account.dkr.ecr.us-west-2.amazonaws.com/user-service:latest
        ports:
        - containerPort: 8080
        env:
        - name: SPRING_PROFILES_ACTIVE
          value: "aws"
        - name: DB_HOST
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: host
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8080
          initialDelaySeconds: 60
          periodSeconds: 30

// Java application optimized for Kubernetes
@SpringBootApplication
public class UserServiceApplication {
    
    public static void main(String[] args) {
        // JVM optimizations for containers
        System.setProperty("java.awt.headless", "true");
        System.setProperty("-XX:+UseContainerSupport", "true");
        System.setProperty("-XX:MaxRAMPercentage", "75.0");
        
        SpringApplication.run(UserServiceApplication.class, args);
    }
    
    @Bean
    public CustomMetricsConfiguration customMetrics() {
        return new CustomMetricsConfiguration();
    }
}

@Configuration
public class KubernetesConfiguration {
    
    @Bean
    @ConditionalOnProperty("kubernetes.enabled")
    public KubernetesServiceDiscovery serviceDiscovery() {
        return new KubernetesServiceDiscovery();
    }
    
    @Bean
    public GracefulShutdownConfiguration gracefulShutdown() {
        // Proper shutdown handling for Kubernetes
        return new GracefulShutdownConfiguration(30); // 30-second grace period
    }
}

// Fargate-optimized Spring Boot application
@SpringBootApplication
public class OrderServiceApplication {
    
    // Optimized startup time for Fargate cold starts
    @EventListener(ApplicationReadyEvent.class)
    public void warmupCache() {
        // Pre-warm critical caches during startup
        productCache.warmup();
        userPreferencesCache.warmup();
    }
    
    @Bean
    public TaskExecutor taskExecutor() {
        // Optimize thread pool for Fargate resource limits
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(500);
        return executor;
    }
}

// Configuration for multiple databases
@Configuration
public class DatabaseConfiguration {
    
    // Primary database for transactional data
    @Primary
    @Bean
    @ConfigurationProperties("app.datasource.primary")
    public DataSource primaryDataSource() {
        return HikariDataSource.create();
    }
    
    // Read replica for reporting and analytics
    @Bean
    @ConfigurationProperties("app.datasource.readonly")
    public DataSource readOnlyDataSource() {
        return HikariDataSource.create();
    }
    
    // DynamoDB for session storage and caching
    @Bean
    public DynamoDbTemplate dynamoDbTemplate() {
        return new DynamoDbTemplate(amazonDynamoDB());
    }
}

// Service using appropriate database for each operation
@Service
public class UserService {
    
    @Autowired
    @Qualifier("primaryDataSource")
    private JdbcTemplate primaryJdbc;
    
    @Autowired
    @Qualifier("readOnlyDataSource") 
    private JdbcTemplate readOnlyJdbc;
    
    @Autowired
    private DynamoDbTemplate dynamoDb;
    
    // Write operations go to primary
    @Transactional
    public User createUser(CreateUserRequest request) {
        return primaryJdbc.query(/* create user SQL */);
    }
    
    // Read operations from read replica
    @Transactional(readOnly = true)
    public List<User> searchUsers(SearchCriteria criteria) {
        return readOnlyJdbc.query(/* search query */);
    }
    
    // Session data in DynamoDB
    public void storeUserSession(String sessionId, UserSession session) {
        dynamoDb.save(session);
    }
}

// Configuration for Aurora Serverless v2
@Configuration
public class AuroraConfiguration {
    
    @Bean
    @ConfigurationProperties("aurora.datasource")
    public HikariDataSource auroraDataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://aurora-cluster.cluster-xyz.us-west-2.rds.amazonaws.com:3306/mydb");
        config.setDriverClassName("com.mysql.cj.jdbc.Driver");
        
        // Optimized for Aurora Serverless scaling
        config.setMinimumIdle(2);
        config.setMaximumPoolSize(20);
        config.setConnectionTimeout(30000);
        config.setIdleTimeout(600000);
        config.setMaxLifetime(1800000);
        
        return new HikariDataSource(config);
    }
    
    @Bean
    public AuroraConnectionManager connectionManager() {
        return new AuroraConnectionManager();
    }
}

// Custom connection manager for Aurora Serverless
@Component
public class AuroraConnectionManager {
    
    private final AtomicInteger activeConnections = new AtomicInteger(0);
    
    @EventListener
    public void handleScalingEvent(AuroraScalingEvent event) {
        if (event.isScalingUp()) {
            // Pre-warm connections
            connectionPool.warmup(event.getTargetCapacity());
        } else {
            // Gracefully close excess connections
            connectionPool.scale(event.getTargetCapacity());
        }
    }
}

// Comprehensive caching strategy
@Service
@CacheConfig(cacheNames = "users")
public class UserService {
    
    // L1: Application-level cache (Caffeine)
    @Cacheable(key = "#userId")
    public User getUser(String userId) {
        return getFromL2OrDatabase(userId);
    }
    
    private User getFromL2OrDatabase(String userId) {
        // L2: Redis cluster cache
        User cachedUser = redisTemplate.opsForValue().get("user:" + userId);
        if (cachedUser != null) {
            return cachedUser;
        }
        
        // L3: Database with read replica
        User user = userRepository.findById(userId);
        
        // Store in L2 cache with TTL
        redisTemplate.opsForValue().set("user:" + userId, user, Duration.ofMinutes(30));
        
        return user;
    }
}

// ElastiCache Redis configuration
@Configuration
@EnableCaching
public class CacheConfiguration {
    
    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        RedisClusterConfiguration clusterConfig = new RedisClusterConfiguration()
            .clusterNode("cache-cluster.xyz.cache.amazonaws.com", 6379);
        
        LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
            .commandTimeout(Duration.ofSeconds(2))
            .shutdownTimeout(Duration.ZERO)
            .build();
            
        return new LettuceConnectionFactory(clusterConfig, clientConfig);
    }
    
    @Bean
    public CacheManager cacheManager() {
        RedisCacheManager.Builder builder = RedisCacheManager
            .RedisCacheManagerBuilder
            .fromConnectionFactory(redisConnectionFactory())
            .cacheDefaults(cacheConfiguration());
            
        return builder.build();
    }
    
    private RedisCacheConfiguration cacheConfiguration() {
        return RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(30))
            .serializeKeysWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()));
    }
}

// Cache performance monitoring
@Component
public class CacheMetrics {
    
    private final MeterRegistry meterRegistry;
    
    @EventListener
    public void handleCacheHit(CacheHitEvent event) {
        meterRegistry.counter("cache.hit", 
            "cache", event.getCacheName(),
            "level", event.getLevel()).increment();
    }
    
    @EventListener 
    public void handleCacheMiss(CacheMissEvent event) {
        meterRegistry.counter("cache.miss",
            "cache", event.getCacheName(),
            "level", event.getLevel()).increment();
    }
    
    @Scheduled(fixedRate = 60000)
    public void reportCacheStatistics() {
        cacheManager.getCacheNames().forEach(cacheName -> {
            Cache cache = cacheManager.getCache(cacheName);
            if (cache instanceof RedisCache) {
                RedisCache redisCache = (RedisCache) cache;
                meterRegistry.gauge("cache.size", cacheName, redisCache.size());
                meterRegistry.gauge("cache.hit.ratio", cacheName, redisCache.getHitRatio());
            }
        });
    }
}

// Custom auto-scaling based on business metrics
@Component
public class BusinessMetricScaler {
    
    private final CloudWatchClient cloudWatch;
    private final AutoScalingClient autoScaling;
    
    @Scheduled(fixedRate = 60000) // Check every minute
    public void evaluateScaling() {
        // Get business metrics
        double ordersPerMinute = getOrdersPerMinute();
        double avgResponseTime = getAverageResponseTime();
        double errorRate = getErrorRate();
        
        ScalingDecision decision = calculateScalingDecision(
            ordersPerMinute, avgResponseTime, errorRate);
            
        if (decision.shouldScale()) {
            executeScaling(decision);
        }
    }
    
    private ScalingDecision calculateScalingDecision(double orders, double responseTime, double errorRate) {
        // Scale up if orders > 1000/min OR response time > 500ms OR error rate > 1%
        if (orders > 1000 || responseTime > 500 || errorRate > 0.01) {
            return ScalingDecision.scaleUp(calculateTargetCapacity(orders, responseTime));
        }
        
        // Scale down if orders < 200/min AND response time < 100ms AND error rate < 0.1%
        if (orders < 200 && responseTime < 100 && errorRate < 0.001) {
            return ScalingDecision.scaleDown(calculateMinimumCapacity());
        }
        
        return ScalingDecision.noChange();
    }
}

// Spot instance management for cost optimization
@Component
public class SpotInstanceManager {
    
    private final EC2Client ec2Client;
    
    public void optimizeFleetComposition() {
        // Get current spot prices
        Map<String, Double> spotPrices = getCurrentSpotPrices();
        
        // Calculate optimal instance mix
        InstanceMix optimalMix = calculateOptimalMix(spotPrices);
        
        // Update auto scaling group with cost-optimized configuration
        updateAutoScalingGroup(optimalMix);
    }
    
    private InstanceMix calculateOptimalMix(Map<String, Double> spotPrices) {
        // Prefer spot instances when prices are favorable
        // Use on-demand instances for baseline capacity
        // Consider performance requirements vs cost savings
        
        return InstanceMix.builder()
            .onDemandPercentage(30) // 30% on-demand for stability
            .spotAllocationStrategy("diversified")
            .instanceTypes(selectOptimalInstanceTypes(spotPrices))
            .build();
    }
}

// Region-aware service configuration
@Configuration
public class MultiRegionConfiguration {
    
    @Value("${aws.region}")
    private String currentRegion;
    
    @Bean
    public RegionAwareServiceDiscovery serviceDiscovery() {
        return new RegionAwareServiceDiscovery(currentRegion);
    }
    
    @Bean
    public CrossRegionReplication crossRegionReplication() {
        return new CrossRegionReplication();
    }
}

// Service with cross-region failover capability
@Service
public class OrderService {
    
    private final List<String> regions = List.of("us-west-2", "us-east-1", "eu-west-1");
    private final Map<String, RestTemplate> regionClients;
    
    public Order processOrder(CreateOrderRequest request) {
        String primaryRegion = determinePrimaryRegion(request);
        
        try {
            return processInRegion(request, primaryRegion);
        } catch (RegionUnavailableException e) {
            // Failover to secondary region
            String secondaryRegion = getSecondaryRegion(primaryRegion);
            return processInRegion(request, secondaryRegion);
        }
    }
    
    private String determinePrimaryRegion(CreateOrderRequest request) {
        // Route based on customer location for optimal latency
        String customerCountry = request.getCustomerLocation().getCountry();
        return regionMapper.getOptimalRegion(customerCountry);
    }
}

// Event-driven data synchronization
@Component
public class CrossRegionEventHandler {
    
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        // Publish to all regions via SNS
        regions.forEach(region -> {
            EventBridge eventBridge = EventBridge.forRegion(region);
            eventBridge.putEvent(event.toEventBridgeEvent());
        });
    }
    
    @EventListener
    public void handleCrossRegionEvent(CrossRegionEvent event) {
        if (!event.getSourceRegion().equals(currentRegion)) {
            // Process event from another region
            syncDataFromEvent(event);
        }
    }
    
    private void syncDataFromEvent(CrossRegionEvent event) {
        // Implement eventual consistency logic
        // Handle conflicts and merge strategies
        conflictResolver.resolve(event);
    }
}

// IAM integration for fine-grained access control
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfiguration {
    
    @Bean
    public AWSCredentialsProvider credentialsProvider() {
        // Use IAM roles instead of access keys
        return DefaultAWSCredentialsProviderChain.getInstance();
    }
    
    @Bean
    public SecretsManagerService secretsManager() {
        return new SecretsManagerService();
    }
}

// Service with IAM-based authorization
@Service
@PreAuthorize("hasRole('ORDER_PROCESSOR')")
public class SecureOrderService {
    
    private final SecretsManagerService secretsManager;
    
    @PreAuthorize("hasPermission(#customerId, 'Customer', 'READ')")
    public List<Order> getCustomerOrders(String customerId) {
        // Method-level security based on IAM permissions
        return orderRepository.findByCustomerId(customerId);
    }
    
    @PreAuthorize("hasPermission(#order, 'WRITE')")
    public Order updateOrder(Order order) {
        // Database credentials from Secrets Manager
        String dbPassword = secretsManager.getSecret("prod/db/password");
        return orderRepository.save(order);
    }
}

// Automated secret rotation
@Component
public class SecretRotationManager {
    
    @Scheduled(cron = "0 0 2 * * ?") // 2 AM daily
    public void rotateSecrets() {
        List<String> secretsToRotate = getSecretsForRotation();
        
        secretsToRotate.forEach(secretArn -> {
            try {
                rotateSecret(secretArn);
                notifyApplications(secretArn);
            } catch (Exception e) {
                handleRotationFailure(secretArn, e);
            }
        });
    }
    
    private void rotateSecret(String secretArn) {
        // Generate new secret value
        String newSecretValue = generateSecretValue();
        
        // Update in Secrets Manager
        secretsManagerClient.updateSecret(UpdateSecretRequest.builder()
            .secretId(secretArn)
            .secretString(newSecretValue)
            .build());
            
        // Update dependent services
        updateDependentServices(secretArn, newSecretValue);
    }
}

// Custom metrics for business KPIs
@Component
public class BusinessMetrics {
    
    private final MeterRegistry meterRegistry;
    private final CloudWatchClient cloudWatch;
    
    @EventListener
    public void recordOrderProcessed(OrderProcessedEvent event) {
        // Business metrics
        meterRegistry.counter("orders.processed",
            "region", event.getRegion(),
            "payment_method", event.getPaymentMethod()).increment();
            
        meterRegistry.timer("order.processing.time",
            "complexity", event.getOrderComplexity())
            .record(event.getProcessingTime(), TimeUnit.MILLISECONDS);
            
        // Custom CloudWatch metrics for alerting
        cloudWatch.putMetricData(PutMetricDataRequest.builder()
            .namespace("ECommerce/Orders")
            .metricData(MetricDatum.builder()
                .metricName("OrderValue")
                .value(event.getOrderValue())
                .timestamp(Instant.now())
                .build())
            .build());
    }
    
    @Scheduled(fixedRate = 300000) // Every 5 minutes
    public void publishHealthMetrics() {
        double healthScore = calculateSystemHealthScore();
        
        cloudWatch.putMetricData(PutMetricDataRequest.builder()
            .namespace("ECommerce/System")
            .metricData(MetricDatum.builder()
                .metricName("HealthScore")
                .value(healthScore)
                .timestamp(Instant.now())
                .build())
            .build());
    }
}

// X-Ray integration for distributed tracing
@Configuration
public class TracingConfiguration {
    
    @Bean
    public AWSXRayRecorder awsxRayRecorder() {
        return AWSXRayRecorderBuilder.standard()
            .withPlugin(new EKSPlugin())
            .withPlugin(new EC2Plugin())
            .withSamplingStrategy(new LocalizedSamplingStrategy())
            .build();
    }
}

// Service with detailed tracing
@Service
public class TracedOrderService {
    
    @XRayEnabled
    public Order processOrder(CreateOrderRequest request) {
        Subsegment subsegment = AWSXRay.beginSubsegment("validate-order");
        try {
            validateOrder(request);
            subsegment.putAnnotation("validation", "passed");
        } finally {
            AWSXRay.endSubsegment();
        }
        
        // Each step creates subsegments for detailed tracing
        processPayment(request);
        updateInventory(request);
        
        return createOrder(request);
    }
    
    @XRayEnabled
    private void processPayment(CreateOrderRequest request) {
        Subsegment subsegment = AWSXRay.beginSubsegment("process-payment");
        subsegment.putAnnotation("payment_method", request.getPaymentMethod());
        subsegment.putMetadata("payment_amount", request.getAmount());
        
        try {
            // Payment processing logic
            paymentService.process(request.getPayment());
        } finally {
            AWSXRay.endSubsegment();
        }
    }
}

// Legacy system integration during migration
@Component
public class LegacyIntegrationGateway {
    
    private final LegacySystemClient legacyClient;
    private final ModernServiceClient modernClient;
    private final FeatureToggleService featureToggle;
    
    public CustomerData getCustomerData(String customerId) {
        // Gradually migrate customers to new system
        if (featureToggle.isEnabled("modern-customer-service", customerId)) {
            try {
                return modernClient.getCustomer(customerId);
            } catch (Exception e) {
                // Fallback to legacy during migration
                log.warn("Modern service failed, falling back to legacy", e);
                return legacyClient.getCustomerData(customerId);
            }
        } else {
            return legacyClient.getCustomerData(customerId);
        }
    }
}

// Database migration with dual writes
@Service
public class DualWriteOrderService {
    
    private final LegacyDatabase legacyDb;
    private final ModernDatabase modernDb;
    
    @Transactional
    public Order createOrder(CreateOrderRequest request) {
        // Write to both systems during migration
        Order order = new Order(request);
        
        // Legacy system (source of truth during migration)
        legacyDb.saveOrder(order);
        
        // Modern system (eventual target)
        try {
            modernDb.saveOrder(order);
        } catch (Exception e) {
            // Log but don't fail the transaction
            log.error("Failed to write to modern database", e);
            migrationMetrics.recordSyncFailure();
        }
        
        return order;
    }
}

// JVM tuning for AWS containers
public class JVMOptimization {
    
    public static void configureForAWS() {
        // Container-aware JVM settings
        System.setProperty("-XX:+UseContainerSupport", "true");
        System.setProperty("-XX:MaxRAMPercentage", "75.0");
        System.setProperty("-XX:+UseG1GC", "true");
        System.setProperty("-XX:MaxGCPauseMillis", "200");
        
        // Optimize for AWS networking
        System.setProperty("-Djava.net.preferIPv4Stack", "true");
        System.setProperty("-Dcom.sun.management.jmxremote", "true");
    }
}