- Spring 5 Design Patterns
- Dinesh Rajput
- 470字
- 2021-07-08 09:59:28
Life of a bean in the container
The Spring application context uses the Factory method design pattern to create Spring beans in the container in the correct order according to the given configuration. So the Spring container has the responsibility of managing the life cycle of the bean from creation to destruction. In the normal java application, Java's new keyword is used to instantiate the bean, and it's ready to use. Once the bean is no longer in use, it's eligible for garbage collection. But in the Spring container, the life cycle of the bean is more elaborate. The following image shows the life cycle of a typical Spring bean:

The life cycle of a Spring bean in the Spring container is as follows:
- Load all bean definitions, creating an ordered graph.
- Instantiate and run BeanFactoryPostProcessors (you can update bean definitions here).
- Instantiate each bean.
- Spring injects the values and bean references into the beans' properties.
- Spring passes the ID of the bean to the setBeanName() method of the BeanNameAware interface if any bean implements it.
- Spring passes the reference of the bean factory itself to the setBeanFactory() method of BeanFactoryAware if any bean implements it.
- Spring passes the reference of the application context itself to the setApplicationContext() method of ApplicationContextAware if any bean implements it.
- BeanPostProcessor is an interface, and Spring allows you to implement it with your bean, and modifies the instance of the bean before the initializer is invoked in the Spring bean container by calling its postProcessBeforeInitialization().
- If your bean implements the InitializingBean interface, Spring calls its afterPropertiesSet() method to initialize any process or loading resource for your application. It's dependent on your specified initialization method. There are other methods to achieve this step, for example, you can use the init-method of the <bean> tag, the initMethod attribute of the @Bean annotation, and JSR 250's @PostConstruct annotation.
- BeanPostProcessor is an interface, and spring allows you to implement it with your bean. It modifies the instance of the bean after the initializer is invoked in the spring bean container by calling its postProcessAfterInitialization().
- Now your bean is ready to use in the step, and your application can access this bean by using the getBean() method of the application context. Your beans remain live in the application context until it is closed by calling the close() method of the application context.
- If your bean implements the DisposibleBean interface, Spring calls its destroy() method to destroy any process or clean up the resources of your application. There are other methods to achieve this step-for example, you can use the destroy-method of the <bean> tag, the destroyMethod attribute of the @Bean annotation, and JSR 250's @PreDestroy annotation.
- These steps show the life cycle of Spring beans in the container.
- The next section describes the modules that are provided by the Spring Framework.
推薦閱讀
- 編程卓越之道(卷3):軟件工程化
- 劍指MySQL:架構、調優與運維
- 用戶體驗增長:數字化·智能化·綠色化
- OpenStack Orchestration
- 數據結構與算法分析(C++語言版)
- Android程序設計基礎
- RISC-V體系結構編程與實踐(第2版)
- Raspberry Pi Home Automation with Arduino(Second Edition)
- Clean Code in C#
- JavaScript從入門到精通(視頻實戰版)
- Getting Started with React VR
- Ext JS 4 Plugin and Extension Development
- Scrapy網絡爬蟲實戰
- Learning D
- Yii2 By Example