1. Introdução
Este artigo fala principalmente sobre o ciclo de vida do feijão no contêiner do Spring COI
Ciclo de vida do feijão primavera
O ciclo de declaração do bean no Spring pode ser dividido nos quatro estágios a seguir:
- Fase de instanciação - a instanciação chama o construtor
- Fase de atribuição de atributo - preencher configura injeção de dependência
- Inicialização --- Chamada de inicialização Método Init
- Destruction-Destruction chama o método Destory
Interfaces e métodos em vários estágios
Cada estágio é uma interface e método específicos, de acordo com o tipo de método e interface, podemos ser divididos nas seguintes categorias:
- A interface e o método do próprio método init, do método destroy
- Interface do ciclo de vida do bean BeanNameAware, ApplicationContextAware, BeanFactoryAware, InitializingBean, DisposableBean
- A interface do ciclo de vida no nível do contêiner inclui principalmente BeanPostProcessor, InstantiationAwareBeanPostProcessor
- Interface de processamento no nível de fábrica BeanFactoryPostProcessor
Processo de execução
Acabei de mencionar a ordem de execução de muitas interfaces e métodos acima?
O código BeanLifecycle é o seguinte
/**
* @ClassName BeanLifecycle
* @Auther burgxun
* @Description: Spring bean 的生命周期
* @Date 2020/4/21 12:45
**/
public class BeanLifecycle implements BeanNameAware, ApplicationContextAware, BeanFactoryAware,InitializingBean,
DisposableBean {
public BeanLifecycle() {
System.out.println("========>【Bean】【BeanLifecycle】执行 构造函数");
}
@Override
public void setBeanName(String s) {
System.out.println("========>【Bean】【BeanNameAware】 执行方法 setBeanName -------》实例化bean后 " +
"为bean 注入BeanName-" + s);
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("========>【Bean】【ApplicationContextAware】 执行方法 " +
"setApplicationContext-------》实例化bean后 为bean注入ApplicationContext");
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("========>【Bean】【BeanFactoryAware】 执行方法 setBeanFactory -------》实例化bean后 ");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("========>【Bean】【InitializingBean】执行方法 afterPropertiesSet -------》bean" +
" 实例化完成后 初始化之前调用");
}
public void beanInit() {
System.out.println("========>【Bean】【BeanLifecycle】 执行方法 Init-Method " +
"-------》xml中配置bean实例化完成后 初始化方法");
}
public void beanDestroy() {
System.out.println("========>【Bean】【BeanLifecycle】 执行方法 Destroy-Method " +
"-------》xml中配置销毁bean之前 回调方法" +
" ");
}
public void sayHello() {
System.out.println("========>【Bean】【BeanLifecycle】执行方法 bean中方法 -------》 sayHello");
}
@Override
public void destroy() throws Exception {
System.out.println("========>【Bean】【DisposableBean】 执行方法 destroy -------》 销毁 Bean 的回调方法");
}
}
O método ContainerLifecycle é o seguinte:
**
* @ClassName ContainerLifecycle
* @Auther burgxun
* @Description: Spring 容器 生命周期
* @Date 2020/4/21 14:44
**/
@Component
public class ContainerLifecycle extends InstantiationAwareBeanPostProcessorAdapter {
public ContainerLifecycle() {
System.out.println("========>【Container】【ContainerLifecycle】 执行 构造函数");
}
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
System.out.println("========>【Container】【InstantiationAwareBeanPostProcessor】执行 " +
"postProcessBeforeInstantiation" +
"-------》Bean实例化之前调用 beanName:" + beanName);
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
System.out.println("========>【Container】【InstantiationAwareBeanPostProcessor】执行 " +
"postProcessAfterInstantiation " +
"-------》Bean实例化之后调用 beanName:" + beanName);
return super.postProcessAfterInstantiation(bean, beanName);
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("========>【Container】【BeanPostProcessor】 执行" +
"postProcessBeforeInitialization " +
"-------》Bean初始化之前调用 beanName:" + beanName);
return super.postProcessBeforeInitialization(bean, beanName);
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("========>【Container】【BeanPostProcessor】执行 " +
"postProcessAfterInitialization " +
"-------》Bean初始化之后调用 beanName:" + beanName);
return super.postProcessAfterInitialization(bean, beanName);
}
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
System.out.println("========>【Container】【InstantiationAwareBeanPostProcessor】 执行 postProcessProperties " +
"Bean 属性赋值的时候 beanName:" + beanName);
return null;
}
}
O código FactoryLifecycle é o seguinte
/**
* @ClassName FactoryLifecycle
* @Auther burgxun
* @Description: Spring beanFactory 如下
* @Date 2020/4/21 17:32
**/
public class FactoryLifecycle implements BeanFactoryPostProcessor {
public FactoryLifecycle() {
System.out.println("========>【BeanFactory】【BeanFactoryPostProcessor】 执行 FactoryLifecycle " +
"构造函数");
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
System.out.println("========>【BeanFactory】【BeanFactoryPostProcessor】 执行方法 " +
"postProcessBeanFactory ");
}
}
Teste do feijão de primavera
public class SpringTest {
@Test
public void mySpringBeanTest() {
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath" +
":Spring-life.xml");
BeanLifecycle beanLifecycle = (BeanLifecycle) context.getBean("beanLifecycle");
beanLifecycle.sayHello();
context.close();
}
}
O resultado da execução é:
【BeanFactory】【BeanFactoryPostProcessor】 执行 FactoryLifecycle 构造函数
【BeanFactory】【BeanFactoryPostProcessor】 执行方法 postProcessBeanFactory
【Container】【ContainerLifecycle】 执行 构造函数
【Container】【InstantiationAwareBeanPostProcessor】执行 postProcessBeforeInstantiation-------》Bean实例化之前调用 beanName:beanLifecycle
【Bean】【BeanLifecycle】执行 构造函数
【Container】【InstantiationAwareBeanPostProcessor】执行 postProcessAfterInstantiation -------》Bean实例化之后调用 beanName:beanLifecycle
【Container】【InstantiationAwareBeanPostProcessor】 执行 postProcessProperties Bean 属性赋值的时候 beanName:beanLifecycle
【Bean】【BeanNameAware】 执行方法 setBeanName -------》实例化bean后 为bean 注入BeanName-beanLifecycle
【Bean】【BeanFactoryAware】 执行方法 setBeanFactory -------》实例化bean后 为bean注入BeanFactory
【Bean】【ApplicationContextAware】 执行方法 setApplicationContext-------》实例化bean后 为bean注入ApplicationContext
【Container】【BeanPostProcessor】 执行postProcessBeforeInitialization -------》Bean初始化之前调用 beanName:beanLifecycle
【Bean】【InitializingBean】执行方法 afterPropertiesSet -------》bean 实例化完成后 初始化之前调用
【Bean】【BeanLifecycle】 执行方法 Init-Method -------》xml中配置bean实例化完成后 初始化方法
【Container】【BeanPostProcessor】执行 postProcessAfterInitialization -------》Bean初始化之后调用 beanName:beanLifecycle
【Bean】【BeanLifecycle】执行方法 bean中方法 -------》 sayHello
【Bean】【DisposableBean】 执行方法 destroy -------》 销毁 Bean 的回调方法
【Bean】【BeanLifecycle】 执行方法 Destroy-Method -------》xml中配置销毁bean之前 回调方法
Em seguida, continue a desenhar um fluxograma
O processo do método foi resolvido
Resuma novamente
os três métodos de chamada de inicialização e destruição de beans no Spring
- Concluído pela interface InitializingBean / DisposableBean
- Especifique o método a ser chamado adicionando init-method / destroy-method à configuração do elemento do bean
- Especifique o método de chamada via anotação @PostConstruct ou @PreDestroy
Qual é a ordem de execução deles?
A resposta é o método "interface method" da anotação configurado no elemento bean