How internally Primary Annotation works

In Spring Boot, @Primary is used to indicate a primary bean among multiple candidate beans of the same type. When Spring's dependency injection mechanism encounters multiple beans of the same type and does not know which one to inject, it will inject the bean marked as @Primary. Let’s dive into how @Primary works internally in Spring.

How @Primary Works Internally:

1. Bean Definition Phase:
   • When Spring Boot starts, it goes through the process of scanning and registering beans.
   • During the bean definition phase, all the beans that are candidates for injection are identified and stored in a map, where the key is the bean type (interface or class), and the values are the beans (their respective instances or definitions).
   • Beans can be defined explicitly via @Bean methods, or implicitly via @Component, @Service, @Repository, and similar annotations.
   • When multiple beans of the same type exist, Spring needs to decide which bean to inject.
2. Primary Bean Resolution:
   • If multiple beans of the same type are found, and one of them is marked with the @Primary annotation, Spring gives preference to that bean when injecting it into dependent classes.
   • Spring internally sets a priority for the bean with @Primary. This priority information is stored in the DefaultListableBeanFactory (or similar container), where Spring tracks which bean is "primary" for a given type.
   • This process happens during bean registration and when dependency injection occurs (e.g., when Spring is wiring beans via constructor or setter injection).
3. Dependency Injection Phase:
   • When Spring encounters a scenario where it needs to inject a bean of a particular type, it checks:
     • If there is only one bean of that type, it injects that bean.
     • If there are multiple beans, it looks for one that is annotated with @Primary. If found, that bean is injected.
     • If none of the beans are marked as @Primary, and no explicit bean is specified using @Qualifier, Spring will throw a NoUniqueBeanDefinitionException, as it cannot determine which bean to inject.
4. Interaction with @Qualifier:
   • If @Qualifier is used, it overrides @Primary. That is, @Qualifier explicitly tells Spring which bean to inject, even if @Primary is present on another bean.
   • This allows developers to control which specific bean should be injected in certain parts of the application, while still keeping @Primary for general use.

Example:

Let’s say you have two beans of the same type:

@Configuration
public class AppConfig {

    @Bean
    public DataSource myDataSource1() {
        return new DataSource("DataSource1");
    }

    @Primary
    @Bean
    public DataSource myDataSource2() {
        return new DataSource("DataSource2");
    }
}

When Spring needs to inject a DataSource bean, and no @Qualifier is specified, Spring will inject myDataSource2 because it is marked with @Primary.

Flow of Bean Injection with @Primary:

1. Bean Creation: Spring creates beans according to the configuration.
2. Bean Registration: Beans are registered in the Spring container with metadata, including any annotations like @Primary.
3. Injection Decision:
   • When a bean of a particular type is requested, Spring searches for all beans of that type.
   • If multiple candidates are found, Spring checks for the presence of the @Primary annotation.
   • If a primary bean is found, it gets injected.
4. Fallback: If there’s no @Primary or no @Qualifier, and multiple beans are found, Spring throws an exception indicating ambiguity.

Behind the Scenes:

Internally, the process involves Spring's bean resolution mechanism. This mechanism is part of the AutowireCandidateResolver within the DefaultListableBeanFactory. When determining the eligible beans for injection, Spring does the following: