The @Configuration annotation in Spring Framework is used to indicate that a class declares one or more @Bean methods and serves as a source of bean definitions for the Spring IoC (Inversion of Control) container. It plays a crucial role in Spring's Java-based configuration.

Here’s a detailed explanation of how @Configuration works internally:

Key Roles of @Configuration

1. Marks a Class as a Configuration Class:
   • When a class is annotated with @Configuration, Spring treats it as a configuration class, meaning it will scan for @Bean methods and process them to register beans in the application context.
2. Enhances the Class with CGLIB Proxy:
   • Spring uses CGLIB (Code Generation Library) to create a proxy subclass of the @Configuration class. This proxy ensures that @Bean methods are executed only once, and the same instance is returned for subsequent calls, maintaining the singleton behavior.

Internal Workflow of @Configuration

1. Class Scanning:
   • During the application context initialization, Spring scans for classes annotated with @Configuration (or included explicitly in the configuration).
   • This is done via the ClassPathBeanDefinitionScanner or similar mechanisms.
2. Bean Definition Parsing:
   • Spring parses the @Configuration class and identifies all @Bean methods.
   • Each @Bean method is registered as a bean definition in the Spring IoC container.
3. CGLIB Proxy Creation:
   • To ensure singleton behavior, Spring creates a CGLIB proxy of the @Configuration class.
   • This proxy intercepts calls to @Bean methods. Instead of executing the method body multiple times, it checks if the bean instance is already created and returns the existing instance if available.
4. Bean Creation and Dependency Injection:
   • When the application context needs a bean, the proxy intercepts the call to the @Bean method and retrieves the bean instance.
   • If the bean is not yet created, the proxy executes the @Bean method and stores the result in the container.

Why CGLIB Proxy is Needed?

Without the CGLIB proxy, calling an @Bean method from within another @Bean method would create a new instance of the bean every time, breaking the singleton contract.

Example Without Proxy:

java
Copy code
@Configuration
public class AppConfig {
    @Bean
    public ServiceA serviceA() {
        return new ServiceA(serviceB()); // Calls serviceB() directly
    }

    @Bean
    public ServiceB serviceB() {
        return new ServiceB();
    }
}

• Without a proxy, every call to serviceB() would create a new ServiceB instance.

Example With Proxy: