Spring Boot Auto-Configuration

@SpringBootApplication
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

@SpringBootApplication  // This is a composite annotation
// Equivalent to:
@SpringBootConfiguration
@EnableAutoConfiguration   // <-- THIS triggers auto-configuration
@ComponentScan(excludeFilters = { ... })

@AutoConfiguration
@ConditionalOnClass(DataSource.class)                    // ✅ HikariCP is on classpath
@ConditionalOnProperty(name = "spring.datasource.url")   // ✅ Property exists
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean                            // ✅ No user-defined DataSource
    public DataSource dataSource(DataSourceProperties props) { ... }
}

// org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
@AutoConfiguration(before = SqlInitializationAutoConfiguration.class)
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class,
          DataSourceCheckpointRestoreConfiguration.class })
public class DataSourceAutoConfiguration {
    // Only runs if javax.sql.DataSource AND spring-jdbc are on classpath
    // AND no reactive R2DBC ConnectionFactory is defined
}

// org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration
@AutoConfiguration
@ConditionalOnClass(ObjectMapper.class)
public class JacksonAutoConfiguration {

    @Bean
    @Primary
    @ConditionalOnMissingBean
    public ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
        return builder.createXmlMapper(false).build();
    }
    // If YOU define an ObjectMapper @Bean, this backs off completely
}

// Scheduling only activates if explicitly enabled
@AutoConfiguration
@ConditionalOnClass({ EnableScheduling.class, ScheduledAnnotationBeanPostProcessor.class })
@ConditionalOnProperty(prefix = "spring.task.scheduling", name = "enabled",
                       havingValue = "true", matchIfMissing = true)
public class TaskSchedulingAutoConfiguration {
    // matchIfMissing = true means: enabled by default unless you set it to false
}

@AutoConfiguration(after = { DispatcherServletAutoConfiguration.class,
                             TaskExecutionAutoConfiguration.class,
                             ValidationAutoConfiguration.class })
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
public class WebMvcAutoConfiguration {
    // Only for servlet web apps — NOT reactive, NOT CLI
}

@AutoConfiguration
@ConditionalOnBean(DataSource.class)
@ConditionalOnClass(JpaRepository.class)
@ConditionalOnMissingBean({ JpaRepositoryFactoryBean.class,
                            JpaRepositoryConfigExtension.class })
@AutoConfigureAfter(HibernateJpaAutoConfiguration.class)  // <-- ORDER IS CRITICAL
public class JpaRepositoriesAutoConfiguration {
    // Without @AutoConfigureAfter, this might evaluate BEFORE DataSource exists
    // Then @ConditionalOnBean(DataSource.class) would FAIL silently
}

package com.company.audit.autoconfigure;

import java.time.Instant;
import java.util.Map;

public class AuditEvent {

    private final String principal;
    private final String action;
    private final String entityType;
    private final String entityId;
    private final Instant timestamp;
    private final Map<String, Object> metadata;

    private AuditEvent(Builder builder) {
        this.principal = builder.principal;
        this.action = builder.action;
        this.entityType = builder.entityType;
        this.entityId = builder.entityId;
        this.timestamp = builder.timestamp != null ? builder.timestamp : Instant.now();
        this.metadata = builder.metadata != null ? Map.copyOf(builder.metadata) : Map.of();
    }

    public static Builder builder() { return new Builder(); }

    // Getters
    public String getPrincipal() { return principal; }
    public String getAction() { return action; }
    public String getEntityType() { return entityType; }
    public String getEntityId() { return entityId; }
    public Instant getTimestamp() { return timestamp; }
    public Map<String, Object> getMetadata() { return metadata; }

    public static class Builder {
        private String principal;
        private String action;
        private String entityType;
        private String entityId;
        private Instant timestamp;
        private Map<String, Object> metadata;

        public Builder principal(String principal) { this.principal = principal; return this; }
        public Builder action(String action) { this.action = action; return this; }
        public Builder entityType(String entityType) { this.entityType = entityType; return this; }
        public Builder entityId(String entityId) { this.entityId = entityId; return this; }
        public Builder timestamp(Instant timestamp) { this.timestamp = timestamp; return this; }
        public Builder metadata(Map<String, Object> metadata) { this.metadata = metadata; return this; }
        public AuditEvent build() { return new AuditEvent(this); }
    }
}

package com.company.audit.autoconfigure;

import java.util.List;

public interface AuditEventRepository {

    void save(AuditEvent event);

    List<AuditEvent> findByPrincipal(String principal);

    List<AuditEvent> findByEntityTypeAndEntityId(String entityType, String entityId);
}

package com.company.audit.autoconfigure;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "company.audit")
public class AuditProperties {

    /**
     * Enable or disable audit logging globally.
     */
    private boolean enabled = true;

    /**
     * Where to send audit events: "kafka", "database", "log"
     */
    private String destination = "kafka";

    /**
     * Kafka topic name when destination=kafka
     */
    private String kafkaTopic = "audit-events";

    /**
     * Include request metadata (IP, user-agent) in audit events
     */
    private boolean includeRequestMetadata = true;

    /**
     * Async processing — events are queued and sent in background
     */
    private boolean async = true;

    /**
     * Queue capacity for async processing
     */
    private int asyncQueueCapacity = 10_000;

    // Getters and Setters
    public boolean isEnabled() { return enabled; }
    public void setEnabled(boolean enabled) { this.enabled = enabled; }
    public String getDestination() { return destination; }
    public void setDestination(String destination) { this.destination = destination; }
    public String getKafkaTopic() { return kafkaTopic; }
    public void setKafkaTopic(String kafkaTopic) { this.kafkaTopic = kafkaTopic; }
    public boolean isIncludeRequestMetadata() { return includeRequestMetadata; }
    public void setIncludeRequestMetadata(boolean includeRequestMetadata) {
        this.includeRequestMetadata = includeRequestMetadata;
    }
    public boolean isAsync() { return async; }
    public void setAsync(boolean async) { this.async = async; }
    public int getAsyncQueueCapacity() { return asyncQueueCapacity; }
    public void setAsyncQueueCapacity(int asyncQueueCapacity) {
        this.asyncQueueCapacity = asyncQueueCapacity;
    }
}

package com.company.audit.autoconfigure;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class AuditService {

    private static final Logger log = LoggerFactory.getLogger(AuditService.class);

    private final AuditEventRepository repository;
    private final AuditProperties properties;
    private final BlockingQueue<AuditEvent> eventQueue;
    private final ExecutorService executor;

    public AuditService(AuditEventRepository repository, AuditProperties properties) {
        this.repository = repository;
        this.properties = properties;

        if (properties.isAsync()) {
            this.eventQueue = new LinkedBlockingQueue<>(properties.getAsyncQueueCapacity());
            this.executor = Executors.newSingleThreadExecutor(r -> {
                Thread t = new Thread(r, "audit-worker");
                t.setDaemon(true);
                return t;
            });
            this.executor.submit(this::processQueue);
        } else {
            this.eventQueue = null;
            this.executor = null;
        }
    }

    public void audit(AuditEvent event) {
        if (!properties.isEnabled()) {
            return;
        }

        if (properties.isAsync()) {
            if (!eventQueue.offer(event)) {
                log.warn("Audit queue full, dropping event: {} {} {}",
                    event.getPrincipal(), event.getAction(), event.getEntityType());
            }
        } else {
            repository.save(event);
        }
    }

    private void processQueue() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                AuditEvent event = eventQueue.take();
                repository.save(event);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            } catch (Exception e) {
                log.error("Failed to persist audit event", e);
            }
        }
    }

    public void shutdown() {
        if (executor != null) {
            executor.shutdownNow();
        }
    }
}

package com.company.audit.autoconfigure;

import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.kafka.core.KafkaTemplate;

@AutoConfiguration
@ConditionalOnClass(AuditService.class)
@ConditionalOnProperty(prefix = "company.audit", name = "enabled",
                       havingValue = "true", matchIfMissing = true)
@EnableConfigurationProperties(AuditProperties.class)
public class AuditAutoConfiguration {

    /**
     * Default: Kafka-based repository when KafkaTemplate is available.
     */
    @Bean
    @ConditionalOnMissingBean(AuditEventRepository.class)
    @ConditionalOnBean(KafkaTemplate.class)
    @ConditionalOnProperty(prefix = "company.audit", name = "destination",
                           havingValue = "kafka", matchIfMissing = true)
    public AuditEventRepository kafkaAuditEventRepository(
            KafkaTemplate<String, Object> kafkaTemplate,
            AuditProperties properties) {
        return new KafkaAuditEventRepository(kafkaTemplate, properties.getKafkaTopic());
    }

    /**
     * Fallback: Log-based repository when Kafka is not available.
     */
    @Bean
    @ConditionalOnMissingBean(AuditEventRepository.class)
    public AuditEventRepository loggingAuditEventRepository() {
        return new LoggingAuditEventRepository();
    }

    /**
     * The main AuditService bean — backs off if user defines their own.
     */
    @Bean
    @ConditionalOnMissingBean
    public AuditService auditService(AuditEventRepository repository,
                                     AuditProperties properties) {
        return new AuditService(repository, properties);
    }
}

@RestController
@RequestMapping("/api/orders")
public class OrderController {

    private final OrderService orderService;
    private final AuditService auditService;  // Auto-injected from starter!

    public OrderController(OrderService orderService, AuditService auditService) {
        this.orderService = orderService;
        this.auditService = auditService;
    }

    @PostMapping
    public ResponseEntity<Order> createOrder(@RequestBody CreateOrderRequest request,
                                             @AuthenticationPrincipal UserDetails user) {
        Order order = orderService.create(request);

        auditService.audit(AuditEvent.builder()
            .principal(user.getUsername())
            .action("ORDER_CREATED")
            .entityType("Order")
            .entityId(order.getId().toString())
            .metadata(Map.of("amount", order.getTotalAmount(),
                             "items", order.getItems().size()))
            .build());

        return ResponseEntity.status(HttpStatus.CREATED).body(order);
    }
}

@Configuration
public class CustomAuditConfig {

    @Bean
    public AuditService auditService(AuditEventRepository repository,
                                     AuditProperties properties) {
        // Custom implementation with encryption, PII masking, etc.
        return new EncryptedAuditService(repository, properties, encryptionKey());
    }
}
// Auto-configured AuditService backs off — @ConditionalOnMissingBean sees this bean

@Component
public class AutoConfigDebugger implements ApplicationRunner {

    private final ConfigurableApplicationContext context;

    public AutoConfigDebugger(ConfigurableApplicationContext context) {
        this.context = context;
    }

    @Override
    public void run(ApplicationArguments args) {
        ConditionEvaluationReport report = ConditionEvaluationReport
            .get(context.getBeanFactory());

        // Find why a specific auto-configuration was skipped
        report.getConditionAndOutcomesBySource().forEach((source, outcomes) -> {
            if (source.contains("AuditAutoConfiguration")) {
                System.out.println("=== " + source + " ===");
                outcomes.forEach(conditionAndOutcome ->
                    System.out.println("  " + conditionAndOutcome.getCondition().getClass().getSimpleName()
                        + ": " + conditionAndOutcome.getOutcome().getMessage())
                );
            }
        });
    }
}

// Old way (Boot 2.x)
@AutoConfiguration
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
@AutoConfigureBefore(FlywayAutoConfiguration.class)
public class JpaAutoConfiguration { }

// New way (Boot 3.x) — cleaner, all in one annotation
@AutoConfiguration(
    after = DataSourceAutoConfiguration.class,
    before = FlywayAutoConfiguration.class
)
public class JpaAutoConfiguration { }

@AutoConfiguration(after = DataSourceAutoConfiguration.class)
@ConditionalOnClass({ DataSource.class, AuthenticationManager.class })
@ConditionalOnBean(DataSource.class)
public class JdbcSecurityAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public UserDetailsService jdbcUserDetailsService(DataSource dataSource) {
        JdbcUserDetailsManager manager = new JdbcUserDetailsManager(dataSource);
        manager.setUsersByUsernameQuery(
            "SELECT username, password, enabled FROM users WHERE username = ?");
        return manager;
    }
}