07.初始化和销毁

07.初始化和销毁

1. 初始化和销毁各自对应的三种方式
2. 初始化和销毁的优先级

一 初始化和销毁对应的方法

1.1 初始化

1. @PostConstruct：
2. 实现InitializingBean重写afterPropertiesSet方法：
3. @Bean时指定初始化方法：

1.2 销毁

1. @PreDestory：
2. 实现DisposableBean重写destroy方法：
3. @Bean时指定销毁方法：

二 执行顺序

创建时：

@PostConstruct > 实现InitializingBean > @Bean时initMethod

销毁时：

@PreDestory > 实现DisposableBean > @Bean时指定destroyMethod

Bean生命周期中的几个重要节点

初始化时：

1. 设置属性值；
2. 调用Bean中的BeanNameAware.setBeanName()方法，如果该Bean实现了BeanNameAware接口；
3. 调用Bean中的BeanFactoryAware.setBeanFactory()方法，如果该Bean实现了BeanFactoryAware接口；
4. 调用BeanPostProcessors.postProcessBeforeInitialization()方法，@PostConstruct注解后的方法就是在这里被执行的
5. 调用Bean中的afterPropertiesSet方法，如果该Bean实现了InitializingBean接口；
6. 调用Bean中的init-method，通常是在配置bean的时候指定了init-method，例如：<bean class=“beanClass” init-method=“init”></bean>
7. 调用BeanPostProcessors.postProcessAfterInitialization()方法；

销毁的时候同理：

1. 调用BeanPostProcessors.postProcessBeforeDestruction()方法，@PreDestroy注解后的方法就是在这里执行的
2. 调用DisposableBean的destroy方法
3. 调用Bean的destroyMethod

注意：在BeanFactory中注册了BeanDefinition时指定Bean为单例时，如果执行了beanFactory.destroySingletons()之后（此时执行销毁方法），再次获取Bean时会仍可以重新获取并且再次执行初始化方法

/**
 * 初始化和销毁的执行顺序
 */
@SpringBootApplication
public class A07_1 {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(A07_1.class, args);
        context.close();
    }

    @Bean(initMethod = "init3")
    public Bean1 bean1() {
        return new Bean1();
    }

    @Bean(destroyMethod = "destroy3")
    public Bean2 bean2() {
        return new Bean2();
    }
}

public class Bean1 implements InitializingBean {
    private static final Logger log = LoggerFactory.getLogger(Bean1.class);

    @PostConstruct
    public void init1() {
        log.debug("初始化1");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        log.debug("初始化2");
    }

    public void init3() {
        log.debug("初始化3");
    }
}

public class Bean2 implements DisposableBean {
    private static final Logger log = LoggerFactory.getLogger(Bean2.class);

    @PreDestroy
    public void destroy1() {
        log.debug("销毁1");
    }

    @Override
    public void destroy() throws Exception {
        log.debug("销毁2");
    }

    public void destroy3() {
        log.debug("销毁3");
    }
}

public class A07_2 {
    public static void main(String[] args) {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        beanFactory.registerBeanDefinition(
                "myBean",
                BeanDefinitionBuilder.genericBeanDefinition(MyBean.class)
                        .setDestroyMethodName("destroy")
                        .getBeanDefinition()
        );

        System.out.println(beanFactory.getBean(MyBean.class));
        beanFactory.destroySingletons(); // 销毁之后, 仍可创建新的单例
        System.out.println(beanFactory.getBean(MyBean.class));
    }

    static class MyBean {
        public MyBean() {
            System.out.println("MyBean()");
        }
        public void destroy() {
            System.out.println("destroy()");
        }
    }
}