Java-based Configuration

// @Configuration — declares this class as a bean definition source:
@Configuration
public class AppConfig {

    // @Bean — return value is registered as a Spring bean:
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder(12);
    }

    // Bean name defaults to method name — "passwordEncoder"
    // Inject elsewhere: @Autowired PasswordEncoder passwordEncoder;

    // Custom bean name:
    @Bean(name = "strongEncoder")
    public PasswordEncoder strongPasswordEncoder() {
        return new BCryptPasswordEncoder(14);
    }

    // Multiple names (aliases):
    @Bean(name = {"jwtService", "tokenService", "authService"})
    public JwtTokenService jwtTokenService() {
        return new JwtTokenService("secret", 3600);
    }

    // Dependencies between @Bean methods — call the method directly:
    @Bean
    public UserService userService() {
        // Spring intercepts this call and returns the SAME singleton instance
        // Does NOT create a new PasswordEncoder — returns the cached bean
        return new UserService(userRepository(), passwordEncoder());
    }

    @Bean
    public UserRepository userRepository() {
        return new JpaUserRepository();
    }

    // Dependencies injected as parameters (preferred over method calls):
    @Bean
    public OrderService orderService(OrderRepository orderRepository,
                                     PaymentService paymentService,
                                     EmailService emailService) {
        // Spring resolves and injects these parameters automatically
        return new OrderService(orderRepository, paymentService, emailService);
    }
}

// How Spring handles @Bean method calls:
@Configuration
public class DataConfig {

    @Bean
    public DataSource dataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
        config.setMaximumPoolSize(10);
        return new HikariDataSource(config);
    }

    @Bean
    public JdbcTemplate jdbcTemplate() {
        // Calls dataSource() — Spring intercepts this call
        return new JdbcTemplate(dataSource());
    }

    @Bean
    public UserRepository userRepository() {
        // Calls dataSource() again — Spring returns the SAME DataSource instance
        return new JdbcUserRepository(dataSource());
    }

    // Both jdbcTemplate and userRepository share the SAME DataSource bean
    // There is only ONE HikariDataSource — the singleton
}

// Without CGLIB — @Configuration(proxyBeanMethods = false):
@Configuration(proxyBeanMethods = false)  // no CGLIB proxy
public class LiteConfig {

    @Bean
    public DataSource dataSource() {
        return new HikariDataSource(config);
    }

    @Bean
    public JdbcTemplate jdbcTemplate() {
        // dataSource() is a regular method call — creates a NEW DataSource!
        // jdbcTemplate and userRepository would have DIFFERENT DataSource instances!
        return new JdbcTemplate(dataSource());
    }
}

// proxyBeanMethods = false (Lite Mode):
// - FASTER startup (no CGLIB proxy generated)
// - SAFE when @Bean methods don't call other @Bean methods
// - Used heavily in Spring Boot's own auto-configuration for performance
// - Should be your default when building @Configuration classes that
//   inject dependencies via parameters instead of method calls

// Best practice — use parameter injection to avoid the issue entirely:
@Configuration(proxyBeanMethods = false)
public class SafeConfig {

    @Bean
    public DataSource dataSource() {
        return new HikariDataSource(hikariConfig());
    }

    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        // DataSource injected as parameter — works in both proxy modes
        return new JdbcTemplate(dataSource);
    }

    @Bean
    public UserRepository userRepository(DataSource dataSource) {
        // Same DataSource injected — correct in both modes
        return new JdbcUserRepository(dataSource);
    }
}

@Configuration
public class BeanCustomizationConfig {

    // Prototype scope — new instance on every injection:
    @Bean
    @Scope("prototype")
    public ReportGenerator reportGenerator() {
        return new ReportGenerator();
    }

    // Request scope — one per HTTP request:
    @Bean
    @Scope(value = WebApplicationContext.SCOPE_REQUEST,
           proxyMode = ScopedProxyMode.TARGET_CLASS)
    public RequestContext requestContext() {
        return new RequestContext();
    }

    // Lazy — created only on first use:
    @Bean
    @Lazy
    public HeavyAnalyticsService analyticsService() {
        // Not created at startup — initialized on first injection
        return new HeavyAnalyticsService();
    }

    // Primary — preferred when multiple beans of the same type exist:
    @Bean
    @Primary
    public PaymentService stripePaymentService() {
        return new StripePaymentService(stripeApiKey);
    }

    @Bean
    public PaymentService paypalPaymentService() {
        return new PaypalPaymentService(paypalClientId);
    }

    // Qualifier — disambiguate when @Primary isn't sufficient:
    @Bean
    @Qualifier("fast")
    public CacheService inMemoryCacheService() {
        return new CaffeineCache();
    }

    @Bean
    @Qualifier("persistent")
    public CacheService redisCacheService() {
        return new RedisCache();
    }

    // DependsOn — ensure another bean is created first:
    @Bean
    @DependsOn("databaseMigration")
    public UserRepository userRepository(DataSource dataSource) {
        return new JpaUserRepository(dataSource);
    }

    @Bean
    public DatabaseMigration databaseMigration(DataSource dataSource) {
        return new FlywayMigration(dataSource);
    }

    // Lifecycle callbacks:
    @Bean(initMethod = "start", destroyMethod = "stop")
    public SchedulerService schedulerService() {
        return new QuartzSchedulerService();
    }
}

// @Import — pull in other @Configuration classes:
@Configuration
@Import({
    SecurityConfig.class,
    CacheConfig.class,
    MessagingConfig.class
})
public class AppConfig {
    // SecurityConfig, CacheConfig, MessagingConfig beans are now all available
}

// @Import used in feature-flag style — import configuration conditionally:
@Configuration
@ConditionalOnProperty(name = "feature.payments", havingValue = "true")
@Import(PaymentConfig.class)
public class FeatureConfig { }

// @ImportResource — import legacy XML configuration:
@Configuration
@ImportResource("classpath:legacy-beans.xml")
public class LegacyMigrationConfig {
    // Beans from XML are available alongside Java-configured beans
    // Useful during migration from XML to Java config
}

// @Import with ImportSelector — conditionally import classes based on logic:
public class PaymentModuleSelector implements ImportSelector {

    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        String provider = System.getProperty("payment.provider", "stripe");
        return switch (provider) {
            case "paypal" -> new String[]{"com.example.config.PaypalConfig"};
            case "braintree" -> new String[]{"com.example.config.BraintreeConfig"};
            default -> new String[]{"com.example.config.StripeConfig"};
        };
    }
}

@Configuration
@Import(PaymentModuleSelector.class)
public class AppConfig { }

// @Import with ImportBeanDefinitionRegistrar — register beans programmatically:
public class DynamicRepositoryRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata,
                                        BeanDefinitionRegistry registry) {
        // Scan for interfaces annotated with @MyRepository and register implementations
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
            .genericBeanDefinition(DynamicRepositoryFactory.class);
        registry.registerBeanDefinition("dynamicRepo", builder.getBeanDefinition());
    }
}

// config/SecurityConfig.java — security configuration:
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig {

    private final JwtAuthenticationFilter jwtFilter;

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(csrf -> csrf.disable())
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/auth/**", "/actuator/health").permitAll()
                .anyRequest().authenticated()
            )
            .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class)
            .build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

// config/PersistenceConfig.java — database configuration:
@Configuration
@EnableJpaAuditing
@EnableJpaRepositories(basePackages = "com.example.myapp.repository")
public class PersistenceConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.hikari")
    public HikariDataSource dataSource(DataSourceProperties props) {
        return props.initializeDataSourceBuilder()
                    .type(HikariDataSource.class)
                    .build();
    }

    @Bean
    public AuditorAware<String> auditorProvider() {
        return () -> Optional.ofNullable(SecurityContextHolder.getContext())
            .map(SecurityContext::getAuthentication)
            .filter(Authentication::isAuthenticated)
            .map(Authentication::getName);
    }
}

// config/CacheConfig.java — cache configuration:
@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10))
            .disableCachingNullValues()
            .serializeValuesWith(
                RedisSerializationContext.SerializationPair
                    .fromSerializer(new GenericJackson2JsonRedisSerializer())
            );

        return RedisCacheManager.builder(factory)
            .cacheDefaults(config)
            .withCacheConfiguration("users", config.entryTtl(Duration.ofMinutes(30)))
            .withCacheConfiguration("products", config.entryTtl(Duration.ofHours(1)))
            .build();
    }
}

// config/AsyncConfig.java — async execution configuration:
@Configuration
@EnableAsync
@EnableScheduling
public class AsyncConfig implements AsyncConfigurer {

    @Override
    @Bean
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("async-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (ex, method, params) ->
            log.error("Async exception in {}: {}", method.getName(), ex.getMessage(), ex);
    }
}

// Feature flag configuration — enable/disable entire feature sets:
@Configuration
@ConditionalOnProperty(name = "feature.notifications.enabled", havingValue = "true",
                       matchIfMissing = true)
public class NotificationConfig {

    @Bean
    public EmailNotificationService emailNotificationService(MailProperties props) {
        return new SmtpEmailNotificationService(props);
    }

    @Bean
    public SmsNotificationService smsNotificationService(TwilioProperties props) {
        return new TwilioSmsService(props);
    }

    @Bean
    public NotificationOrchestrator notificationOrchestrator(
            EmailNotificationService email,
            SmsNotificationService sms) {
        return new NotificationOrchestrator(email, sms);
    }
}

// Environment-specific configuration:
@Configuration
@Profile("dev")
public class DevelopmentConfig {

    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.H2)
            .addScript("classpath:schema.sql")
            .addScript("classpath:test-data.sql")
            .build();
    }

    @Bean
    public StorageService storageService() {
        return new LocalFileStorageService("/tmp/uploads");
    }
}

@Configuration
@Profile("prod")
public class ProductionConfig {

    @Bean
    public DataSource dataSource(DataSourceProperties props) {
        return DataSourceBuilder.create()
            .url(props.getUrl())
            .username(props.getUsername())
            .password(props.getPassword())
            .build();
    }

    @Bean
    public StorageService storageService(S3Properties props) {
        return new AwsS3StorageService(props.getBucket(), props.getRegion());
    }
}

// Override pattern — default bean with @ConditionalOnMissingBean:
@Configuration
public class DefaultConfig {

    @Bean
    @ConditionalOnMissingBean(MetricsCollector.class)
    public MetricsCollector noOpMetricsCollector() {
        return new NoOpMetricsCollector();  // default — does nothing
    }
}

// Any @Configuration class can override by defining a MetricsCollector bean:
@Configuration
@Profile("prod")
public class ProductionMetricsConfig {

    @Bean
    public MetricsCollector prometheusMetricsCollector() {
        return new PrometheusMetricsCollector();  // overrides default
    }
}

// USE COMPONENT SCANNING (@Service, @Repository, @Component) when:
// - The class IS the implementation (not configuring an external class)
// - Creation is straightforward — no factory logic needed
// - The class is part of your application code

@Service
public class UserService { }   // your class, simple creation → @Service

@Repository
public interface UserRepository extends JpaRepository<User, Long> { }   // your interface → @Repository

// USE @Bean in @Configuration when:
// - Configuring a THIRD-PARTY class (you can't add @Component to Stripe's SDK)
// - Creation requires factory logic, conditional branches, or multiple steps
// - You need to produce multiple beans from one method
// - You want a named variant of an existing bean

@Configuration
public class InfrastructureConfig {

    // Third-party class — can't annotate the source:
    @Bean
    public ObjectMapper objectMapper() {
        return JsonMapper.builder()
            .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
            .addModule(new JavaTimeModule())
            .build();
    }

    // Requires factory logic:
    @Bean
    public RestTemplate restTemplate() {
        RestTemplateBuilder builder = new RestTemplateBuilder()
            .setConnectTimeout(Duration.ofSeconds(5))
            .setReadTimeout(Duration.ofSeconds(10))
            .additionalInterceptors(new LoggingInterceptor());
        return builder.build();
    }

    // Named variant:
    @Bean("longTimeoutRestTemplate")
    public RestTemplate longTimeoutRestTemplate() {
        return new RestTemplateBuilder()
            .setReadTimeout(Duration.ofSeconds(60))
            .build();
    }
}

// COMBINATION — most real-world applications use both:
@Service                    // component scanning registers UserService
public class UserService {
    private final ObjectMapper objectMapper;     // @Bean-configured
    private final RestTemplate restTemplate;    // @Bean-configured
    private final UserRepository userRepository; // JPA interface — component scanned

    public UserService(ObjectMapper objectMapper,
                       RestTemplate restTemplate,
                       UserRepository userRepository) {
        this.objectMapper = objectMapper;
        this.restTemplate = restTemplate;
        this.userRepository = userRepository;
    }
}