Following Spring container initialization, the refresh() method orchestrates the application context setup. This critical sequence configures the environment, registers components, and prepares the container for bean lifecycle management.

public void initializeContext() throws BeansException {
    synchronized (this.lifecycleLock) {
        preRefreshSetup();
        
        ConfigurableListableBeanFactory contextFactory = createFreshBeanFactory();
        
        setupBeanFactory(contextFactory);
        
        try {
            postProcessBeanFactory(contextFactory);
            executeBeanFactoryPostProcessors(contextFactory);
            registerBeanPostProcessors(contextFactory);
            initializeMessageSource();
            setupEventMulticaster();
            onContextRefresh();
            registerApplicationListeners();
            initializeNonLazySingletons(contextFactory);
            completeContextInitialization();
        }
    }
}

preRefreshSetup() establishes the container's operational foundation by:

• Recording initialization timestamp
• Transitioning from dormant to active state
• Configuring environment properties
• Validating mandatory configuration parameters

The createFreshBeanFactory() method delegates to subclass implementations to generate a fresh BeanFactory instance. Concrete implementations like GenericApplicationContext reuse existing factories while AbstractRefreshableApplicationContext initializes new ones.

setupBeanFactory() configures the factory's core infrastructure:

protected void configureBeanFactory(ConfigurableListableBeanFactory factory) {
    factory.setBeanClassLoader(getClassLoader());
    factory.setExpressionResolver(new StandardBeanExpressionResolver());
    factory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    
    factory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    factory.ignoreDependencyInterface(EnvironmentAware.class);
    // ... other dependency exclusions
    
    factory.registerResolvableDependency(BeanFactory.class, factory);
    // ... other resolvable dependencies
    
    factory.addBeanPostProcessor(new ApplicationListenerDetector(this));
    // ... other factory configurations
}

Subsequent steps handle specialized container requirements. For web environments, postProcessBeanFactory() adds context-aware processors like ServletContextAwareProcessor to manage web-specific dependencies.

The executeBeanFactoryPostProcessors() phase processes BeanFactoryPostProcessor implementations. Key components include:

• ConfigurationClassPostProcessor: Resolves @Configuration classes and their annotations (@ComponentScan, @Import, @Bean)
• BeanDefinitionRegistryPostProcessor: Registers bean definitions from scanning and import operations
• Automatic configuration processing via EnableAutoConfiguration metadata

Configuration processing follows this sequence:

1. Resolve @PropertySources and environment properties
2. Scan packages via @ComponentScan and register bean definitions
3. Process @Import annotations (including deferred selectors like EnableAutoConfigurationImportSelector)
4. Register beans annotated with @Bean
5. Handle deferred import selections

After bean definition registration, registerBeanPostProcessors() integrates lifecycle management components. These processors handle dependency injection (AutowiredAnnotationBeanPostProcessor), lifecycle callbacks (CommonAnnotationBeanPostProcessor), and validation (RequiredAnnotationBeanPostProcessor).

initializeMessageSource() sets up internationalization capabilities while setupEventMulticaster() configures event broadcasting infrastructure. The onContextRefresh() hook enables container-specific initialization, such as starting embedded web servers in Spring Boot.

Application listeners are registered through registerApplicationListeners(), which processes both pre-registered beans and those discovered via the factory. Early events are dispatched to listeners before full initialization completes.

initializeNonLazySingletons() triggers instantiation of all non-lazy singleton beans. This step activates bean post processors during initialization and resolves dependencies for all registered beans.

Finally, completeContextInitialization() initializes lifecycle processors and publishes the ContextRefreshedEvent, signaling the container is fully operational and ready for application use.