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:
1. Load all bean definitions, creating an ordered graph.
2. Instantiate and run BeanFactoryPostProcessors (you can update bean
definitions here).
3. Instantiate each bean.
4. Spring injects the values and bean references into the beans' properties.
5. Spring passes the ID of the bean to the setBeanName() method of the
BeanNameAware interface if any bean implements it.
6. Spring passes the reference of the bean factory itself to the
setBeanFactory() method of BeanFactoryAware if any bean implements it.
7. Spring passes the reference of the application context itself to the
setApplicationContext() method of ApplicationContextAware if any bean
implements it.
8. 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().
9. 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.
10. 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().
11. 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.
12. 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.
13. These steps show the life cycle of Spring beans in the container.
14. The next section describes the modules that are provided by the Spring
Framework.
英文部分来源book：Spring 5 Design Patterns
来看一下源码如何实现的：
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
初始化生命周期
// Initialize the bean instance.
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
}org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean
主要是bean的InstantiationAwareBeanPostProcessors和属性值的设置及依赖注入，对应上文中的2，3，4。
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)
主要是上文中5-10提到的各种Aware及初始化的操作。
具体源码都可以了解到具体细节，不再复述。
