Java Configuration (@Bean)

In Spring, Java-based configuration operates in one of two modes: Full Configuration Mode or Lite Configuration Mode. This distinction represents one of the most critical, yet frequently misunderstood, runtime mechanics in the entire framework.

In Full mode, Spring generates a CGLIB subclass of your @Configuration class at startup. When one @Bean method calls another @Bean method (e.g. dataSource()), CGLIB intercepts the call, checks the BeanFactory singleton registry, and returns the existing managed singleton if already created. In Lite mode, no proxy exists, so calling the method simply invokes raw Java construction, producing duplicate instances!

While @Component is ideal for classes whose source code you own, @Bean factory methods are essential in three production scenarios:

1. 01Third-Party Library Classes: Configuring objects from external libraries (such as Jackson ObjectMapper, HikariDataSource, or RedisTemplate) where you cannot add @Component to the source code.
2. 02Conditional / Programmatic Assembly: When instantiation requires algorithmic branching, environment evaluation, or dynamic parameters (e.g. constructing an in-memory client for dev and an OAuth2 client for prod).
3. 03Explicit Lifecycle Control: Declaring custom init and destroy methods via @Bean(initMethod = "start", destroyMethod = "close").

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Configuration(proxyBeanMethods = true)
public class InfrastructureConfig {

    @Bean
    public ObjectMapper objectMapper() {
        return JsonMapper.builder()
            .findAndAddModules()
            .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
            .build();
    }

    @Bean
    public AuditClient auditClient(ObjectMapper mapper) { // Method parameter injection!
        return new AuditClient(mapper);
    }
}

When developers use proxyBeanMethods = false (often to improve startup time or ahead-of-time compilation) and directly invoke other @Bean methods, they unknowingly violate singleton guarantees, creating multiple connection pools or caches.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

@Configuration(proxyBeanMethods = false) // Lite mode: CGLIB proxying is DISABLED!
public class DangerousLiteConfig {

    @Bean
    public ConnectionPool pool() {
        return new ConnectionPool(); // Costly resource!
    }

    @Bean
    public OrderService orderService() {
        return new OrderService(pool()); // Calls pool() directly!
    }

    @Bean
    public PaymentService paymentService() {
        return new PaymentService(pool()); // Calls pool() directly!
    }
}

// Output from ApplicationContext inspection:
OrderService pool hashcode:   ConnectionPool@7f31245a
PaymentService pool hashcode: ConnectionPool@2a1844b2
WARN: Two separate ConnectionPool instances created! Total database connections doubled!