Qual é o ciclo de vida de um objeto criado no Spring?

1. Instanciar: O Spring cria uma instância do objeto.
2. Preencher propriedades: Dependências (campos marcados com @Autowired, @Value, etc.) são injetadas através de setters ou campos.
3. Interfaces Aware: Se o bean implementar BeanNameAware, BeanFactoryAware, ApplicationContextAware ou outras interfaces Aware, o Spring chama os métodos correspondentes (setBeanName, setBeanFactory, setApplicationContext, etc.), passando o contexto.
4. BeanPostProcessors (pré-inicialização): Antes de chamar os métodos de inicialização, postProcessBeforeInitialization dos BeanPostProcessor registrados é chamado.
5. Bean de inicialização:
   • Se o bean implementar InitializingBean, seu método afterPropertiesSet() é chamado.
   • Se uma método de inicialização for especificado via @Bean(initMethod="...") ou init-method em XML, esse método é chamado.
6. BeanPostProcessors (pós-inicialização): Após a inicialização, postProcessAfterInitialization dos BeanPostProcessor registrados é chamado. Nesta etapa, frequentemente são criados objetos proxy (por exemplo, para transações ou segurança).
7. Pronto para uso: O objeto é considerado totalmente configurado e pronto para uso.
8. Destruir:
   • Se o bean implementar DisposableBean, seu método destroy() é chamado.
   • Se uma método de destruição for especificado via @Bean(destroyMethod="...") ou destroy-method em XML, esse método é chamado.
   • O método marcado com @PreDestroy é chamado.
9. Limpeza: O Spring remove o bean do contexto.

// Exemplo de um bean participando do ciclo de vida
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.BeanNameAware;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class MySpringBean implements InitializingBean, DisposableBean, BeanNameAware {

    private String beanName;

    // 2. Preencher propriedades (via setter)
    private Dependency requiredDependency;

    public void setRequiredDependency(Dependency requiredDependency) {
        System.out.println("2. Definindo dependência");
        this.requiredDependency = requiredDependency;
    }

    // 3. Interfaces Aware
    @Override
    public void setBeanName(String name) {
        System.out.println("3. Definindo nome do bean: " + name);
        this.beanName = name;
    }

    // 5. Bean de inicialização (de InitializingBean)
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("5. Chamado afterPropertiesSet() de InitializingBean");
        // Lógica de inicialização
    }

    // 5. Bean de inicialização (de @PostConstruct)
    @PostConstruct
    public void postConstructMethod() {
        System.out.println("5. Método @PostConstruct chamado");
        // Lógica de inicialização
    }

    // 5. Método de inicialização personalizado
    public void customInitMethod() {
        System.out.println("5. Método init personalizado chamado");
        // Lógica de inicialização
    }

    // 7. Pronto para usar
    public void doSomething() {
        System.out.println("7. O bean está pronto e fazendo algo");
    }

    // 8. Destruir (de DisposableBean)
    @Override
    public void destroy() throws Exception {
        System.out.println("8. Método destroy() de DisposableBean chamado");
        // Lógica de limpeza
    }

    // 8. Destruir (de @PreDestroy)
    @PreDestroy
    public void preDestroyMethod() {
        System.out.println("8. Método @PreDestroy chamado");
        // Lógica de limpeza
    }

    // 8. Destruir (método destroy personalizado)
    public void customDestroyMethod() {
        System.out.println("8. Método destroy personalizado chamado");
        // Lógica de limpeza
    }

    // Classe interna para exemplo de dependência
    public static class Dependency {
        // ...
    }
}