Spring Cloud Config provides centralized external configuration management backed by a Git repository. It enables distributed systems to have centralized configuration with environment-specific overrides.
Core Concepts
What is Spring Cloud Config?
- Centralized configuration server for distributed systems
- Git-backed configuration repository
- Environment-specific configuration management
- Configuration versioning and audit trails
- Dynamic configuration refresh without restarts
Key Benefits:
- Centralized Management: Single source of truth for all configurations
- Environment Specific: Different configurations per environment (dev, staging, prod)
- Version Control: Full history and rollback capabilities via Git
- Dynamic Refresh: Update configurations without application restart
- Encryption: Support for encrypting sensitive configuration values
Architecture Overview
Client Applications ↓ Spring Cloud Config Server ↓ Git Repository (Configuration Files) ↓ Optional: Vault/Consul for Secrets
Dependencies and Setup
Maven Dependencies for Config Server
<properties>
<spring-boot.version>3.1.0</spring-boot.version>
<spring-cloud.version>2022.0.3</spring-cloud.version>
</properties>
<dependencies>
<!-- Spring Cloud Config Server -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-server</artifactId>
</dependency>
<!-- Spring Boot -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>${spring-boot.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
<version>${spring-boot.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
<version>${spring-boot.version}</version>
</dependency>
<!-- Encryption Support -->
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-rsa</artifactId>
<version>1.0.11.RELEASE</version>
</dependency>
<!-- Monitoring -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
<version>${spring-boot.version}</version>
</dependency>
<!-- Testing -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>${spring-boot.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
Maven Dependencies for Config Client
<properties>
<spring-boot.version>3.1.0</spring-boot.version>
<spring-cloud.version>2022.0.3</spring-cloud.version>
</properties>
<dependencies>
<!-- Spring Cloud Config Client -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<!-- Spring Boot -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>${spring-boot.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
<version>${spring-boot.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
<version>${spring-boot.version}</version>
</dependency>
<!-- Refresh Scope -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>
<!-- Database -->
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<scope>runtime</scope>
</dependency>
<!-- Testing -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>${spring-boot.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
Config Server Implementation
1. Config Server Main Application
@SpringBootApplication
@EnableConfigServer
@EnableDiscoveryClient
public class ConfigServerApplication {
public static void main(String[] args) {
SpringApplication.run(ConfigServerApplication.class, args);
}
}
2. Config Server Configuration
# application.yml
server:
port: 8888
spring:
application:
name: config-server
cloud:
config:
server:
git:
uri: https://github.com/your-org/config-repo.git
default-label: main
search-paths:
- '{application}'
- '{profile}'
- common
timeout: 10
force-pull: true
encrypt:
enabled: true
composite:
- type: git
uri: https://github.com/your-org/config-repo.git
- type: vault
host: 127.0.0.1
port: 8200
kv-version: 2
security:
user:
name: config-user
password: ${CONFIG_SERVER_PASSWORD:changeme}
# Encryption Configuration
encrypt:
key-store:
location: classpath:keystore.jks
password: changeit
alias: configKey
secret: changeit
# Management Endpoints
management:
endpoints:
web:
exposure:
include: health,info,metrics,configprops,env,refresh,busrefresh
endpoint:
health:
show-details: always
refresh:
enabled: true
busrefresh:
enabled: true
# Logging
logging:
level:
org.springframework.cloud.config: DEBUG
3. Security Configuration for Config Server
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests(authz -> authz
.requestMatchers("/actuator/health").permitAll()
.requestMatchers("/actuator/info").permitAll()
.anyRequest().authenticated()
)
.httpBasic(withDefaults())
.csrf(csrf -> csrf.disable());
return http.build();
}
@Bean
public UserDetailsService userDetailsService() {
UserDetails user = User.withUsername("config-user")
.password("{noop}changeme")
.roles("CONFIG_READER")
.build();
return new InMemoryUserDetailsManager(user);
}
}
4. Custom Environment Repository
@Component
@Slf4j
public class CustomGitEnvironmentRepository implements EnvironmentRepository {
private final GitEnvironmentRepository delegate;
private final RedisTemplate<String, String> redisTemplate;
public CustomGitEnvironmentRepository(GitEnvironmentRepository delegate,
RedisTemplate<String, String> redisTemplate) {
this.delegate = delegate;
this.redisTemplate = redisTemplate;
}
@Override
public Environment findOne(String application, String profile, String label) {
String cacheKey = String.format("config:%s:%s:%s", application, profile, label);
// Try cache first
String cachedConfig = redisTemplate.opsForValue().get(cacheKey);
if (cachedConfig != null) {
log.debug("Returning cached configuration for: {}/{}/{}", application, profile, label);
return deserializeEnvironment(cachedConfig);
}
// Fetch from Git repository
Environment environment = delegate.findOne(application, profile, label);
// Cache the result
try {
String serialized = serializeEnvironment(environment);
redisTemplate.opsForValue().set(cacheKey, serialized, Duration.ofMinutes(5));
} catch (Exception e) {
log.warn("Failed to cache configuration", e);
}
return environment;
}
private String serializeEnvironment(Environment environment) throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
return mapper.writeValueAsString(environment);
}
private Environment deserializeEnvironment(String json) {
try {
ObjectMapper mapper = new ObjectMapper();
return mapper.readValue(json, Environment.class);
} catch (JsonProcessingException e) {
log.warn("Failed to deserialize cached environment", e);
return null;
}
}
}
5. Encryption/Decryption Service
@Service
@Slf4j
public class ConfigEncryptionService {
private final TextEncryptor textEncryptor;
private final ObjectMapper objectMapper;
public ConfigEncryptionService(@Qualifier("configTextEncryptor") TextEncryptor textEncryptor) {
this.textEncryptor = textEncryptor;
this.objectMapper = new ObjectMapper();
}
public String encrypt(String plainText) {
if (plainText == null) {
return null;
}
try {
if (isAlreadyEncrypted(plainText)) {
return plainText;
}
return "{cipher}" + textEncryptor.encrypt(plainText);
} catch (Exception e) {
log.error("Failed to encrypt value", e);
throw new ConfigEncryptionException("Encryption failed", e);
}
}
public String decrypt(String encryptedText) {
if (encryptedText == null) {
return null;
}
try {
if (!isEncrypted(encryptedText)) {
return encryptedText;
}
String cipherText = encryptedText.substring("{cipher}".length());
return textEncryptor.decrypt(cipherText);
} catch (Exception e) {
log.error("Failed to decrypt value: {}", encryptedText, e);
throw new ConfigDecryptionException("Decryption failed", e);
}
}
public Map<String, String> decryptProperties(Map<String, String> properties) {
if (properties == null) {
return Collections.emptyMap();
}
Map<String, String> decrypted = new HashMap<>();
properties.forEach((key, value) -> {
try {
decrypted.put(key, decrypt(value));
} catch (Exception e) {
log.warn("Failed to decrypt property: {}", key, e);
decrypted.put(key, value); // Keep original value on decryption failure
}
});
return decrypted;
}
public boolean isEncrypted(String value) {
return value != null && value.startsWith("{cipher}");
}
private boolean isAlreadyEncrypted(String value) {
return isEncrypted(value);
}
public HealthCheckResult healthCheck() {
try {
String testValue = "config-server-health-check";
String encrypted = encrypt(testValue);
String decrypted = decrypt(encrypted);
boolean healthy = testValue.equals(decrypted);
String message = healthy ? "Encryption/decryption working correctly" : "Encryption test failed";
return new HealthCheckResult(healthy, message, Map.of(
"testValue", testValue,
"encrypted", encrypted,
"decrypted", decrypted
));
} catch (Exception e) {
return new HealthCheckResult(false, "Encryption health check failed: " + e.getMessage(), Map.of());
}
}
}
@Configuration
public class EncryptionConfig {
@Bean
@ConditionalOnProperty(name = "encrypt.key-store.location")
public TextEncryptor configTextEncryptor(
@Value("${encrypt.key-store.location}") String keyStoreLocation,
@Value("${encrypt.key-store.password}") String keyStorePassword,
@Value("${encrypt.key-store.alias}") String keyStoreAlias,
@Value("${encrypt.key-store.secret}") String keyStoreSecret) {
try {
KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(
new ClassPathResource(keyStoreLocation.replace("classpath:", "")),
keyStorePassword.toCharArray()
);
KeyPair keyPair = keyStoreKeyFactory.getKeyPair(keyStoreAlias, keyStoreSecret.toCharArray());
return new RsaTextEncryptor(keyPair);
} catch (Exception e) {
throw new IllegalStateException("Failed to initialize text encryptor", e);
}
}
}
6. Config Server Controller
@RestController
@RequestMapping("/admin")
@Slf4j
public class ConfigAdminController {
private final ConfigEncryptionService encryptionService;
private final EnvironmentRepository environmentRepository;
public ConfigAdminController(ConfigEncryptionService encryptionService,
EnvironmentRepository environmentRepository) {
this.encryptionService = encryptionService;
this.environmentRepository = environmentRepository;
}
@PostMapping("/encrypt")
public ResponseEntity<EncryptionResult> encrypt(@RequestBody EncryptionRequest request) {
try {
String encrypted = encryptionService.encrypt(request.getPlainText());
return ResponseEntity.ok(new EncryptionResult(encrypted, true, "Encryption successful"));
} catch (Exception e) {
log.error("Encryption failed", e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(new EncryptionResult(null, false, "Encryption failed: " + e.getMessage()));
}
}
@PostMapping("/decrypt")
public ResponseEntity<DecryptionResult> decrypt(@RequestBody DecryptionRequest request) {
try {
String decrypted = encryptionService.decrypt(request.getEncryptedText());
return ResponseEntity.ok(new DecryptionResult(decrypted, true, "Decryption successful"));
} catch (Exception e) {
log.error("Decryption failed", e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(new DecryptionResult(null, false, "Decryption failed: " + e.getMessage()));
}
}
@GetMapping("/config/{application}/{profile}/{label}")
public ResponseEntity<Environment> getConfig(
@PathVariable String application,
@PathVariable String profile,
@PathVariable String label) {
try {
Environment environment = environmentRepository.findOne(application, profile, label);
return ResponseEntity.ok(environment);
} catch (Exception e) {
log.error("Failed to get configuration for {}/{}/{}", application, profile, label, e);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
}
}
@GetMapping("/health/encryption")
public ResponseEntity<HealthCheckResult> encryptionHealth() {
HealthCheckResult health = encryptionService.healthCheck();
HttpStatus status = health.isHealthy() ? HttpStatus.OK : HttpStatus.SERVICE_UNAVAILABLE;
return ResponseEntity.status(status).body(health);
}
}
@Data
class EncryptionRequest {
private String plainText;
}
@Data
class EncryptionResult {
private final String encryptedText;
private final boolean success;
private final String message;
}
@Data
class DecryptionRequest {
private String encryptedText;
}
@Data
class DecryptionResult {
private final String decryptedText;
private final boolean success;
private final String message;
}
@Data
class HealthCheckResult {
private final boolean healthy;
private final String message;
private final Map<String, Object> details;
}
Config Client Implementation
1. Client Application Configuration
# bootstrap.yml
spring:
application:
name: user-service
profiles:
active: dev
cloud:
config:
uri: http://config-server:8888
fail-fast: true
retry:
initial-interval: 1000
max-interval: 2000
max-attempts: 6
request-connect-timeout: 5000
request-read-timeout: 5000
username: config-user
password: ${CONFIG_SERVER_PASSWORD:changeme}
label: main
profile: dev,common
bus:
enabled: true
# Application specific configuration
app:
config:
refresh-interval: 300000 # 5 minutes
encryption-enabled: true
2. Configuration Properties Classes
@Configuration
@ConfigurationProperties(prefix = "app.database")
@Data
@RefreshScope
public class DatabaseConfig {
private String url;
private String username;
private String password;
private String driverClassName;
private int maxPoolSize = 10;
private int minIdle = 2;
private long connectionTimeout = 30000;
private long idleTimeout = 300000;
private long maxLifetime = 1800000;
@PostConstruct
public void validate() {
if (url == null || url.trim().isEmpty()) {
throw new IllegalStateException("Database URL must be configured");
}
}
}
@Configuration
@ConfigurationProperties(prefix = "app.security")
@Data
@RefreshScope
public class SecurityConfig {
private String apiKey;
private List<String> allowedOrigins = Arrays.asList("*");
private boolean csrfEnabled = true;
private int jwtExpirationMs = 86400000; // 24 hours
private String jwtSecret;
@PostConstruct
public void validate() {
if (jwtSecret == null || jwtSecret.trim().isEmpty()) {
throw new IllegalStateException("JWT secret must be configured");
}
}
}
@Configuration
@ConfigurationProperties(prefix = "app.feature")
@Data
@RefreshScope
public class FeatureConfig {
private boolean newUserRegistrationEnabled = true;
private boolean emailVerificationRequired = false;
private int maxUsersPerAccount = 10;
private boolean advancedAnalyticsEnabled = false;
private Map<String, Boolean> flags = new HashMap<>();
public boolean isFeatureEnabled(String feature) {
return flags.getOrDefault(feature, false);
}
}
@Configuration
@ConfigurationProperties(prefix = "app.external")
@Data
@RefreshScope
public class ExternalServiceConfig {
private String paymentServiceUrl;
private String emailServiceUrl;
private String notificationServiceUrl;
private int timeoutMs = 5000;
private int maxRetries = 3;
private Map<String, String> headers = new HashMap<>();
}
3. Dynamic Configuration Service
@Service
@Slf4j
public class DynamicConfigService {
private final DatabaseConfig databaseConfig;
private final SecurityConfig securityConfig;
private final FeatureConfig featureConfig;
private final ExternalServiceConfig externalServiceConfig;
private final ContextRefresher contextRefresher;
private final Map<String, Object> configCache = new ConcurrentHashMap<>();
private final AtomicReference<Instant> lastRefresh = new AtomicReference<>(Instant.now());
public DynamicConfigService(DatabaseConfig databaseConfig,
SecurityConfig securityConfig,
FeatureConfig featureConfig,
ExternalServiceConfig externalServiceConfig,
ContextRefresher contextRefresher) {
this.databaseConfig = databaseConfig;
this.securityConfig = securityConfig;
this.featureConfig = featureConfig;
this.externalServiceConfig = externalServiceConfig;
this.contextRefresher = contextRefresher;
initializeCache();
}
public DatabaseConfig getDatabaseConfig() {
return databaseConfig;
}
public SecurityConfig getSecurityConfig() {
return securityConfig;
}
public FeatureConfig getFeatureConfig() {
return featureConfig;
}
public ExternalServiceConfig getExternalServiceConfig() {
return externalServiceConfig;
}
public Map<String, Object> getAllConfig() {
Map<String, Object> config = new HashMap<>();
config.put("database", databaseConfig);
config.put("security", securityConfig);
config.put("features", featureConfig);
config.put("externalServices", externalServiceConfig);
config.put("lastRefresh", lastRefresh.get());
return config;
}
public void refreshConfiguration() {
try {
log.info("Refreshing configuration from Config Server");
Set<String> refreshed = contextRefresher.refresh();
if (!refreshed.isEmpty()) {
log.info("Refreshed configuration properties: {}", refreshed);
lastRefresh.set(Instant.now());
// Update cache
initializeCache();
// Notify listeners
notifyConfigChangeListeners(refreshed);
} else {
log.info("No configuration properties were refreshed");
}
} catch (Exception e) {
log.error("Failed to refresh configuration", e);
throw new ConfigRefreshException("Configuration refresh failed", e);
}
}
public boolean isFeatureEnabled(String feature) {
return featureConfig.isFeatureEnabled(feature);
}
public <T> T getConfigValue(String key, Class<T> type) {
return type.cast(configCache.get(key));
}
public Instant getLastRefreshTime() {
return lastRefresh.get();
}
private void initializeCache() {
configCache.clear();
configCache.put("database.url", databaseConfig.getUrl());
configCache.put("security.apiKey", securityConfig.getApiKey());
configCache.put("feature.newUserRegistration", featureConfig.isNewUserRegistrationEnabled());
configCache.put("external.paymentServiceUrl", externalServiceConfig.getPaymentServiceUrl());
}
private void notifyConfigChangeListeners(Set<String> changedProperties) {
// In a real implementation, you might use ApplicationEventPublisher
// to publish configuration change events
log.debug("Configuration changed: {}", changedProperties);
}
}
4. Configuration-Enabled DataSource
@Configuration
@Slf4j
public class DynamicDataSourceConfig {
@Bean
@RefreshScope
public DataSource dataSource(DatabaseConfig databaseConfig) {
log.info("Creating DataSource with URL: {}", databaseConfig.getUrl());
HikariDataSource dataSource = new HikariDataSource();
dataSource.setJdbcUrl(databaseConfig.getUrl());
dataSource.setUsername(databaseConfig.getUsername());
dataSource.setPassword(databaseConfig.getPassword());
dataSource.setDriverClassName(databaseConfig.getDriverClassName());
dataSource.setMaximumPoolSize(databaseConfig.getMaxPoolSize());
dataSource.setMinimumIdle(databaseConfig.getMinIdle());
dataSource.setConnectionTimeout(databaseConfig.getConnectionTimeout());
dataSource.setIdleTimeout(databaseConfig.getIdleTimeout());
dataSource.setMaxLifetime(databaseConfig.getMaxLifetime());
// Additional HikariCP optimizations
dataSource.setLeakDetectionThreshold(60000);
dataSource.setConnectionTestQuery("SELECT 1");
return dataSource;
}
@Bean
@RefreshScope
public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource) {
LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
em.setDataSource(dataSource);
em.setPackagesToScan("com.example.entity");
em.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
Properties properties = new Properties();
properties.setProperty("hibernate.hbm2ddl.auto", "validate");
properties.setProperty("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect");
properties.setProperty("hibernate.show_sql", "false");
properties.setProperty("hibernate.format_sql", "true");
em.setJpaProperties(properties);
return em;
}
}
5. Configuration Refresh Controller
@RestController
@RequestMapping("/api/config")
@Slf4j
public class ConfigRefreshController {
private final DynamicConfigService configService;
private final ApplicationEventPublisher eventPublisher;
public ConfigRefreshController(DynamicConfigService configService,
ApplicationEventPublisher eventPublisher) {
this.configService = configService;
this.eventPublisher = eventPublisher;
}
@PostMapping("/refresh")
public ResponseEntity<ConfigRefreshResult> refreshConfig() {
try {
configService.refreshConfiguration();
ConfigRefreshResult result = new ConfigRefreshResult(
true,
"Configuration refreshed successfully",
configService.getLastRefreshTime()
);
return ResponseEntity.ok(result);
} catch (ConfigRefreshException e) {
log.error("Configuration refresh failed", e);
ConfigRefreshResult result = new ConfigRefreshResult(
false,
"Configuration refresh failed: " + e.getMessage(),
configService.getLastRefreshTime()
);
return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(result);
}
}
@GetMapping("/current")
public ResponseEntity<Map<String, Object>> getCurrentConfig() {
Map<String, Object> config = configService.getAllConfig();
return ResponseEntity.ok(config);
}
@GetMapping("/features/{feature}")
public ResponseEntity<FeatureStatus> getFeatureStatus(@PathVariable String feature) {
boolean enabled = configService.isFeatureEnabled(feature);
FeatureStatus status = new FeatureStatus(
feature,
enabled,
configService.getLastRefreshTime()
);
return ResponseEntity.ok(status);
}
@PostMapping("/features/{feature}/toggle")
public ResponseEntity<FeatureToggleResult> toggleFeature(@PathVariable String feature) {
// Note: This would typically update the configuration in the Git repository
// For demonstration purposes only
FeatureToggleResult result = new FeatureToggleResult(
feature,
!configService.isFeatureEnabled(feature),
"Feature toggle would update configuration repository"
);
return ResponseEntity.ok(result);
}
}
@Data
class ConfigRefreshResult {
private final boolean success;
private final String message;
private final Instant lastRefresh;
}
@Data
class FeatureStatus {
private final String featureName;
private final boolean enabled;
private final Instant lastRefreshed;
}
@Data
class FeatureToggleResult {
private final String featureName;
private final boolean newState;
private final String message;
}
6. Configuration Change Event Listener
@Component
@Slf4j
public class ConfigChangeEventListener {
private final DynamicConfigService configService;
public ConfigChangeEventListener(DynamicConfigService configService) {
this.configService = configService;
}
@EventListener
public void handleConfigChange(EnvironmentChangeEvent event) {
log.info("Configuration changed: {}", event.getKeys());
// Handle specific configuration changes
event.getKeys().forEach(key -> {
switch (key) {
case "app.feature.newUserRegistrationEnabled":
handleNewUserRegistrationChange();
break;
case "app.security.apiKey":
handleApiKeyChange();
break;
case "app.database.url":
handleDatabaseUrlChange();
break;
default:
log.debug("Configuration changed for key: {}", key);
}
});
}
@EventListener
public void handleRefreshScopeRefreshed(RefreshScopeRefreshedEvent event) {
log.info("Refresh scope was refreshed");
// Perform any necessary cleanup or reinitialization
}
private void handleNewUserRegistrationChange() {
boolean enabled = configService.getFeatureConfig().isNewUserRegistrationEnabled();
log.info("New user registration feature is now: {}", enabled ? "ENABLED" : "DISABLED");
// Notify other components or perform actions based on this change
}
private void handleApiKeyChange() {
log.info("API key was updated");
// Invalidate cached API keys or notify security components
}
private void handleDatabaseUrlChange() {
log.warn("Database URL was changed. Application restart may be required for DataSource reinitialization.");
// In a production scenario, you might want to trigger a DataSource recreation
}
}
7. Health Indicator for Config Client
@Component
public class ConfigClientHealthIndicator implements HealthIndicator {
private final DynamicConfigService configService;
private final ConfigClientProperties configClientProperties;
public ConfigClientHealthIndicator(DynamicConfigService configService,
ConfigClientProperties configClientProperties) {
this.configService = configService;
this.configClientProperties = configClientProperties;
}
@Override
public Health health() {
try {
Map<String, Object> details = new HashMap<>();
details.put("configServerUri", configClientProperties.getUri());
details.put("applicationName", configClientProperties.getName());
details.put("profiles", configClientProperties.getProfile());
details.put("label", configClientProperties.getLabel());
details.put("lastRefresh", configService.getLastRefreshTime());
// Check if essential configurations are present
boolean configValid = isConfigurationValid();
details.put("configurationValid", configValid);
if (configValid) {
return Health.up()
.withDetails(details)
.build();
} else {
return Health.down()
.withDetail("error", "Essential configuration missing")
.withDetails(details)
.build();
}
} catch (Exception e) {
return Health.down()
.withDetail("error", e.getMessage())
.build();
}
}
private boolean isConfigurationValid() {
try {
DatabaseConfig dbConfig = configService.getDatabaseConfig();
SecurityConfig securityConfig = configService.getSecurityConfig();
return dbConfig.getUrl() != null &&
securityConfig.getJwtSecret() != null;
} catch (Exception e) {
return false;
}
}
}
Git Repository Structure
config-repo/ ├── application.yml ├── user-service/ │ ├── application.yml │ ├── application-dev.yml │ ├── application-staging.yml │ └── application-prod.yml ├── order-service/ │ ├── application.yml │ ├── application-dev.yml │ └── application-prod.yml └── common/ ├── database.yml ├── security.yml └── features.yml
Example Configuration Files
# config-repo/application.yml spring: jackson: date-format: yyyy-MM-dd HH:mm:ss time-zone: UTC management: endpoints: web: exposure: include: health,info,metrics,refresh endpoint: health: show-details: always logging: level: com.example: INFO
# config-repo/user-service/application-dev.yml app: database: url: jdbc:postgresql://localhost:5432/userdb_dev username: dev_user password: dev_password max-pool-size: 5 security: api-key: dev-api-key-123 jwt-secret: dev-jwt-secret-456 allowed-origins: - http://localhost:3000 - http://localhost:8080 feature: new-user-registration-enabled: true email-verification-required: false max-users-per-account: 50 external: payment-service-url: http://localhost:8081 email-service-url: http://localhost:8082 timeout-ms: 3000
# config-repo/user-service/application-prod.yml
app:
database:
url: jdbc:postgresql://prod-db:5432/userdb
username: ${DB_USERNAME}
password: '{cipher}AQB...encrypted...XYZ'
max-pool-size: 20
security:
api-key: '{cipher}AQB...encrypted...XYZ'
jwt-secret: '{cipher}AQB...encrypted...XYZ'
allowed-origins:
- https://myapp.com
feature:
new-user-registration-enabled: true
email-verification-required: true
max-users-per-account: 1000
external:
payment-service-url: https://payment.myapp.com
email-service-url: https://email.myapp.com
timeout-ms: 10000
Testing
1. Config Server Test
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@TestPropertySource(properties = {
"spring.cloud.config.server.git.uri=file:./src/test/resources/config-repo",
"spring.cloud.config.server.git.default-label=main"
})
class ConfigServerApplicationTest {
@Autowired
private TestRestTemplate restTemplate;
@Test
void testConfigServerEndpoints() {
ResponseEntity<Environment> response = restTemplate
.withBasicAuth("config-user", "changeme")
.getForEntity("/user-service/dev/main", Environment.class);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(response.getBody()).isNotNull();
}
@Test
void testEncryptionEndpoint() {
EncryptionRequest request = new EncryptionRequest();
request.setPlainText("secret-value");
ResponseEntity<EncryptionResult> response = restTemplate
.withBasicAuth("config-user", "changeme")
.postForEntity("/admin/encrypt", request, EncryptionResult.class);
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(response.getBody()).isNotNull();
assertThat(response.getBody().isSuccess()).isTrue();
assertThat(response.getBody().getEncryptedText()).startsWith("{cipher}");
}
}
2. Config Client Test
@SpringBootTest
@ActiveProfiles("test")
@TestPropertySource(properties = {
"spring.cloud.config.enabled=false",
"app.database.url=jdbc:h2:mem:testdb",
"app.security.jwt-secret=test-secret"
})
class ConfigClientTest {
@Autowired
private DynamicConfigService configService;
@Autowired
private DatabaseConfig databaseConfig;
@Test
void testConfigurationLoading() {
assertThat(databaseConfig.getUrl()).isEqualTo("jdbc:h2:mem:testdb");
assertThat(configService.getFeatureConfig().isNewUserRegistrationEnabled()).isTrue();
}
@Test
void testFeatureToggle() {
assertThat(configService.isFeatureEnabled("newUserRegistration")).isTrue();
}
}
Best Practices
- Environment Separation: Use different profiles for dev, staging, prod
- Sensitive Data Encryption: Always encrypt passwords and API keys
- Configuration Validation: Validate configuration on application startup
- Fail-Fast: Configure clients to fail fast if config server is unavailable
- Monitoring: Monitor config server health and configuration changes
- Version Control: Use Git tags for configuration versions
// Example of configuration validation
@Component
@Slf4j
public class ConfigValidator {
private final DynamicConfigService configService;
@EventListener(ApplicationReadyEvent.class)
public void validateConfiguration() {
log.info("Validating application configuration...");
try {
validateDatabaseConfig();
validateSecurityConfig();
validateExternalServices();
log.info("Configuration validation completed successfully");
} catch (Exception e) {
log.error("Configuration validation failed", e);
throw new IllegalStateException("Invalid configuration", e);
}
}
private void validateDatabaseConfig() {
DatabaseConfig dbConfig = configService.getDatabaseConfig();
if (dbConfig.getUrl() == null || dbConfig.getUrl().trim().isEmpty()) {
throw new ValidationException("Database URL must be configured");
}
}
private void validateSecurityConfig() {
SecurityConfig securityConfig = configService.getSecurityConfig();
if (securityConfig.getJwtSecret() == null || securityConfig.getJwtSecret().trim().isEmpty()) {
throw new ValidationException("JWT secret must be configured");
}
}
private void validateExternalServices() {
ExternalServiceConfig externalConfig = configService.getExternalServiceConfig();
if (externalConfig.getPaymentServiceUrl() == null) {
log.warn("Payment service URL is not configured");
}
}
}
Conclusion
Spring Cloud Config provides:
- Centralized configuration management for distributed systems
- Environment-specific configurations with profile support
- Version control and audit trails through Git integration
- Dynamic configuration updates without application restarts
- Secure sensitive data with encryption support
This comprehensive implementation enables robust configuration management for Java applications, supporting both simple key-value configurations and complex structured configurations with dynamic refresh capabilities. The solution scales from small applications to large microservices architectures while maintaining security and reliability.
Java Logistics, Shipping Integration & Enterprise Inventory Automation (Tracking, ERP, RFID & Billing Systems)
https://macronepal.com/blog/aftership-tracking-in-java-enterprise-package-visibility/
Explains how to integrate AfterShip tracking services into Java applications to provide real-time shipment visibility, delivery status updates, and centralized tracking across multiple courier services.
https://macronepal.com/blog/shipping-integration-using-fedex-api-with-java-for-logistics-automation/
Explains how to integrate the FedEx API into Java systems to automate shipping tasks such as creating shipments, calculating delivery costs, generating shipping labels, and tracking packages.
https://macronepal.com/blog/shipping-and-logistics-integrating-ups-apis-with-java-applications/
Explains UPS API integration in Java to enable automated shipping operations including rate calculation, shipment scheduling, tracking, and delivery confirmation management.
https://macronepal.com/blog/generating-and-reading-qr-codes-for-products-in-java/
Explains how Java applications generate and read QR codes for product identification, tracking, and authentication, supporting faster inventory handling and product verification processes.
https://macronepal.com/blog/designing-a-robust-pick-and-pack-workflow-in-java/
Explains how to design an efficient pick-and-pack workflow in Java warehouse systems, covering order processing, item selection, packaging steps, and logistics preparation to improve fulfillment efficiency.
https://macronepal.com/blog/rfid-inventory-management-system-in-java-a-complete-guide/
Explains how RFID technology integrates with Java applications to automate inventory tracking, reduce manual errors, and enable real-time stock monitoring in warehouses and retail environments.
https://macronepal.com/blog/erp-integration-with-odoo-in-java/
Explains how Java applications connect with Odoo ERP systems to synchronize inventory, orders, customer records, and financial data across enterprise systems.
https://macronepal.com/blog/automated-invoice-generation-creating-professional-excel-invoices-with-apache-poi-in-java/
Explains how to automatically generate professional Excel invoices in Java using Apache POI, enabling structured billing documents and automated financial record creation.
https://macronepal.com/blog/enterprise-financial-integration-using-quickbooks-api-in-java-applications/
Explains QuickBooks API integration in Java to automate financial workflows such as invoice management, payment tracking, accounting synchronization, and financial reporting.