Comprehensive A/B Testing Implementation

1. Core Experiment Configuration

public class ExperimentConfig { private final String experimentId; private final String experimentName; private final Map<String, Double> variantWeights; private final Set<String> targetAudience; private final Instant startTime; private final Instant endTime; private final boolean isActive; private final Map<String, Object> customParameters; public ExperimentConfig(Builder builder) { this.experimentId = builder.experimentId; this.experimentName = builder.experimentName; this.variantWeights = Map.copyOf(builder.variantWeights); this.targetAudience = Set.copyOf(builder.targetAudience); this.startTime = builder.startTime; this.endTime = builder.endTime; this.isActive = builder.isActive; this.customParameters = Map.copyOf(builder.customParameters); } public static class Builder { private String experimentId; private String experimentName; private Map<String, Double> variantWeights = new HashMap<>(); private Set<String> targetAudience = new HashSet<>(); private Instant startTime; private Instant endTime; private boolean isActive = true; private Map<String, Object> customParameters = new HashMap<>(); public Builder(String experimentId, String experimentName) { this.experimentId = experimentId; this.experimentName = experimentName; } public Builder addVariant(String variantName, double weight) { this.variantWeights.put(variantName, weight); return this; } public Builder targetAudience(Set<String> audience) { this.targetAudience = audience; return this; } public Builder timeRange(Instant start, Instant end) { this.startTime = start; this.endTime = end; return this; } public Builder active(boolean active) { this.isActive = active; return this; } public Builder customParameter(String key, Object value) { this.customParameters.put(key, value); return this; } public ExperimentConfig build() { validate(); return new ExperimentConfig(this); } private void validate() { if (experimentId == null || experimentId.trim().isEmpty()) { throw new IllegalArgumentException("Experiment ID cannot be null or empty"); } if (variantWeights.isEmpty()) { throw new IllegalArgumentException("At least one variant must be defined"); } double totalWeight = variantWeights.values().stream().mapToDouble(Double::doubleValue).sum(); if (Math.abs(totalWeight - 1.0) > 0.001) { throw new IllegalArgumentException("Variant weights must sum to 1.0"); } } } // Getters public String getExperimentId() { return experimentId; } public Map<String, Double> getVariantWeights() { return variantWeights; } public boolean isActive() { return isActive; } public boolean isInTimeRange() { Instant now = Instant.now(); return !now.isBefore(startTime) && !now.isAfter(endTime); } }

2. User Assignment Service

@Component public class VariantAssignmentService { private final HashFunction hashFunction = Hashing.murmur3_32_fixed(); private final double MAX_TRAFFIC_PERCENTAGE = 1.0; public Assignment assignVariant(String userId, ExperimentConfig experiment) { if (!experiment.isActive() || !experiment.isInTimeRange()) { return Assignment.defaultVariant(experiment.getExperimentId()); } String assignmentKey = experiment.getExperimentId() + ":" + userId; int hash = Math.abs(hashFunction.hashUnencodedChars(assignmentKey).asInt()); double trafficAllocation = (hash % 10000) / 10000.0; if (trafficAllocation > MAX_TRAFFIC_PERCENTAGE) { return Assignment.defaultVariant(experiment.getExperimentId()); } String variant = determineVariant(trafficAllocation, experiment.getVariantWeights()); return new Assignment(experiment.getExperimentId(), variant, true); } private String determineVariant(double trafficAllocation, Map<String, Double> variantWeights) { double cumulativeWeight = 0.0; for (Map.Entry<String, Double> entry : variantWeights.entrySet()) { cumulativeWeight += entry.getValue(); if (trafficAllocation < cumulativeWeight) { return entry.getKey(); } } return variantWeights.keySet().iterator().next(); // Fallback } } public class Assignment { private final String experimentId; private final String variant; private final boolean assigned; private final Instant assignmentTime; public Assignment(String experimentId, String variant, boolean assigned) { this.experimentId = experimentId; this.variant = variant; this.assigned = assigned; this.assignmentTime = Instant.now(); } public static Assignment defaultVariant(String experimentId) { return new Assignment(experimentId, "control", false); } // Getters public String getVariant() { return variant; } public boolean isAssigned() { return assigned; } }

3. Experiment Manager

@Component public class ExperimentManager { private final Map<String, ExperimentConfig> experiments = new ConcurrentHashMap<>(); private final VariantAssignmentService assignmentService; private final EventTrackingService eventTrackingService; public ExperimentManager(VariantAssignmentService assignmentService, EventTrackingService eventTrackingService) { this.assignmentService = assignmentService; this.eventTrackingService = eventTrackingService; } public void registerExperiment(ExperimentConfig experiment) { experiments.put(experiment.getExperimentId(), experiment); } public Assignment getAssignment(String userId, String experimentId) { ExperimentConfig experiment = experiments.get(experimentId); if (experiment == null) { return Assignment.defaultVariant(experimentId); } return assignmentService.assignVariant(userId, experiment); } public <T> T executeWithVariant(String userId, String experimentId, ExperimentFunction<T> function) { Assignment assignment = getAssignment(userId, experimentId); try { T result = function.execute(assignment.getVariant()); trackEvent(userId, experimentId, assignment.getVariant(), "success"); return result; } catch (Exception e) { trackEvent(userId, experimentId, assignment.getVariant(), "error"); throw e; } } public void trackEvent(String userId, String experimentId, String variant, String eventType) { ExperimentEvent event = new ExperimentEvent(userId, experimentId, variant, eventType); eventTrackingService.trackEvent(event); } @FunctionalInterface public interface ExperimentFunction<T> { T execute(String variant); } }

4. Event Tracking and Analytics

@Component public class EventTrackingService { private final MeterRegistry meterRegistry; private final List<EventStorage> storageBackends; public EventTrackingService(MeterRegistry meterRegistry, List<EventStorage> storageBackends) { this.meterRegistry = meterRegistry; this.storageBackends = storageBackends; } public void trackEvent(ExperimentEvent event) { // Record metrics meterRegistry.counter("abtesting.events", "experiment", event.getExperimentId(), "variant", event.getVariant(), "event_type", event.getEventType() ).increment(); // Store event in all backends storageBackends.forEach(backend -> backend.store(event)); } public ExperimentStats calculateStats(String experimentId, Instant start, Instant end) { // Implementation for calculating conversion rates, confidence intervals, etc. return new ExperimentStats(experimentId, start, end); } } public class ExperimentEvent { private final String userId; private final String experimentId; private final String variant; private final String eventType; private final Instant timestamp; private final Map<String, Object> properties; public ExperimentEvent(String userId, String experimentId, String variant, String eventType) { this.userId = userId; this.experimentId = experimentId; this.variant = variant; this.eventType = eventType; this.timestamp = Instant.now(); this.properties = new HashMap<>(); } public ExperimentEvent withProperty(String key, Object value) { this.properties.put(key, value); return this; } // Getters public String getExperimentId() { return experimentId; } public String getVariant() { return variant; } public String getEventType() { return eventType; } }

5. Statistical Analysis Service

@Component public class StatisticalAnalysisService { private static final double CONFIDENCE_LEVEL = 0.95; private static final double SIGNIFICANCE_LEVEL = 0.05; public ExperimentResult analyzeExperiment(ExperimentData data) { Map<String, VariantStats> variantStats = calculateVariantStats(data); boolean isSignificant = calculateSignificance(variantStats); return new ExperimentResult(data.getExperimentId(), variantStats, isSignificant); } private Map<String, VariantStats> calculateVariantStats(ExperimentData data) { return data.getVariants().stream() .collect(Collectors.toMap( VariantData::getVariantName, this::calculateVariantStatistics )); } private VariantStats calculateVariantStatistics(VariantData variantData) { long visitors = variantData.getTotalVisitors(); long conversions = variantData.getConversions(); double conversionRate = (double) conversions / visitors; double standardError = calculateStandardError(conversionRate, visitors); double confidenceInterval = calculateConfidenceInterval(standardError); return new VariantStats( visitors, conversions, conversionRate, confidenceInterval ); } private boolean calculateSignificance(Map<String, VariantStats> variantStats) { // Implement chi-squared test or t-test VariantStats control = variantStats.get("control"); if (control == null) return false; return variantStats.entrySet().stream() .filter(entry -> !"control".equals(entry.getKey())) .anyMatch(entry -> isStatisticallySignificant(control, entry.getValue())); } private boolean isStatisticallySignificant(VariantStats control, VariantStats variant) { // Simplified significance calculation double zScore = calculateZScore(control, variant); return Math.abs(zScore) > 1.96; // For 95% confidence } private double calculateZScore(VariantStats control, VariantStats variant) { double p1 = control.getConversionRate(); double p2 = variant.getConversionRate(); long n1 = control.getVisitors(); long n2 = variant.getVisitors(); double p = (p1 * n1 + p2 * n2) / (n1 + n2); double standardError = Math.sqrt(p * (1 - p) * (1.0 / n1 + 1.0 / n2)); return (p2 - p1) / standardError; } private double calculateStandardError(double proportion, long sampleSize) { return Math.sqrt(proportion * (1 - proportion) / sampleSize); } private double calculateConfidenceInterval(double standardError) { return 1.96 * standardError; // Z-score for 95% confidence } } public class ExperimentResult { private final String experimentId; private final Map<String, VariantStats> variantStats; private final boolean statisticallySignificant; private final String winningVariant; public ExperimentResult(String experimentId, Map<String, VariantStats> variantStats, boolean statisticallySignificant) { this.experimentId = experimentId; this.variantStats = variantStats; this.statisticallySignificant = statisticallySignificant; this.winningVariant = determineWinningVariant(variantStats); } private String determineWinningVariant(Map<String, VariantStats> variantStats) { return variantStats.entrySet().stream() .max(Comparator.comparingDouble(entry -> entry.getValue().getConversionRate())) .map(Map.Entry::getKey) .orElse("control"); } // Getters public boolean isStatisticallySignificant() { return statisticallySignificant; } public String getWinningVariant() { return winningVariant; } }

6. Spring Boot Configuration

@Configuration @EnableConfigurationProperties(ABTestingProperties.class) public class ABTestingAutoConfiguration { @Bean public VariantAssignmentService variantAssignmentService() { return new VariantAssignmentService(); } @Bean public EventTrackingService eventTrackingService(MeterRegistry meterRegistry) { List<EventStorage> storageBackends = Arrays.asList( new DatabaseEventStorage(), new AnalyticsEventStorage() ); return new EventTrackingService(meterRegistry, storageBackends); } @Bean public ExperimentManager experimentManager(VariantAssignmentService assignmentService, EventTrackingService eventTrackingService) { return new ExperimentManager(assignmentService, eventTrackingService); } @Bean public StatisticalAnalysisService statisticalAnalysisService() { return new StatisticalAnalysisService(); } } @ConfigurationProperties(prefix = "ab-testing") public class ABTestingProperties { private boolean enabled = true; private String defaultVariant = "control"; private int hashSeed = 42; private Duration analysisPeriod = Duration.ofHours(24); // Getters and setters public boolean isEnabled() { return enabled; } public void setEnabled(boolean enabled) { this.enabled = enabled; } public String getDefaultVariant() { return defaultVariant; } public void setDefaultVariant(String defaultVariant) { this.defaultVariant = defaultVariant; } }

7. REST Controller for Experiment Management

@RestController @RequestMapping("/api/experiments") public class ExperimentController { private final ExperimentManager experimentManager; private final StatisticalAnalysisService analysisService; public ExperimentController(ExperimentManager experimentManager, StatisticalAnalysisService analysisService) { this.experimentManager = experimentManager; this.analysisService = analysisService; } @PostMapping public ResponseEntity<ExperimentConfig> createExperiment(@RequestBody ExperimentConfig config) { experimentManager.registerExperiment(config); return ResponseEntity.ok(config); } @GetMapping("/{experimentId}/assignment") public ResponseEntity<Assignment> getAssignment( @PathVariable String experimentId, @RequestParam String userId) { Assignment assignment = experimentManager.getAssignment(userId, experimentId); return ResponseEntity.ok(assignment); } @PostMapping("/{experimentId}/track") public ResponseEntity<Void> trackEvent( @PathVariable String experimentId, @RequestParam String userId, @RequestParam String variant, @RequestParam String eventType) { experimentManager.trackEvent(userId, experimentId, variant, eventType); return ResponseEntity.accepted().build(); } @GetMapping("/{experimentId}/results") public ResponseEntity<ExperimentResult> getResults(@PathVariable String experimentId) { // This would typically fetch data from storage and analyze ExperimentData data = fetchExperimentData(experimentId); ExperimentResult result = analysisService.analyzeExperiment(data); return ResponseEntity.ok(result); } private ExperimentData fetchExperimentData(String experimentId) { // Implementation to fetch experiment data from database return new ExperimentData(experimentId, List.of()); } }

8. Feature Toggle Integration

@Component public class FeatureToggleService { private final ExperimentManager experimentManager; public FeatureToggleService(ExperimentManager experimentManager) { this.experimentManager = experimentManager; } public boolean isFeatureEnabled(String featureName, String userId) { return experimentManager.executeWithVariant(userId, featureName, variant -> { return "enabled".equals(variant) || "treatment".equals(variant); }); } public <T> T getFeatureConfig(String featureName, String userId, Function<String, T> configMapper) { return experimentManager.executeWithVariant(userId, featureName, configMapper::apply); } }

9. Example Usage in Business Logic

@Service public class ProductService { private final ExperimentManager experimentManager; private final FeatureToggleService featureToggleService; public ProductService(ExperimentManager experimentManager, FeatureToggleService featureToggleService) { this.experimentManager = experimentManager; this.featureToggleService = featureToggleService; } public ProductRecommendation getRecommendations(String userId, String category) { // A/B test for recommendation algorithm return experimentManager.executeWithVariant(userId, "recommendation_algorithm", variant -> { switch (variant) { case "collaborative_filtering": return collaborativeFilteringRecommendations(userId, category); case "content_based": return contentBasedRecommendations(userId, category); default: return defaultRecommendations(userId, category); } }); } public ProductDetail getProductDetail(String userId, String productId) { // Feature flag for new UI if (featureToggleService.isFeatureEnabled("new_product_ui", userId)) { return getEnhancedProductDetail(productId); } else { return getLegacyProductDetail(productId); } } public void trackProductView(String userId, String productId) { // Get assignment and track view event Assignment assignment = experimentManager.getAssignment(userId, "product_layout"); experimentManager.trackEvent(userId, "product_layout", assignment.getVariant(), "product_view"); // Additional tracking with properties experimentManager.trackEvent(userId, "product_layout", assignment.getVariant(), "product_view_with_properties") .withProperty("product_id", productId) .withProperty("category", getProductCategory(productId)); } private ProductRecommendation collaborativeFilteringRecommendations(String userId, String category) { // Implementation return new ProductRecommendation(); } private ProductRecommendation contentBasedRecommendations(String userId, String category) { // Implementation return new ProductRecommendation(); } private ProductRecommendation defaultRecommendations(String userId, String category) { // Implementation return new ProductRecommendation(); } }

10. Testing Framework

@ExtendWith(SpringExtension.class) @SpringBootTest class ABTestingTest { @Autowired private ExperimentManager experimentManager; @Test void testVariantAssignmentConsistency() { String userId = "user123"; String experimentId = "test_experiment"; Assignment firstAssignment = experimentManager.getAssignment(userId, experimentId); Assignment secondAssignment = experimentManager.getAssignment(userId, experimentId); assertEquals(firstAssignment.getVariant(), secondAssignment.getVariant()); } @Test void testTrafficDistribution() { Map<String, Integer> variantCounts = new HashMap<>(); int totalUsers = 10000; for (int i = 0; i < totalUsers; i++) { String userId = "user_" + i; Assignment assignment = experimentManager.getAssignment(userId, "distribution_test"); variantCounts.merge(assignment.getVariant(), 1, Integer::sum); } // Verify distribution is within expected bounds double controlPercentage = (double) variantCounts.get("control") / totalUsers; assertTrue(controlPercentage > 0.48 && controlPercentage < 0.52); // 50% distribution } }

Configuration Example

# application.yml ab-testing: enabled: true default-variant: "control" hash-seed: 42 analysis-period: 24h experiments: recommendation_algorithm: name: "Product Recommendation Algorithm Test" variants: control: 0.33 collaborative_filtering: 0.33 content_based: 0.34 start-time: 2024-01-01T00:00:00Z end-time: 2024-02-01T00:00:00Z active: true product_layout: name: "New Product Page Layout" variants: control: 0.5 new_layout: 0.5 start-time: 2024-01-01T00:00:00Z end-time: 2024-03-01T00:00:00Z active: true

This comprehensive A/B testing framework provides:

• Consistent user assignment using hashing algorithms
• Flexible experiment configuration with traffic allocation
• Real-time event tracking and analytics
• Statistical significance calculation
• Spring Boot integration for easy setup
• Feature toggle capabilities
• REST API for experiment management
• Comprehensive testing support

The framework ensures reliable, statistically sound A/B testing that can scale with your application's needs.