Dynamic Feature Control: Implementing Robust Feature Toggles in Java Applications

Feature toggles (or feature flags) are a powerful technique that allows you to modify system behavior without changing code. They enable gradual rollouts, A/B testing, emergency kill switches, and environment-specific functionality. Let's explore how to implement robust feature toggles in Java applications using various configuration strategies.

Architecture Overview

Feature Toggle Config → Toggle Manager → Feature Service → Application Code ↑ (Dynamic Sources: File, Database, ConfigMap, Redis)

Strategy 1: Spring Boot Configuration-Based Toggles

Dependencies

<!-- pom.xml --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>

Basic Toggle Configuration

// src/main/java/com/company/feature/FeatureConfig.java @Configuration @ConfigurationProperties(prefix = "features") @Data public class FeatureConfig { private Map<String, Boolean> toggles = new HashMap<>(); private Map<String, PercentageToggle> percentageToggles = new HashMap<>(); private Map<String, String> variantToggles = new HashMap<>(); @Data public static class PercentageToggle { private int percentage; private boolean defaultWhenDisabled = false; } }

Application Properties

# application.yml features: toggles: new-payment-gateway: true advanced-reporting: false dark-mode: true social-login: false percentage-toggles: beta-feature: percentage: 10 default-when-disabled: false gradual-rollout: percentage: 50 default-when-disabled: true variant-toggles: theme-color: "blue" pricing-tier: "premium" api-version: "v2" management: endpoints: web: exposure: include: features,health,info

Strategy 2: Advanced Feature Toggle Service

Core Feature Toggle Interface

// src/main/java/com/company/feature/FeatureToggleService.java public interface FeatureToggleService { boolean isEnabled(String featureName); boolean isEnabled(String featureName, String userId); String getVariant(String featureName); String getVariant(String featureName, String userId); void refreshToggles(); Map<String, Object> getAllToggles(); }

Implementation with Refreshable Configuration

// src/main/java/com/company/feature/ConfigFeatureToggleService.java @Service @Slf4j public class ConfigFeatureToggleService implements FeatureToggleService { private final FeatureConfig featureConfig; private final ObjectMapper objectMapper; private final Random random; // Cache for user-based consistent decisions private final Map<String, Map<String, Boolean>> userFeatureCache = new ConcurrentHashMap<>(); public ConfigFeatureToggleService(FeatureConfig featureConfig, ObjectMapper objectMapper) { this.featureConfig = featureConfig; this.objectMapper = objectMapper; this.random = new Random(); } @Override public boolean isEnabled(String featureName) { return isEnabled(featureName, null); } @Override public boolean isEnabled(String featureName, String userId) { // Check simple boolean toggles first Boolean simpleToggle = featureConfig.getToggles().get(featureName); if (simpleToggle != null) { return simpleToggle; } // Check percentage-based toggles FeatureConfig.PercentageToggle percentageToggle = featureConfig.getPercentageToggles().get(featureName); if (percentageToggle != null) { return isPercentageEnabled(featureName, percentageToggle, userId); } log.warn("Feature toggle not found: {}", featureName); return false; } private boolean isPercentageEnabled(String featureName, FeatureConfig.PercentageToggle toggle, String userId) { if (userId != null) { // Consistent behavior for same user return getUserPercentageDecision(featureName, toggle, userId); } else { // Random decision for anonymous users return random.nextInt(100) < toggle.getPercentage(); } } private boolean getUserPercentageDecision(String featureName, FeatureConfig.PercentageToggle toggle, String userId) { return userFeatureCache .computeIfAbsent(userId, k -> new HashMap<>()) .computeIfAbsent(featureName, k -> { // Deterministic based on user ID int hash = Math.abs(userId.hashCode()); return (hash % 100) < toggle.getPercentage(); }); } @Override public String getVariant(String featureName) { return getVariant(featureName, null); } @Override public String getVariant(String featureName, String userId) { String variant = featureConfig.getVariantToggles().get(featureName); return variant != null ? variant : "default"; } @Override public void refreshToggles() { userFeatureCache.clear(); log.info("Feature toggle cache cleared"); } @Override public Map<String, Object> getAllToggles() { Map<String, Object> allToggles = new HashMap<>(); allToggles.put("booleanToggles", featureConfig.getToggles()); allToggles.put("percentageToggles", featureConfig.getPercentageToggles()); allToggles.put("variantToggles", featureConfig.getVariantToggles()); return allToggles; } }

Strategy 3: Dynamic Feature Toggles with Database Backend

Database Schema

-- feature_toggles.sql CREATE TABLE feature_toggles ( id BIGINT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255) NOT NULL UNIQUE, enabled BOOLEAN DEFAULT FALSE, percentage INT DEFAULT 0, variant VARCHAR(100), target_users JSON, start_time TIMESTAMP NULL, end_time TIMESTAMP NULL, created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP ); CREATE TABLE feature_toggle_audit ( id BIGINT AUTO_INCREMENT PRIMARY KEY, feature_name VARCHAR(255) NOT NULL, user_id VARCHAR(255), enabled BOOLEAN, accessed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP );

JPA Entity and Repository

// src/main/java/com/company/feature/entity/FeatureToggle.java @Entity @Table(name = "feature_toggles") @Data @EntityListeners(AuditingEntityListener.class) public class FeatureToggle { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; @Column(unique = true, nullable = false) private String name; private Boolean enabled = false; private Integer percentage = 0; private String variant; @Column(columnDefinition = "JSON") private String targetUsers; // JSON array of user IDs private Instant startTime; private Instant endTime; @CreatedDate private Instant createdAt; @LastModifiedDate private Instant updatedAt; @Transient public List<String> getTargetUserList() { if (targetUsers == null || targetUsers.trim().isEmpty()) { return Collections.emptyList(); } try { return Arrays.asList(new ObjectMapper().readValue(targetUsers, String[].class)); } catch (Exception e) { return Collections.emptyList(); } } } // Repository @Repository public interface FeatureToggleRepository extends JpaRepository<FeatureToggle, Long> { Optional<FeatureToggle> findByName(String name); List<FeatureToggle> findByEnabledTrue(); }

Advanced Database Feature Service

// src/main/java/com/company/feature/DatabaseFeatureToggleService.java @Service @Slf4j public class DatabaseFeatureToggleService implements FeatureToggleService { private final FeatureToggleRepository repository; private final FeatureToggleAuditRepository auditRepository; private final ObjectMapper objectMapper; // Local cache with TTL private final Cache<String, FeatureToggle> toggleCache = Caffeine.newBuilder() .expireAfterWrite(5, TimeUnit.MINUTES) .maximumSize(1000) .build(); public DatabaseFeatureToggleService(FeatureToggleRepository repository, FeatureToggleAuditRepository auditRepository, ObjectMapper objectMapper) { this.repository = repository; this.auditRepository = auditRepository; this.objectMapper = objectMapper; } @Override public boolean isEnabled(String featureName) { return isEnabled(featureName, null); } @Override public boolean isEnabled(String featureName, String userId) { FeatureToggle toggle = getToggle(featureName); if (toggle == null) { log.warn("Feature toggle not found: {}", featureName); auditAccess(featureName, userId, false); return false; } boolean enabled = evaluateToggle(toggle, userId); auditAccess(featureName, userId, enabled); return enabled; } private FeatureToggle getToggle(String featureName) { return toggleCache.get(featureName, key -> repository.findByName(key).orElse(null) ); } private boolean evaluateToggle(FeatureToggle toggle, String userId) { // Check time window if (!isWithinTimeWindow(toggle)) { return false; } // Check targeted users if (userId != null && !toggle.getTargetUserList().isEmpty()) { return toggle.getTargetUserList().contains(userId); } // Check percentage rollout if (toggle.getPercentage() > 0 && userId != null) { return isUserInPercentage(toggle.getName(), userId, toggle.getPercentage()); } // Simple boolean toggle return Boolean.TRUE.equals(toggle.getEnabled()); } private boolean isWithinTimeWindow(FeatureToggle toggle) { Instant now = Instant.now(); return (toggle.getStartTime() == null || !now.isBefore(toggle.getStartTime())) && (toggle.getEndTime() == null || !now.isAfter(toggle.getEndTime())); } private boolean isUserInPercentage(String featureName, String userId, int percentage) { // Consistent hashing for same user int hash = Math.abs((featureName + ":" + userId).hashCode()); return (hash % 100) < percentage; } private void auditAccess(String featureName, String userId, boolean enabled) { try { FeatureToggleAudit audit = new FeatureToggleAudit(); audit.setFeatureName(featureName); audit.setUserId(userId); audit.setEnabled(enabled); auditRepository.save(audit); } catch (Exception e) { log.warn("Failed to audit feature toggle access", e); } } @Override public void refreshToggles() { toggleCache.invalidateAll(); log.info("Feature toggle cache refreshed"); } @Scheduled(fixedRate = 60000) // Refresh every minute public void scheduledRefresh() { refreshToggles(); } }

Strategy 4: Kubernetes ConfigMap-Based Feature Toggles

ConfigMap Definition

# k8s/feature-toggles-configmap.yaml apiVersion: v1 kind: ConfigMap metadata: name: feature-toggles labels: app: java-app data: features.json: | { "toggles": { "new-ui": true, "beta-features": false, "payment-v2": true }, "percentageToggles": { "gradual-migration": { "percentage": 25, "defaultWhenDisabled": true } }, "variants": { "theme": "dark", "api-version": "v2" } }

ConfigMap Watcher Integration

// src/main/java/com/company/feature/ConfigMapFeatureManager.java @Component @Slf4j public class ConfigMapFeatureManager { private final FeatureToggleService featureService; private final ObjectMapper objectMapper; private volatile String currentConfigHash; public ConfigMapFeatureManager(FeatureToggleService featureService, ObjectMapper objectMapper) { this.featureService = featureService; this.objectMapper = objectMapper; } @EventListener public void onConfigMapUpdate(ConfigMapUpdateEvent event) { if (event.getConfigData().containsKey("features.json")) { try { String newConfig = event.getConfigData().get("features.json"); String newHash = calculateHash(newConfig); if (!newHash.equals(currentConfigHash)) { updateFeatures(newConfig); currentConfigHash = newHash; log.info("Feature toggles updated from ConfigMap"); } } catch (Exception e) { log.error("Failed to update features from ConfigMap", e); } } } private void updateFeatures(String configJson) throws Exception { FeatureConfig newConfig = objectMapper.readValue(configJson, FeatureConfig.class); // In a real implementation, you would update the feature service featureService.refreshToggles(); } private String calculateHash(String content) { try { MessageDigest digest = MessageDigest.getInstance("SHA-256"); byte[] hash = digest.digest(content.getBytes()); return Base64.getEncoder().encodeToString(hash); } catch (Exception e) { return content; // Fallback to content comparison } } }

Strategy 5: Feature Toggle Controllers and Management

REST API for Feature Management

// src/main/java/com/company/feature/FeatureToggleController.java @RestController @RequestMapping("/api/features") @Validated @Slf4j public class FeatureToggleController { private final FeatureToggleService featureService; public FeatureToggleController(FeatureToggleService featureService) { this.featureService = featureService; } @GetMapping public Map<String, Object> getAllFeatures() { return featureService.getAllToggles(); } @GetMapping("/{featureName}/enabled") public boolean isFeatureEnabled(@PathVariable String featureName, @RequestParam(required = false) String userId) { return featureService.isEnabled(featureName, userId); } @GetMapping("/{featureName}/variant") public String getFeatureVariant(@PathVariable String featureName, @RequestParam(required = false) String userId) { return featureService.getVariant(featureName, userId); } @PostMapping("/refresh") public ResponseEntity<Void> refreshFeatures() { featureService.refreshToggles(); return ResponseEntity.ok().build(); } }

Spring Boot Actuator Endpoint

// src/main/java/com/company/feature/FeatureToggleEndpoint.java @Component @Endpoint(id = "features") @Slf4j public class FeatureToggleEndpoint { private final FeatureToggleService featureService; public FeatureToggleEndpoint(FeatureToggleService featureService) { this.featureService = featureService; } @ReadOperation public Map<String, Object> features() { return featureService.getAllToggles(); } @WriteOperation public void refresh() { featureService.refreshToggles(); } }

Practical Usage Examples

1. Gradual Feature Rollout

// src/main/java/com/company/service/PaymentService.java @Service @Slf4j public class PaymentService { private final FeatureToggleService featureToggle; private final PaymentGatewayV1 gatewayV1; private final PaymentGatewayV2 gatewayV2; public PaymentService(FeatureToggleService featureToggle, PaymentGatewayV1 gatewayV1, PaymentGatewayV2 gatewayV2) { this.featureToggle = featureToggle; this.gatewayV1 = gatewayV1; this.gatewayV2 = gatewayV2; } public PaymentResult processPayment(PaymentRequest request, String userId) { if (featureToggle.isEnabled("payment-gateway-v2", userId)) { log.info("Using payment gateway V2 for user: {}", userId); return gatewayV2.process(request); } else { log.info("Using payment gateway V1 for user: {}", userId); return gatewayV1.process(request); } } }

2. A/B Testing

// src/main/java/com/company/service/RecommendationService.java @Service public class RecommendationService { private final FeatureToggleService featureToggle; private final AlgorithmA algorithmA; private final AlgorithmB algorithmB; public List<Product> getRecommendations(String userId) { String variant = featureToggle.getVariant("recommendation-algorithm", userId); switch (variant) { case "algorithm-a": return algorithmA.getRecommendations(userId); case "algorithm-b": return algorithmB.getRecommendations(userId); default: return algorithmA.getRecommendations(userId); } } public void trackRecommendationPerformance(String userId, String productId, boolean purchased) { String variant = featureToggle.getVariant("recommendation-algorithm", userId); // Send to analytics for A/B test evaluation analyticsService.trackConversion(variant, userId, productId, purchased); } }

3. Emergency Kill Switch

// src/main/java/com/company/service/DataExportService.java @Service public class DataExportService { private final FeatureToggleService featureToggle; @Async public CompletableFuture<ExportResult> exportUserData(String userId) { // Check kill switch before starting expensive operation if (!featureToggle.isEnabled("data-export-enabled")) { throw new FeatureDisabledException("Data export feature is currently disabled"); } return CompletableFuture.supplyAsync(() -> { // Perform expensive data export return performExport(userId); }); } }

Testing Feature Toggles

Unit Tests

// src/test/java/com/company/feature/FeatureToggleServiceTest.java @ExtendWith(MockitoExtension.class) class FeatureToggleServiceTest { @Mock private FeatureConfig featureConfig; @InjectMocks private ConfigFeatureToggleService featureService; @Test void testFeatureEnabled() { // Given Map<String, Boolean> toggles = new HashMap<>(); toggles.put("new-feature", true); when(featureConfig.getToggles()).thenReturn(toggles); // When boolean enabled = featureService.isEnabled("new-feature"); // Then assertThat(enabled).isTrue(); } @Test void testPercentageToggleConsistency() { // Given String userId = "user-123"; FeatureConfig.PercentageToggle toggle = new FeatureConfig.PercentageToggle(); toggle.setPercentage(50); Map<String, FeatureConfig.PercentageToggle> percentageToggles = new HashMap<>(); percentageToggles.put("gradual-rollout", toggle); when(featureConfig.getPercentageToggles()).thenReturn(percentageToggles); // When - multiple calls should return same result boolean firstCall = featureService.isEnabled("gradual-rollout", userId); boolean secondCall = featureService.isEnabled("gradual-rollout", userId); // Then assertThat(firstCall).isEqualTo(secondCall); } }

Integration Test

// src/test/java/com/company/feature/FeatureToggleIT.java @SpringBootTest @TestPropertySource(properties = { "features.toggles.new-ui=true", "features.percentage-toggles.beta-feature.percentage=25" }) class FeatureToggleIT { @Autowired private FeatureToggleService featureService; @Test void testFeatureToggleIntegration() { assertThat(featureService.isEnabled("new-ui")).isTrue(); assertThat(featureService.isEnabled("non-existent")).isFalse(); } }

Best Practices

Toggle Lifetime Management

Regularly clean up old feature toggles
Use naming conventions (e.g., feat-*, kill-*, ops-*)
Document toggle purpose and ownership

Monitoring and Observability

Log toggle evaluations for debugging
Track toggle usage metrics
Set up alerts for critical kill switches

Security

Restrict toggle modification permissions
Validate toggle configurations
Audit toggle changes

Performance

Cache toggle states appropriately
Use efficient data structures for user-based toggles
Minimize network calls for remote toggle services

Conclusion

Feature toggles are essential for modern Java applications, enabling:

Safe deployments with gradual rollouts
A/B testing and data-driven decisions
Operational control with kill switches
Environment-specific behavior without code changes

Choose the right strategy based on your needs:

Configuration-based: Simple, suitable for most applications
Database-backed: Dynamic, great for runtime management
External services: Enterprise-grade, full-featured

By implementing robust feature toggles, you gain unprecedented control over your application's behavior while maintaining stability and enabling rapid innovation.

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.