Hunor Vadasz-Perhat

Posted on Jan 29

spring-012: entire-spring-bean-lifecycle-from-registration-to-destruction-with-sample-examples

#java #spring #springboot #programming

Here I systematically explore Spring's lifecycle methods by implementing them one by one in a structured way 🚀

Step 1: Understanding `registerBeanDefinition()` in Practice

We are starting with how Spring registers bean definitions before instantiation using BeanDefinitionRegistry.

🔹 What Happens at This Stage?

Spring loads and registers bean definitions from:
- @ComponentScan
- @Bean methods inside @Configuration
- XML-based configuration (if used)
At this point, no beans are instantiated yet! Spring is just storing the metadata about each bean.

🔹 Practical Example: Registering a Bean Manually

We define a class CustomBeanRegistrar that implements BeanDefinitionRegistryPostProcessor.
Inside postProcessBeanDefinitionRegistry(), we register a bean definition manually.
We create a bean class (MyDynamicBean) that will be instantiated when accessed.

@Configuration
public class CustomBeanRegistrar implements BeanDefinitionRegistryPostProcessor {

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

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // Not needed for this example
    }
}

🔹 Key Takeaways

✅ This method is used to dynamically register beans (e.g., based on conditions, external configs).

✅ At this stage, beans are just "blueprints"—actual instances are not created yet.

✅ Best Practice: Only use this when dynamic bean registration is needed (e.g., custom plugins).

Step 2: Understanding `postProcessBeforeInstantiation()`

Now that we've covered bean definition registration, the next lifecycle method is InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation().

🔹 What Happens at This Stage?

This method runs before the actual instantiation of a bean.
It allows you to:
- Modify or replace the bean instance before it is created.
- Prevent normal instantiation by returning a proxy or a custom instance.

🔹 Practical Example: Intercepting Bean Instantiation

We've implemented InstantiationAwareBeanPostProcessor to log when this method is called.

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

💡 Key Observations

✅ This method executes before the constructor is called.

✅ You can return a different instance instead of allowing the default instantiation.

✅ Best Practice: Use it for AOP (Aspect-Oriented Programming) scenarios like creating proxies.

Step 3: Understanding `setBeanName()`

Now that we've covered postProcessBeforeInstantiation(), the next lifecycle method is BeanNameAware#setBeanName().

🔹 What Happens at This Stage?

After the bean is instantiated, Spring calls setBeanName().
This allows the bean to know its own name in the application context.
This happens before dependency injection.

🔹 Practical Example: Bean Recognizing Its Own Name

We've extended the existing application to include BeanNameAware inside MyDynamicBean:

class MyDynamicBean implements BeanNameAware {
    private String beanName;

    public MyDynamicBean() {
        System.out.println("MyDynamicBean instantiated!");
    }

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

💡 Key Observations

✅ The method is called immediately after instantiation.

✅ The bean can store its own name for later use.

✅ Best Practice: Use this when the bean needs to log or manipulate its own name.

Step 4: Understanding `setBeanClassLoader()`

Now that we've covered setBeanName(), the next lifecycle method is BeanClassLoaderAware#setBeanClassLoader().

🔹 What Happens at This Stage?

After setting the bean name, Spring calls setBeanClassLoader(ClassLoader classLoader).
This method allows the bean to access the ClassLoader that loaded it.
The ClassLoader is responsible for loading classes into memory.

🔹 Practical Example: Accessing Bean ClassLoader

We've extended our MyDynamicBean class to implement BeanClassLoaderAware:

class MyDynamicBean implements BeanNameAware, BeanClassLoaderAware {
    private String beanName;
    private ClassLoader classLoader;

    public MyDynamicBean() {
        System.out.println("MyDynamicBean instantiated!");
    }

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

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
        System.out.println("Bean ClassLoader set: " + classLoader);
    }
}

💡 Key Observations

✅ The setBeanClassLoader() method is called after setBeanName().

✅ The ClassLoader allows the bean to dynamically load classes at runtime.

✅ Best Practice: Use it when you need to load classes dynamically (e.g., plugins, external dependencies).

Step 5: Understanding `setBeanFactory()`

Now that we've covered setBeanClassLoader(), the next lifecycle method is BeanFactoryAware#setBeanFactory().

🔹 What Happens at This Stage?

After setting the bean name and class loader, Spring calls setBeanFactory().
This method provides access to the BeanFactory, which is the core Spring container that holds all bean instances.
The bean can now programmatically retrieve other beans from the factory.

🔹 Practical Example: Accessing the `BeanFactory`

We've extended MyDynamicBean to implement BeanFactoryAware:

class MyDynamicBean implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware {
    private String beanName;
    private ClassLoader classLoader;
    private BeanFactory beanFactory;

    public MyDynamicBean() {
        System.out.println("MyDynamicBean instantiated!");
    }

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

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
        System.out.println("Bean ClassLoader set: " + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("BeanFactory set: " + beanFactory);
    }
}

💡 Key Observations

✅ The setBeanFactory() method is called after setBeanClassLoader().

✅ The BeanFactory allows beans to retrieve other beans programmatically.

✅ Best Practice: Use dependency injection (@Autowired) instead of directly accessing BeanFactory, unless you need dynamic lookups.

Step 6: Understanding `setEnvironment()`

Now that we've covered setBeanFactory(), the next lifecycle method is EnvironmentAware#setEnvironment().

🔹 What Happens at This Stage?

After setting bean factory access, Spring calls setEnvironment().
This method allows the bean to access environment properties, such as:
- System properties (System.getProperty("key"))
- Application properties (application.properties / application.yml)
- Profiles (spring.profiles.active)
- Other configurable settings.

🔹 Practical Example: Accessing Environment Variables

We've extended MyDynamicBean to implement EnvironmentAware:

class MyDynamicBean implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, EnvironmentAware {
    private String beanName;
    private ClassLoader classLoader;
    private BeanFactory beanFactory;
    private Environment environment;

    public MyDynamicBean() {
        System.out.println("MyDynamicBean instantiated!");
    }

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

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
        System.out.println("Bean ClassLoader set: " + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("BeanFactory set: " + beanFactory);
    }

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
        System.out.println("Environment set: " + environment);
        System.out.println("Active Profile: " + environment.getActiveProfiles());
        System.out.println("Server Port: " + environment.getProperty("server.port"));
    }
}

💡 Key Observations

✅ The setEnvironment() method is called after setBeanFactory().

✅ The environment allows access to application properties and profiles.

✅ Best Practice: Use it when a bean needs to read environment properties dynamically.

Step 7: Understanding `setEmbeddedValueResolver()`

Now that we've covered setEnvironment(), the next lifecycle method is EmbeddedValueResolverAware#setEmbeddedValueResolver().

🔹 What Happens at This Stage?

After setting environment access, Spring calls setEmbeddedValueResolver().
This method provides a StringValueResolver that allows resolving embedded placeholders (e.g., ${server.port} or #{expression}).
Useful when dealing with property placeholders or Spring Expression Language (SpEL).

🔹 Practical Example: Resolving Embedded Placeholders

We've extended MyDynamicBean to implement EmbeddedValueResolverAware:

class MyDynamicBean implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, EnvironmentAware, EmbeddedValueResolverAware {
    private String beanName;
    private ClassLoader classLoader;
    private BeanFactory beanFactory;
    private Environment environment;
    private StringValueResolver valueResolver;

    public MyDynamicBean() {
        System.out.println("MyDynamicBean instantiated!");
    }

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

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
        System.out.println("Bean ClassLoader set: " + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("BeanFactory set: " + beanFactory);
    }

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
        System.out.println("Environment set: " + environment);
        System.out.println("Active Profile: " + environment.getActiveProfiles());
        System.out.println("Server Port: " + environment.getProperty("server.port"));
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.valueResolver = resolver;
        String resolvedValue = valueResolver.resolveStringValue("${server.port}");
        System.out.println("Embedded Value Resolved: " + resolvedValue);
    }
}

💡 Key Observations

✅ The setEmbeddedValueResolver() method is called after setEnvironment().

✅ Allows resolving placeholders like ${property.name} dynamically.

✅ Best Practice: Use this when a bean needs to dynamically resolve properties or SpEL expressions.

Step 8: Understanding `setResourceLoader()`

Now that we've covered setEmbeddedValueResolver(), the next lifecycle method is ResourceLoaderAware#setResourceLoader().

🔹 What Happens at This Stage?

After setting the embedded value resolver, Spring calls setResourceLoader().
This method provides a ResourceLoader, which allows loading external resources such as:
- Files from the classpath (classpath:/config.xml)
- Files from the file system (file:/tmp/config.xml)
- URLs (https://example.com/config.xml)

🔹 Practical Example: Accessing Resources

We've extended MyDynamicBean to implement ResourceLoaderAware:

class MyDynamicBean implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, EnvironmentAware, EmbeddedValueResolverAware, ResourceLoaderAware {
    private String beanName;
    private ClassLoader classLoader;
    private BeanFactory beanFactory;
    private Environment environment;
    private StringValueResolver valueResolver;
    private ResourceLoader resourceLoader;

    public MyDynamicBean() {
        System.out.println("MyDynamicBean instantiated!");
    }

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

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
        System.out.println("Bean ClassLoader set: " + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("BeanFactory set: " + beanFactory);
    }

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
        System.out.println("Environment set: " + environment);
        System.out.println("Active Profile: " + environment.getActiveProfiles());
        System.out.println("Server Port: " + environment.getProperty("server.port"));
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.valueResolver = resolver;
        String resolvedValue = valueResolver.resolveStringValue("${server.port}");
        System.out.println("Embedded Value Resolved: " + resolvedValue);
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
        System.out.println("ResourceLoader set: " + resourceLoader);

        // Example usage: Load a file from classpath
        System.out.println("Loading resource example: " + resourceLoader.getResource("classpath:application.properties").exists());
    }
}

💡 Key Observations

✅ The setResourceLoader() method is called after setEmbeddedValueResolver().

✅ The ResourceLoader allows loading external files dynamically.

✅ Best Practice: Use ResourceLoader when a bean needs to load external configurations or static assets.

Step 9: Understanding `setApplicationEventPublisher()`

Now that we've covered setResourceLoader(), the next lifecycle method is ApplicationEventPublisherAware#setApplicationEventPublisher().

🔹 What Happens at This Stage?

After setting the resource loader, Spring calls setApplicationEventPublisher().
This method provides an ApplicationEventPublisher, which allows the bean to:
- Publish custom application events.
- Trigger event-driven components (such as @EventListener).

🔹 Practical Example: Publishing an Event

We've extended MyDynamicBean to implement ApplicationEventPublisherAware:

class MyDynamicBean implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, EnvironmentAware, EmbeddedValueResolverAware, ResourceLoaderAware, ApplicationEventPublisherAware {
    private String beanName;
    private ClassLoader classLoader;
    private BeanFactory beanFactory;
    private Environment environment;
    private StringValueResolver valueResolver;
    private ResourceLoader resourceLoader;
    private ApplicationEventPublisher eventPublisher;

    public MyDynamicBean() {
        System.out.println("MyDynamicBean instantiated!");
    }

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

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
        System.out.println("Bean ClassLoader set: " + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
        System.out.println("BeanFactory set: " + beanFactory);
    }

    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
        System.out.println("Environment set: " + environment);
        System.out.println("Active Profile: " + environment.getActiveProfiles());
        System.out.println("Server Port: " + environment.getProperty("server.port"));
    }

    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.valueResolver = resolver;
        String resolvedValue = valueResolver.resolveStringValue("${server.port}");
        System.out.println("Embedded Value Resolved: " + resolvedValue);
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
        System.out.println("ResourceLoader set: " + resourceLoader);
        System.out.println("Loading resource example: " + resourceLoader.getResource("classpath:application.properties").exists());
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
        System.out.println("ApplicationEventPublisher set: " + eventPublisher);

        // Publish a custom event
        eventPublisher.publishEvent(new CustomEvent(this, "Test Event Message"));
    }
}

// Custom Event Class
class CustomEvent extends org.springframework.context.ApplicationEvent {
    private final String message;

    public CustomEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

// Listener for Custom Events
@Component
class CustomEventListener {
    @org.springframework.context.event.EventListener
    public void handleCustomEvent(CustomEvent event) {
        System.out.println("Received Custom Event: " + event.getMessage());
    }
}

💡 Key Observations

✅ The setApplicationEventPublisher() method is called after setResourceLoader().

✅ The ApplicationEventPublisher allows beans to trigger application events.

✅ Best Practice: Use ApplicationEventPublisher for decoupling components via event-driven programming.

Step 10: Understanding `setMessageSource()`

Now that we've covered setApplicationEventPublisher(), the next lifecycle method is MessageSourceAware#setMessageSource().

🔹 What Happens at This Stage?

After setting the ApplicationEventPublisher, Spring calls setMessageSource().
This method provides a MessageSource, which allows beans to:
- Retrieve localized messages (for internationalization).
- Access messages.properties files for text translations.

🔹 Practical Example: Retrieving Messages

We've extended MyDynamicBean to implement MessageSourceAware:

@Override
public void setMessageSource(MessageSource messageSource) {
    this.messageSource = messageSource;
    System.out.println("MessageSource set: " + messageSource);

    // Retrieve a message from messages.properties (if configured)
    System.out.println("Example message: " + messageSource.getMessage("example.message", null, "Default Message", null));
}

💡 Key Observations

✅ The setMessageSource() method is called after setApplicationEventPublisher().

✅ MessageSource allows retrieving localized messages dynamically.

✅ Best Practice: Use MessageSource for internationalization and text localization.

Step 11: Understanding `setApplicationContext()`

Now that we've covered setMessageSource(), the next lifecycle method is ApplicationContextAware#setApplicationContext().

🔹 What Happens at This Stage?

After setting the MessageSource, Spring calls setApplicationContext().
This method provides an ApplicationContext, which allows beans to:
- Access all beans in the Spring container.
- Retrieve environment properties.
- Interact with the lifecycle of the entire application.

🔹 Practical Example: Accessing the ApplicationContext

We've extended MyDynamicBean to implement ApplicationContextAware:

@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    this.applicationContext = applicationContext;
    System.out.println("ApplicationContext set: " + applicationContext);

    // Example: Retrieving a bean dynamically
    MyDynamicBean anotherBean = applicationContext.getBean(MyDynamicBean.class);
    System.out.println("Retrieved bean from ApplicationContext: " + anotherBean);
}

💡 Key Observations

✅ The setApplicationContext() method is called after setMessageSource().

✅ ApplicationContext provides access to all registered beans dynamically.

✅ Best Practice: Use @Autowired instead of manually accessing the ApplicationContext, unless necessary.

Step 12: Understanding `setServletContext()`

Now that we've covered setApplicationContext(), the next lifecycle method is ServletContextAware#setServletContext() (applicable for web applications).

🔹 What Happens at This Stage?

After setting the ApplicationContext, Spring calls setServletContext().
This method provides access to the ServletContext, allowing the bean to:
- Interact with web-related resources.
- Retrieve application-wide configuration parameters.
- Access web-related objects like request/session attributes.

🔹 Practical Example: Accessing the ServletContext

We've extended MyDynamicBean to implement ServletContextAware:

@Override
public void setServletContext(ServletContext servletContext) {
    this.servletContext = servletContext;
    System.out.println("ServletContext set: " + servletContext);

    // Example: Retrieving a context parameter
    String contextParam = servletContext.getInitParameter("someConfig");
    System.out.println("Context Parameter: " + contextParam);
}

💡 Key Observations

✅ The setServletContext() method is called after setApplicationContext().

✅ ServletContext allows interaction with web-specific components.

✅ Best Practice: Use ServletContext only when necessary; prefer Spring beans for managing web configurations.

Step 13: Understanding `postProcessBeforeInitialization()`

Now that we've covered setServletContext(), the next lifecycle method is BeanPostProcessor#postProcessBeforeInitialization().

🔹 What Happens at This Stage?

Spring calls postProcessBeforeInitialization() before the initialization callbacks (@PostConstruct, InitializingBean#afterPropertiesSet()).
This method allows beans to:
- Modify bean properties before initialization.
- Apply proxying, validation, or logging before initialization.

🔹 Practical Example: Intercepting Bean Initialization

We've added a BeanPostProcessor to modify beans before initialization:

@Component
class CustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization called for: " + beanName);
        return bean;
    }
}

💡 Key Observations

✅ The postProcessBeforeInitialization() method is called before @PostConstruct and afterPropertiesSet().

✅ Best Practice: Use this for bean modifications, logging, or applying custom initialization logic.

Step 14: Understanding `@PostConstruct` and `afterPropertiesSet()`

Now that we've covered postProcessBeforeInitialization(), the next lifecycle methods are @PostConstruct and InitializingBean#afterPropertiesSet().

🔹 What Happens at This Stage?

Spring calls initialization callbacks after postProcessBeforeInitialization(), including:
- @PostConstruct: A method annotated with @PostConstruct runs after dependency injection is completed.
- afterPropertiesSet(): This method is part of the InitializingBean interface and runs after all properties are set.
These methods are typically used for:
- Validating required properties.
- Setting up resources after dependency injection.

🔹 Practical Example: Using `@PostConstruct` and `afterPropertiesSet()`

We've modified MyDynamicBean to implement InitializingBean and added a @PostConstruct method:

@PostConstruct
public void postConstruct() {
    System.out.println("@PostConstruct method executed");
}

@Override
public void afterPropertiesSet() throws Exception {
    System.out.println("afterPropertiesSet() method executed");
}

💡 Key Observations

✅ @PostConstruct runs before afterPropertiesSet().

✅ Best Practice: Use @PostConstruct for setup logic, and afterPropertiesSet() when implementing InitializingBean.

✅ Avoid implementing InitializingBean unless absolutely necessary, as @PostConstruct is more flexible.

Step 15: Understanding `postProcessAfterInitialization()`

Now that we've covered @PostConstruct and afterPropertiesSet(), the next lifecycle method is BeanPostProcessor#postProcessAfterInitialization().

🔹 What Happens at This Stage?

Spring calls postProcessAfterInitialization() after initialization callbacks (@PostConstruct, afterPropertiesSet()).
This method allows:
- Applying proxying mechanisms (e.g., AOP).
- Performing post-initialization modifications (e.g., wrapping the bean).

🔹 Practical Example: Intercepting Bean Post-Initialization

We've extended CustomBeanPostProcessor to implement postProcessAfterInitialization():

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    System.out.println("postProcessAfterInitialization called for: " + beanName);
    return bean;
}

💡 Key Observations

✅ The postProcessAfterInitialization() method is called after @PostConstruct and afterPropertiesSet().

✅ Best Practice: Use this method for applying proxies or final modifications after the bean is fully initialized.

Step 16: Understanding `@PreDestroy` and `destroy()`

Now that we've covered postProcessAfterInitialization(), the final lifecycle methods are @PreDestroy and DisposableBean#destroy().

🔹 What Happens at This Stage?

Spring calls destruction callbacks before shutting down the application.
These methods ensure proper resource cleanup:
- @PreDestroy: Runs before the bean is destroyed, ideal for closing resources.
- destroy(): From DisposableBean, allows executing destruction logic.

🔹 Practical Example: Cleaning Up Resources

We've modified MyDynamicBean to implement DisposableBean and added a @PreDestroy method:

@PreDestroy
public void preDestroy() {
    System.out.println("@PreDestroy method executed");
}

@Override
public void destroy() throws Exception {
    System.out.println("destroy() method executed");
}

💡 Key Observations

✅ @PreDestroy runs before destroy().

✅ Best Practice: Use @PreDestroy for graceful shutdown and destroy() if implementing DisposableBean.

✅ Avoid implementing DisposableBean unless required, as @PreDestroy is more flexible.

Happy coding 🚀

Here I systematically explore Spring's lifecycle methods by implementing them one by one in a structured way 🚀

Step 1: Understanding registerBeanDefinition() in Practice

🔹 What Happens at This Stage?

🔹 Practical Example: Registering a Bean Manually

🔹 Key Takeaways

Step 2: Understanding postProcessBeforeInstantiation()

🔹 What Happens at This Stage?

🔹 Practical Example: Intercepting Bean Instantiation

💡 Key Observations

Step 3: Understanding setBeanName()

🔹 What Happens at This Stage?

🔹 Practical Example: Bean Recognizing Its Own Name

💡 Key Observations

Step 4: Understanding setBeanClassLoader()

🔹 What Happens at This Stage?

🔹 Practical Example: Accessing Bean ClassLoader

💡 Key Observations

Step 5: Understanding setBeanFactory()

🔹 What Happens at This Stage?

🔹 Practical Example: Accessing the BeanFactory

💡 Key Observations

Step 6: Understanding setEnvironment()

🔹 What Happens at This Stage?

🔹 Practical Example: Accessing Environment Variables

💡 Key Observations

Step 7: Understanding setEmbeddedValueResolver()

🔹 What Happens at This Stage?

🔹 Practical Example: Resolving Embedded Placeholders

💡 Key Observations

Step 8: Understanding setResourceLoader()

🔹 What Happens at This Stage?

🔹 Practical Example: Accessing Resources

💡 Key Observations

Step 9: Understanding setApplicationEventPublisher()

🔹 What Happens at This Stage?

🔹 Practical Example: Publishing an Event

💡 Key Observations

Step 10: Understanding setMessageSource()

🔹 What Happens at This Stage?

🔹 Practical Example: Retrieving Messages

💡 Key Observations

Step 11: Understanding setApplicationContext()

🔹 What Happens at This Stage?

🔹 Practical Example: Accessing the ApplicationContext

💡 Key Observations

Step 12: Understanding setServletContext()

🔹 What Happens at This Stage?

🔹 Practical Example: Accessing the ServletContext

💡 Key Observations

Step 13: Understanding postProcessBeforeInitialization()

🔹 What Happens at This Stage?

🔹 Practical Example: Intercepting Bean Initialization

💡 Key Observations

Step 14: Understanding @PostConstruct and afterPropertiesSet()

🔹 What Happens at This Stage?

🔹 Practical Example: Using @PostConstruct and afterPropertiesSet()

💡 Key Observations

Step 15: Understanding postProcessAfterInitialization()

🔹 What Happens at This Stage?

🔹 Practical Example: Intercepting Bean Post-Initialization

💡 Key Observations

Step 16: Understanding @PreDestroy and destroy()

🔹 What Happens at This Stage?

🔹 Practical Example: Cleaning Up Resources

💡 Key Observations

Read next

Token Bucket Rate Limiter (Redis & Java)

React Component Composition Design Pattern With Examples

3223. Minimum Length of String After Operations

How to easily add 3D Models to your React apps.

Step 1: Understanding `registerBeanDefinition()` in Practice

Step 2: Understanding `postProcessBeforeInstantiation()`

Step 3: Understanding `setBeanName()`

Step 4: Understanding `setBeanClassLoader()`

Step 5: Understanding `setBeanFactory()`

🔹 Practical Example: Accessing the `BeanFactory`

Step 6: Understanding `setEnvironment()`

Step 7: Understanding `setEmbeddedValueResolver()`

Step 8: Understanding `setResourceLoader()`

Step 9: Understanding `setApplicationEventPublisher()`

Step 10: Understanding `setMessageSource()`

Step 11: Understanding `setApplicationContext()`

Step 12: Understanding `setServletContext()`

Step 13: Understanding `postProcessBeforeInitialization()`

Step 14: Understanding `@PostConstruct` and `afterPropertiesSet()`

🔹 Practical Example: Using `@PostConstruct` and `afterPropertiesSet()`

Step 15: Understanding `postProcessAfterInitialization()`

Step 16: Understanding `@PreDestroy` and `destroy()`