ciclo de vida do feijão
Artigo reimpresso: https://blog.csdn.net/qq_39323228/article/details/103284456
https://blog.csdn.net/w_linux/article/details/80086950
- Instancie o objeto bean (via construtor ou método de fábrica)
- Defina as propriedades do objeto (setter, etc.) (injeção de dependência)
- Se o Bean implementa a interface BeanNameAware, a fábrica chama o método setBeanName () do Bean para passar o ID do Bean. (E o seguinte é para verificar a interface do Aware)
- Se o Bean implementa a interface BeanFactoryAware, a fábrica chama o método setBeanFactory () para passar na própria fábrica
- Passe a instância do Bean para o método postProcessBeforeInitialization (Object bean, String beanname) do pré-processador do Bean
- Chame o método de inicialização do Bean
- Passe a instância do Bean para o método postProcessAfterInitialization (Object bean, String beanname) do pós-processador do Bean
- Use Bean
- Antes que o contêiner seja fechado, chame o método de destruição do Bean
Depois de ler os dois artigos acima com atenção, eu basicamente entendi. Aqui está o código para entender o ciclo de vida
package com.example.Spingbootdemo.dto;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
/**
* @Author: xx
* @Date: 2020/12/5
*/
public class LomBoom implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean,
DisposableBean {
private String field;
public LomBoom() {
System.out.println("SpringBean 构造方法");
}
public String getField() {
System.out.println("SpringBean get方法");
return field;
}
public void setField(String field) {
System.out.println("SpringBean set方法");
this.field = field;
}
@Override
public void setBeanName(String s) {
System.out.println("BeanName:"+s);
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("BeanFactory");
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("ApplicationContext");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("afterPropertiesSet");
}
@Override
public void destroy() throws Exception {
System.out.println("destroy");
}
public void init(){
System.out.println("init");
}
public void des(){
System.out.println("des");
}
}
package com.example.Spingbootdemo;
import com.example.Spingbootdemo.dto.LomBoom;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
@SpringBootApplication
public class SpingbootdemoApplication {
public static void main(String[] args) {
SpringApplication.run(SpingbootdemoApplication.class, args);
//ApplicationContext context = new AnnotationConfigApplicationContext(LomBoom.class);
ApplicationContext context=new ClassPathXmlApplicationContext("component-bean.xml");
LomBoom lomBoom = (LomBoom) context.getBean("lomBoom");
//Bean的使用
System.out.println(lomBoom);
//关闭容器
((AbstractApplicationContext) context).close();
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
default-autowire="byName">
<bean id="lomBoom" class="com.example.Spingbootdemo.dto.LomBoom" init-method="init" destroy-method="des" >
<property name="field" value="test" />
</bean>
</beans>
escopo de feijão
Spring 3 define 5 escopos para o Bean, a saber, singleton (singleton), protótipo (protótipo), solicitação, sessão e sessão global. Os 5 escopos são explicados da seguinte maneira:
- Singleton: modo Singleton. Apenas uma instância de Bean compartilhada existe no contêiner Spring IoC. Não importa quantos Beans se refiram a ela, ele sempre aponta para o mesmo objeto. O escopo Singleton é o escopo padrão no Spring. Você também pode definir explicitamente o Bean como um modo singleton e configurá-lo como:
- <bean id = "userDao" class = "com.ioc.UserDaoImpl" scope = "singleton" />
- Protótipo: modo de protótipo Cada vez que um bean definido por protótipo é obtido através do container Spring, o container irá criar uma nova instância de Bean.Cada instância de Bean tem suas próprias propriedades e estado, enquanto o singleton tem apenas um objeto globalmente. De acordo com a experiência, use o escopo do protótipo para beans com estado e o escopo singleton para beans sem estado.
- solicitação: em uma solicitação Http, o contêiner retornará a mesma instância do Bean. Para diferentes solicitações Http, um novo bean será gerado e o bean só é válido na Solicitação Http atual.
- <bean id = "loginAction" class = "com.cnblogs.Login" scope = "request" />, para cada solicitação Http, o contêiner Spring cria uma nova instância de acordo com a definição do bean, e a instância está apenas no solicitação Http atual A solicitação é válida, mas outras solicitações não podem ver as mudanças de estado na solicitação atual. Quando a solicitação Http atual terminar, a instância do bean também será destruída.
- Sessão: Em uma Sessão Http, o contêiner retornará a mesma instância do Bean. Uma solicitação para uma Sessão diferente criará uma nova instância, e a instância do bean só é válida na Sessão atual.
- <bean id = "userPreference" class = "com.ioc.UserPreference" scope = "session" />, o mesmo que a solicitação Http, cada solicitação de sessão cria uma nova instância, e instâncias diferentes não compartilham atributos e instâncias É apenas válido em sua própria solicitação de sessão. Quando a solicitação terminar, a instância será destruída.
- Sessão Global: Em uma Sessão Http global, o contêiner retornará a mesma instância do Bean, que só é válida quando o contexto do portlet é usado.