spring-006: logical-execution-order-and-code-flow

public static void main(String[] args) { ApplicationContext context = new AnnotationConfigApplicationContext(TenantConfig.class); TenantService tenantService = context.getBean(TenantService.class); tenantService.processTenantData(); } @Configuration @ComponentScan(basePackages = "org.example4") // Adjust to your package structure public class TenantConfig { @Bean(name = "tenantA-dataSource") public TenantDataSource tenantADataSource() { return new TenantDataSource(); } @Bean(name = "tenantB-dataSource") public TenantDataSource tenantBDataSource() { return new TenantDataSource(); } } public class TenantDataSource implements BeanNameAware { private String tenantName; private String databaseUrl; @Override public void setBeanName(String beanName) { // Extract tenant name from the bean name if (beanName.contains("-")) { this.tenantName = beanName.split("-")[0]; } else { throw new IllegalArgumentException("Invalid bean naming convention. Expected format: <tenantName>-dataSource"); } // Assign a database URL dynamically based on the tenant name this.databaseUrl = "jdbc:mysql://localhost:3306/" + tenantName + "_db"; } public void connect() { System.out.println("Connecting to database for tenant: " + tenantName); System.out.println("Using database URL: " + databaseUrl); // Simulate connection logic here } } @Service public class TenantService { private final TenantDataSource tenantADataSource; private final TenantDataSource tenantBDataSource; @Autowired public TenantService( @Qualifier("tenantA-dataSource") TenantDataSource tenantADataSource, @Qualifier("tenantB-dataSource") TenantDataSource tenantBDataSource ) { this.tenantADataSource = tenantADataSource; this.tenantBDataSource = tenantBDataSource; } public void processTenantData() { System.out.println("Processing data for all tenants..."); tenantADataSource.connect(); tenantBDataSource.connect(); } } 

Step-by-Step Execution Order

1. Main Class Execution Begins

public static void main(String[] args) { ApplicationContext context = new AnnotationConfigApplicationContext(TenantConfig.class); TenantService tenantService = context.getBean(TenantService.class); tenantService.processTenantData(); } 

• What happens here:
  • A new Spring application context (AnnotationConfigApplicationContext) is initialized with TenantConfig as the configuration class.
  • Spring begins scanning for beans and components, following the configuration provided in TenantConfig.

2. Spring Processes TenantConfig

@Configuration @ComponentScan(basePackages = "org.example4") public class TenantConfig { @Bean(name = "tenantA-dataSource") public TenantDataSource tenantADataSource() { return new TenantDataSource(); } @Bean(name = "tenantB-dataSource") public TenantDataSource tenantBDataSource() { return new TenantDataSource(); } } 

• What happens here:
  1. @Configuration:
     • Marks TenantConfig as a configuration class.
  2. @ComponentScan:
     • Spring scans the org.example4 package for classes annotated with @Component, @Service, @Repository, etc.
     • It detects and registers the TenantService class as a Spring-managed bean because of the @Service annotation.
  3. @Bean Definitions:
     • Spring calls the tenantADataSource() and tenantBDataSource() methods to create two instances of TenantDataSource.
     • These beans are registered in the Spring context with the names:
     • tenantA-dataSource
     • tenantB-dataSource

3. Spring Instantiates TenantDataSource Beans

public class TenantDataSource implements BeanNameAware { @Override public void setBeanName(String beanName) { ... } } 

• What happens here:

  • Spring creates two instances of TenantDataSource by calling the methods in TenantConfig:
  • tenantADataSource() -> Creates an instance of TenantDataSource and registers it as tenantA-dataSource.
  • tenantBDataSource() -> Creates another instance of TenantDataSource and registers it as tenantB-dataSource.

• Bean Lifecycle - BeanNameAware:

  • Spring detects that TenantDataSource implements BeanNameAware.
  • For each bean:
  • setBeanName("tenantA-dataSource") is called on the first instance.
    • tenantName = "tenantA"
    • databaseUrl = "jdbc:mysql://localhost:3306/tenantA_db"
  • setBeanName("tenantB-dataSource") is called on the second instance.
    • tenantName = "tenantB"
    • databaseUrl = "jdbc:mysql://localhost:3306/tenantB_db"

4. Spring Creates and Configures TenantService

@Service public class TenantService { @Autowired public TenantService( @Qualifier("tenantA-dataSource") TenantDataSource tenantADataSource, @Qualifier("tenantB-dataSource") TenantDataSource tenantBDataSource ) { ... } } 

• What happens here:

  1. Spring detects TenantService because of the @Service annotation and registers it as a Spring-managed bean.
  2. Spring finds the constructor annotated with @Autowired and resolves the dependencies:
     • For the first parameter, @Qualifier("tenantA-dataSource") ensures Spring injects the bean named tenantA-dataSource.
     • For the second parameter, @Qualifier("tenantB-dataSource") ensures Spring injects the bean named tenantB-dataSource.
  3. Spring calls the constructor of TenantService:

   new TenantService(tenantADataSource, tenantBDataSource); 

1. The TenantService bean is now fully initialized and managed by Spring.

5. Retrieve the Spring-Managed TenantService Bean

TenantService tenantService = context.getBean(TenantService.class); 

• What happens here:
  • The context.getBean(TenantService.class) call retrieves the TenantService bean from the Spring context.
  • This bean is already fully configured by Spring, with its dependencies (tenantADataSource and tenantBDataSource) injected.

6. Call TenantService.processTenantData()

tenantService.processTenantData(); 

• What happens here:

  • The processTenantData() method is invoked on the TenantService bean.

  • Inside the method:
    tenantADataSource.connect() is called:

    • Outputs:

     Connecting to database for tenant: tenantA Using database URL: jdbc:mysql://localhost:3306/tenantA_db 

  tenantBDataSource.connect() is called:

  • Outputs:
    

     Connecting to database for tenant: tenantB Using database URL: jdbc:mysql://localhost:3306/tenantB_db 

Summary of the Execution Order

1. Main Class Initialization:

   • Spring context is initialized with TenantConfig.

2. Bean Registration:

   • Spring scans TenantConfig:
     • Registers two beans: tenantA-dataSource and tenantB-dataSource.
     • Registers TenantService as a Spring-managed bean.

3. Bean Creation and Lifecycle:

   • Spring creates TenantDataSource beans and calls setBeanName() to configure them dynamically.
   • Spring creates the TenantService bean, injecting the correct TenantDataSource beans using @Qualifier.

4. Retrieve TenantService Bean:

   • The TenantService bean is retrieved from the Spring context.

5. Method Execution:

   • The processTenantData() method is called, connecting to both tenant databases and printing connection details.

Key Takeaways

• Spring Context: The Spring IoC container is responsible for creating, initializing, and managing beans.
• Dependency Injection: Spring resolves dependencies using @Autowired and @Qualifier.
• Bean Lifecycle: The TenantDataSource beans are initialized with tenant-specific properties during the setBeanName() phase.
• Spring-Managed Beans: The TenantService bean is fully managed by Spring, and all dependencies are injected automatically.