一，通过@Bean注解指定初始化和销毁方法
<bean id="person" class="com.practice.bean.Person" init-method="" destroy-method="" >和在XML配置文件中的格式一样，在@Bean注解中也有这两个属性
String initMethod() default "";
String destroyMethod() default AbstractBeanDefinition.INFER_METHOD;在Person类中新建init和destroy方法
private void init() {
System.out.println("----->执行init方法");
}
private void destroy() {
System.out.println("----->执行destroy方法");
}配置类为：
@Configuration
@ComponentScan(value = "com.practice")
public class MainConfig {
@Bean(initMethod = "init",destroyMethod = "destroy")
public Person person() {
return new Person("Alen", 21);
}
}执行测试类：
@Test
public void test01() {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
Person bean = applicationContext.getBean(Person.class);
System.out.println(bean.toString());
applicationContext.close();
}打印结果如下：
----->执行init方法
Person{name='Alen', age=21}
----->执行destroy方法可以看出在容器创建的时候执行了init的方法（可以将getBean(Person.class)注释掉），在容器销毁时执行了destroy方法。
以上是在该对象为单例的情况下，那么在多例的情况下又是如何呢？
//为配置类中加载的组件加上如下注释
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)可以看出，在容器创建的时候并没有执行初始化方法，是在获取该组件的时候执行init方法。而在容器关闭时也不会执行destroy方法。
二，通过实现InitializingBean（定义初始化逻辑）
DisposableBean（定义销毁逻辑）
让Person类实现这两个接口，可以看到需要实现两个方法：
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("--->执行afterPropertiesSet方法");
}
@Override
public void destroy() throws Exception {
System.out.println("--->执行destroy方法");
}执行测试类，结果如下：
--->执行afterPropertiesSet方法
Person{name='Alen', age=21}
--->执行destroy方法多例情况下也和第一部分中的情况一致。
三，可以使用JSR250：
@PostConstruct和@PreDestroy注解
在Person类中，实现如下：
@PostConstruct
private void init() {
System.out.println("----->执行init方法");
}
@PreDestroy
private void destroy() {
System.out.println("----->执行destroy方法");
}执行测试类，结果如下：
----->执行init方法
Person{name='Alen', age=21}
----->执行destroy方法多例情况下也和第一部分中的情况一致。
四，实现BeanPostProcessor（Bean的后置处理器）
Spring还提供了BeanPostProcessor接口在执行初始化前和初始化后的处理器，在该接口中定义了以下两个方法：
public interface BeanPostProcessor {
@Nullable
default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Nullable
default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
}Person实现该接口，重写这两个方法。
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("--->执行postProcessBeforeInitialization方法"+beanName);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("--->执行postProcessAfterInitialization方法"+beanName);
return bean;
}
}执行测试类，结果如下：
--->执行postProcessBeforeInitialization方法mainConfig
--->执行postProcessAfterInitialization方法mainConfig
--->执行postProcessBeforeInitialization方法person
----->执行init方法
--->执行postProcessAfterInitialization方法person
Person{name='Alen', age=21}
----->执行destroy方法可以看出在执行init方法前后，组件person分别调用了postProcessBeforeInitialization方法和postProcessAfterInitialization方法。
那么它是怎么工作的呢，我们在postProcessBeforeInitialization的返回值前加上断点，debug启动测试类：
从容器创建开始进入，找到postProcessBeforeInitialization方法怎么执行的（按照debug路径）：
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
//创建一个新的AnnotationConfigApplicationContext，需要进行属性赋值
//tip：此处逻辑后序阅读源码时再学习
this();
//注册传入的配置类
register(annotatedClasses);
//将传入的资源持久化
refresh();
}进入refresh方法：可以看到调用了finishBeanFactoryInitialization方法--->实例化所有剩下的（非延迟加载）单例。
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);再进入DefaultListableBeanFactory的preInstantiateSingletons方法，按照debug路径，
最终到达AbstractAutowireCapableBeanFactory类的doCreateBean方法，在该方法中有如下代码：
try {
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
}- populateBean()：使用Bean定义中的属性值填充给定BeanWrapper中的Bean实例。
在initializeBean方法中，我们终于看到了解析BeanPostProcessor的方法
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
//执行postProcessBeforeInitialization方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//执行初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
//执行postProcessAfterInitialization方法
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;一。先来看一下applyBeanPostProcessorsBeforeInitialization方法
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}通过getBeanPostProcessors（）方法，获取到所有的BeanPostProcesors列表
0 = {ApplicationContextAwareProcessor@1856}
1 = {ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor@1857}
2 = {PostProcessorRegistrationDelegate$BeanPostProcessorChecker@1858}
3 = {MyBeanPostProcessor@1787}
4 = {CommonAnnotationBeanPostProcessor@1768}
5 = {AutowiredAnnotationBeanPostProcessor@1757}
6 = {ApplicationListenerDetector@1859} 并遍历执行，其中有自定义的MyBeanPostProcessor类，此处将会执行我们重写的postProcessBeforeInitialization方法。在列表中还有InitDestroyAnnotationBeanPostProcessor组件，该组件的作用就是找到容器中加了initAnnotationType注解(或destroyAnnotationType)的方法，并通过反射去调用它,@PostConstruct就属于initAnnotationType注解，所以在此处就会执行Person的init方法。
二。再看一下postProcessAfterInitialization方法，流程也是一样
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}getBeanPostProcessors方法获取用于创建该组件的BeanPostProcessors 列表，遍历并执行postProcessAfterInitialization方法，如果返回的为空则直接返回包装好的该实例。
三。在invokeInitMethods方法中做了什么。
在invokeInitMethods主要有以下两个方法：
((InitializingBean) bean).afterPropertiesSet();
invokeCustomInitMethod(beanName, bean, mbd);1.在该类中先判断了当前组件是否为InitializingBean：bean instanceof InitializingBean。然后执行
((InitializingBean) bean).afterPropertiesSet()方法（在属性赋值完成和BeanPostProcessorsBeforeInitialization方法后）。
2.invokeCustomInitMethod(beanName, bean, mbd)执行客户自定义的初始化方法，此处从RootBeanDefinition获取到initMethodName(此处可以发现@Bean(initMethod = "init",destroyMethod = "destroy")该注解中的init方法)并通过反射调用该方法，执行init方法。
四。BeanPostProcessor在Spring底层的应用
在一中，可以看到applyBeanPostProcessorsBeforeInitialization在获取所有的BeanPostProcesors列表，在列表中还有其他几BeanPostProcessor。
以ApplicationContextAwareProcessor为例，在其方法中为实现ApplicationContextAware接口的组件注入了ApplicationContext；ApplicationContextAwareProcessor源码中可以看出：
先执行实现的postProcessBeforeInitialization，先进行安全验证相关，然后执行了invokeAwareInterfaces(bean)方法：
private void invokeAwareInterfaces(Object bean) {
if (bean instanceof Aware) {
if (bean instanceof EnvironmentAware) {
((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware) {
((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
}
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware) {
((MessageSourceAware) bean).setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
}
}为实现类传入了ApplicationContext。