This guide provides a comprehensive walkthrough of the Spring bean lifecycle, demonstrating each stage with practical examples. We'll explore Spring's lifecycle methods sequentially, building a robust understanding of how Spring manages its beans from registration to destruction.

Step 1: Bean Definition Registration (registerBeanDefinition())

We begin by examining how Spring registers bean definitions before instantiation, leveraging BeanDefinitionRegistry.

What Happens: Spring loads and registers bean definitions from various sources: @ComponentScan, @Bean methods within @Configuration classes, and XML configuration (if used). Crucially, no beans are instantiated at this point. Spring simply stores metadata about each bean.

Practical Example: Manually registering a bean using a BeanDefinitionRegistryPostProcessor.

@Configuration
public class CustomBeanRegistrar implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(MyDynamicBean.class);
        registry.registerBeanDefinition("myDynamicBean", beanDefinition);
        System.out.println("Custom bean definition registered: MyDynamicBean");
    }

    // ... (rest of the code remains the same)
}

Key Takeaway: Dynamic bean registration (e.g., based on conditions or external configurations) is achieved through this method. Beans are essentially blueprints at this stage. Use this method sparingly, only when dynamic registration is truly necessary.

Step 2: Before Instantiation (postProcessBeforeInstantiation())

Next, we explore InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation().

What Happens: This method executes before a bean's instantiation. It allows modification or replacement of the bean instance before creation, or even prevention of standard instantiation by returning a proxy or custom object.

Practical Example: Intercepting bean instantiation for logging purposes.

@Component
class CustomInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("Before instantiating bean: " + beanName);
        return null; // Allows normal instantiation
    }
}

Key Observation: This method runs before the constructor is called. It's valuable for AOP scenarios (creating proxies).

Step 3: Bean Name Awareness (setBeanName())

After instantiation, Spring calls BeanNameAware#setBeanName().

What Happens: The bean becomes aware of its own name within the application context. This occurs before dependency injection.

Practical Example: A bean recognizing its own name.

class MyDynamicBean implements BeanNameAware {
    private String beanName;

    // ... (constructor and other methods)

    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("Bean name set: " + name);
    }
}

Key Observation: This method is called immediately post-instantiation. The bean can store its name for later use (e.g., logging or internal manipulation).

Steps 4-12: Further Lifecycle Methods

The remaining lifecycle methods ( BeanClassLoaderAware, BeanFactoryAware, EnvironmentAware, EmbeddedValueResolverAware, ResourceLoaderAware, ApplicationEventPublisherAware, MessageSourceAware, and ApplicationContextAware) follow a similar pattern: Spring calls a specific setter method, providing the bean with access to a crucial Spring component. These are detailed in the original document and follow the same structure of "What Happens," "Practical Example," and "Key Observation." They allow access to the classloader, bean factory, environment properties, embedded value resolver, resource loader, event publisher, message source, and application context respectively.

Step 13: Before Initialization (postProcessBeforeInitialization())

BeanPostProcessor#postProcessBeforeInitialization() is called before initialization callbacks (@PostConstruct, InitializingBean#afterPropertiesSet()).

What Happens: Allows modification of bean properties or application of aspects (proxying, validation, logging) before the bean is fully initialized.

Practical Example: Modifying a bean before initialization.

@Configuration
public class CustomBeanRegistrar implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(MyDynamicBean.class);
        registry.registerBeanDefinition("myDynamicBean", beanDefinition);
        System.out.println("Custom bean definition registered: MyDynamicBean");
    }

    // ... (rest of the code remains the same)
}

Key Observation: This method executes before the initialization callbacks.

Step 14: Initialization Callbacks (@PostConstruct, afterPropertiesSet())

Spring invokes initialization callbacks after postProcessBeforeInitialization().

What Happens: @PostConstruct (annotation-based) and InitializingBean#afterPropertiesSet() (interface-based) are used for validation, resource setup, or any post-dependency injection initialization.

Practical Example: Using both @PostConstruct and afterPropertiesSet().

@Component
class CustomInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("Before instantiating bean: " + beanName);
        return null; // Allows normal instantiation
    }
}

Key Observation: @PostConstruct runs before afterPropertiesSet(). Favor @PostConstruct over implementing InitializingBean unless strictly necessary.

Step 15: After Initialization (postProcessAfterInitialization())

BeanPostProcessor#postProcessAfterInitialization() executes after initialization callbacks.

What Happens: Allows applying proxies or performing final modifications after full bean initialization.

Practical Example: Applying post-initialization modifications.

class MyDynamicBean implements BeanNameAware {
    private String beanName;

    // ... (constructor and other methods)

    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("Bean name set: " + name);
    }
}

Key Observation: This method is called after initialization callbacks.

Step 16: Destruction Callbacks (@PreDestroy, destroy())

Finally, destruction callbacks are invoked before application shutdown.

What Happens: @PreDestroy (annotation-based) and DisposableBean#destroy() (interface-based) ensure proper resource cleanup.

Practical Example: Cleaning up resources.

@Configuration
public class CustomBeanRegistrar implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(MyDynamicBean.class);
        registry.registerBeanDefinition("myDynamicBean", beanDefinition);
        System.out.println("Custom bean definition registered: MyDynamicBean");
    }

    // ... (rest of the code remains the same)
}

Key Observation: @PreDestroy runs before destroy(). Prefer @PreDestroy unless needing DisposableBean's functionality.

This comprehensive overview details the Spring bean lifecycle, enabling developers to effectively utilize Spring's lifecycle management features for robust and well-managed applications.

The above is the detailed content of spring-: entire-spring-bean-lifecycle-from-registration-to-destruction-with-sample-examples. For more information, please follow other related articles on the PHP Chinese website!