1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/*** @Author: cuzz* @Date: 2018/9/23 21:20* @Description:*/
public class Car {public Car () {System.out.println("car constructor...");}public void init() {System.out.println("car...init...");}public void destroy() {System.out.println("car...destroy...");}
}

1

<bean id="car" class="com.cuzz.bean.Car" init-method="init" destroy-method="destroy"></bean>

1
2
3
4
5
6
7
8
9
10
11
12
13

/*** @Author: cuzz* @Date: 2018/9/24 12:49* @Description: 配置类*/
@Configuration
public class MainConfigOfLifecycle {@Bean(initMethod = "init", destroyMethod = "destroy")public Car car() {return new Car();}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

/*** @Author: cuzz* @Date: 2018/9/24 13:00* @Description:*/
public class IOCTestLifeCycle {@Testpublic void test01() {// 创建ioc容器AnnotationConfigApplicationContext applicationContext =new AnnotationConfigApplicationContext(MainConfigOfLifecycle.class);System.out.println("容器创建完成...");// 关闭容器System.out.println("--->开始关闭容器");applicationContext.close();System.out.println("--->已经关闭容器");}
}

1
2
3
4
5
6

car constructor...
car...init...
容器创建完成...
--->开始关闭容器
car...destroy...
--->已经关闭容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public interface InitializingBean {/*** Invoked by a BeanFactory after it has set all bean properties supplied* (and satisfied BeanFactoryAware and ApplicationContextAware).* <p>This method allows the bean instance to perform initialization only* possible when all bean properties have been set and to throw an* exception in the event of misconfiguration.* @throws Exception in the event of misconfiguration (such* as failure to set an essential property) or if initialization fails.*/void afterPropertiesSet() throws Exception;}

1
2
3
4
5
6
7
8
9
10
11

public interface DisposableBean {/*** Invoked by a BeanFactory on destruction of a singleton.* @throws Exception in case of shutdown errors.* Exceptions will get logged but not rethrown to allow* other beans to release their resources too.*/void destroy() throws Exception;}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/*** @Author: cuzz* @Date: 2018/9/24 13:36* @Description:*/
public class Cat implements InitializingBean, DisposableBean{public Cat() {System.out.println("cat constructor...");}@Overridepublic void afterPropertiesSet() throws Exception {System.out.println("cat...init...");}@Overridepublic void destroy() throws Exception {System.out.println("cat...destroy...");}}

1
2
3
4
5
6

cat constructor...
cat...init...
容器创建完成...
--->开始关闭容器
cat...destroy...
--->已经关闭容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/*** @Author: cuzz* @Date: 2018/9/24 14:03* @Description:*/
public class Dog {public Dog() {System.out.println("dog constructor...");}@PostConstructpublic void postConstruct() {System.out.println("post construct...");}@PreDestroypublic void preDestroy() {System.out.println("pre destroy...");}
}

1
2
3
4
5
6

dog constructor...
post construct...
容器创建完成...
--->开始关闭容器
pre destroy...
--->已经关闭容器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

/*** Factory hook that allows for custom modification of new bean instances,* e.g. checking for marker interfaces or wrapping them with proxies.** <p>ApplicationContexts can autodetect BeanPostProcessor beans in their* bean definitions and apply them to any beans subsequently created.* Plain bean factories allow for programmatic registration of post-processors,* applying to all beans created through this factory.** <p>Typically, post-processors that populate beans via marker interfaces* or the like will implement {@link #postProcessBeforeInitialization},* while post-processors that wrap beans with proxies will normally* implement {@link #postProcessAfterInitialization}.*/
public interface BeanPostProcessor {/*** Apply this BeanPostProcessor to the given new bean instance <i>before</i> any bean* initialization callbacks (like InitializingBean's {@code afterPropertiesSet}* or a custom init-method). The bean will already be populated with property values.* The returned bean instance may be a wrapper around the original.* @param bean the new bean instance* @param beanName the name of the bean* @return the bean instance to use, either the original or a wrapped one;* if {@code null}, no subsequent BeanPostProcessors will be invoked* @throws org.springframework.beans.BeansException in case of errors* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet*/Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;/*** Apply this BeanPostProcessor to the given new bean instance <i>after</i> any bean* initialization callbacks (like InitializingBean's {@code afterPropertiesSet}* or a custom init-method). The bean will already be populated with property values.* The returned bean instance may be a wrapper around the original.* <p>In case of a FactoryBean, this callback will be invoked for both the FactoryBean* instance and the objects created by the FactoryBean (as of Spring 2.0). The* post-processor can decide whether to apply to either the FactoryBean or created* objects or both through corresponding {@code bean instanceof FactoryBean} checks.* <p>This callback will also be invoked after a short-circuiting triggered by a* {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method,* in contrast to all other BeanPostProcessor callbacks.* @param bean the new bean instance* @param beanName the name of the bean* @return the bean instance to use, either the original or a wrapped one;* if {@code null}, no subsequent BeanPostProcessors will be invoked* @throws org.springframework.beans.BeansException in case of errors* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet* @see org.springframework.beans.factory.FactoryBean*/Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/*** @Author: cuzz* @Date: 2018/9/24 14:21* @Description: 后置处理器，初始化前后进行处理工作*/
public class MyBeanPostProcessor implements BeanPostProcessor{@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {System.out.println("--->postProcessBeforeInitialization..." + beanName +"==>" + bean);return bean;}@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {System.out.println("--->postProcessAfterInitialization..." + beanName +"==>" + bean);return bean;}
}

1
2
3
4
5
6
7
8
9
10
11
12
13

@Configuration
public class MainConfigOfLifecycle {@Beanpublic Cat cat() {return new Cat();}@Beanpublic MyBeanPostProcessor myBeanPostProcessor() {return new MyBeanPostProcessor();}
}

1
2
3
4
5
6
7
8
9
10
11
12

--->postProcessBeforeInitialization...org.springframework.context.event.internalEventListenerProcessor==>org.springframework.context.event.EventListenerMethodProcessor@1dc67c2
--->postProcessAfterInitialization...org.springframework.context.event.internalEventListenerProcessor==>org.springframework.context.event.EventListenerMethodProcessor@1dc67c2
--->postProcessBeforeInitialization...org.springframework.context.event.internalEventListenerFactory==>org.springframework.context.event.DefaultEventListenerFactory@2bd765
--->postProcessAfterInitialization...org.springframework.context.event.internalEventListenerFactory==>org.springframework.context.event.DefaultEventListenerFactory@2bd765
cat constructor...
--->postProcessBeforeInitialization...cat==>com.cuzz.bean.Cat@1d3b207
cat...init...
--->postProcessAfterInitialization...cat==>com.cuzz.bean.Cat@1d3b207
容器创建完成...
--->开始关闭容器
cat...destroy...
--->已经关闭容器

1
2
3
4
5
6

try {populateBean(beanName, mbd, instanceWrapper);if (exposedObject != null) {exposedObject = initializeBean(beanName, exposedObject, mbd);}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {Object wrappedBean = bean;if (mbd == null || !mbd.isSynthetic()) {// 执行before方法wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);}...try {// 执行初始化invokeInitMethods(beanName, wrappedBean, mbd);}if (mbd == null || !mbd.isSynthetic()) {// 执行after方法wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);}return wrappedBean;
}