Config

Configuration Layer

📝 Note: This guide uses generic placeholder names to be reusable across any Spring Boot microservice. Replace with your actual implementation:

• {YourService} → Your service name (e.g., OrderService, PaymentService)
• BusinessService → Your core service (e.g., OrderService, UserService)
• DataService → Your data processing service (e.g., PaymentService, InventoryService)
• IntegrationService → Your external integration (e.g., PaymentGatewayService)
• {RequestType} → Your request DTO (e.g., CreateOrderRequest)
• {ResponseType} → Your response DTO (e.g., OrderResponse)

Overview

The configuration layer centralizes all Spring Boot configuration classes, defining beans, API clients, security, async processing, caching, and external service integrations. This layer establishes the application's runtime behavior and dependencies.

Architecture: Configuration Classes Pattern with property-based, environment-specific configuration using Spring profiles (local, docker, production).

Package Structure

config/
├── ApiClientConfiguration.java      # External API base URLs and endpoints
├── ApplicationConfiguration.java    # Application-level properties
├── BeanConfiguration.java           # Core bean definitions (ObjectMapper, RestTemplate)
├── ClientConfiguration.java         # HTTP client and template configurations
├── LibraryConfig.java              # Third-party libraries (SQS, cache)
├── SecurityConfiguration.java       # Spring Security settings
├── SwaggerConfiguration.java        # API documentation (Swagger/OpenAPI)
├── WebConfiguration.java           # Web MVC config (CORS, converters)
└── model/rest/ServiceGroup.java    # Service group data model

Configuration Classes

Quick Reference

Centralized API Configuration

@Value("${token.api.base.url}")
private String tokenApiBaseUrl;

@Bean
public String getTokenEndpoint() {
    return tokenApiBaseUrl + "/token";
}

See: examples/ApiClientConfigurationExample.java

Bean Definition

@Bean
public ObjectMapper objectMapper() {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    mapper.registerModule(new JavaTimeModule());
    mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    return mapper;
}

See: examples/BeanFactoryExample.java

Property Injection with Defaults

@Value("${resource access.ttl.seconds:3600}")
private Long resource accessTtlSeconds;

See: examples/PropertyBindingExample.java

HTTP Client with Timeouts

@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
    return builder
            .setConnectTimeout(Duration.ofSeconds(30))
            .setReadTimeout(Duration.ofSeconds(30))
            .build();
}

See: examples/HttpClientConfigExample.java

Connection Pooling

PoolingHttpClientConnectionManager connectionManager = 
    new PoolingHttpClientConnectionManager();
connectionManager.setMaxTotal(100);
connectionManager.setDefaultMaxPerRoute(20);

See: examples/ConnectionPoolingExample.java

CORS Configuration

@Override
public void addCorsMappings(CorsRegistry registry) {
    registry.addMapping("/api/**")
            .allowedOrigins("https://amcplus.com", "https://www.amcplus.com")
            .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
            .allowCredentials(true)
            .maxAge(3600);
}

See: examples/CorsConfigurationExample.java

Conditional Bean Creation

@Bean
@ConditionalOnProperty(name = "aws.sqs.enabled", havingValue = "true")
public AmazonSQS amazonSQS() {
    return AmazonSQSClientBuilder.defaultClient();
}

See: examples/LibraryIntegrationExample.java

Design Patterns

• Configuration Pattern: Centralized configuration by concern
• Factory Pattern: Bean factory methods for complex objects
• Builder Pattern: RestTemplateBuilder, Docket for fluent configuration
• Strategy Pattern: Conditional bean creation based on environment
• Dependency Injection: Spring IoC container manages dependencies

Environment Configuration

# Production - application.properties
token.api.base.url=${TOKEN_API_BASE_URL}
auth.api.base.url=${AUTH_API_BASE_URL}
aws.sqs.enabled=true

# Local - application-local.properties
token.api.base.url=http://localhost:8081
auth.api.base.url=http://localhost:8082
aws.sqs.enabled=false

# Docker - application-docker.properties
token.api.base.url=http://token-api:8081
auth.api.base.url=http://auth-api:8082
aws.sqs.enabled=true

Key Principles

• ✅ Externalize all configuration values
• ✅ Provide default values for non-critical properties
• ✅ Validate required properties at startup
• ✅ Configure proper timeouts on HTTP clients
• ✅ Use connection pooling for performance
• ✅ Explicit CORS origins (no wildcards)
• ✅ Disable CSRF for stateless REST APIs
• ✅ Use @ConditionalOnProperty for feature toggles
• ✅ Separate configuration by concern
• ❌ Never commit secrets to configuration files

Code Formatting

All Java code is formatted using Spotless with Google Java Format (AOSP style).

Format code:

./gradlew spotlessApply

Detailed Documentation

Guides

• Patterns Guide - Configuration patterns and design principles
• Best Practices Guide - Configuration best practices and standards
• Testing Guide - Testing configuration classes
• Anti-Patterns Guide - Common mistakes to avoid

Examples

All examples are in examples/ directory with package: com.example.microserviceorch.config.example

Configuration Examples:

• ApiClientConfigurationExample.java - API client configuration
• BeanFactoryExample.java - Bean factory pattern
• PropertyBindingExample.java - Property injection
• HttpClientConfigExample.java - HTTP client setup
• ConnectionPoolingExample.java - Connection pooling
• CorsConfigurationExample.java - CORS configuration
• LibraryIntegrationExample.java - Third-party integration
• BuilderPatternExample.java - Builder pattern
• SwaggerConfigurationExample.java - API documentation

Test Examples:

• ApiClientConfigurationExampleTest.java - Configuration testing
• PropertyInjectionExampleTest.java - Property injection testing
• ConfigurationIntegrationExampleTest.java - Integration testing
• ConditionalBeanExampleTest.java - Conditional bean testing
• HttpClientConfigExampleTest.java - HTTP client testing
• CorsConfigExampleTest.java - CORS testing
• SwaggerConfigExampleTest.java - Swagger testing
• ProfileConfigurationExampleTest.java - Profile testing
• BeanDependencyExampleTest.java - Dependency testing

Summary

The configuration layer ensures centralized configuration for external services, environment-specific settings via Spring profiles, type-safe property binding, proper HTTP client configuration with timeouts and pooling, security configuration, third-party library integration, API documentation via Swagger/OpenAPI, and consistent code formatting with Spotless.

This approach provides flexibility, maintainability, and clear separation of concerns across different configuration aspects.