The spring container initializes the bean and takes action before destroying it

First: Actions before initializing and destroying beans by annotating @postconstruct and @PreDestroy methods

[Java]View Plain Copy

2. Import javax.annotation.PostConstruct;
4. Import Javax.annotation.PreDestroy;
8. Public class datainitializer{
10. @PostConstruct
12. public void Initmethod () throws Exception {
14. System.out.println ("Initmethod is executed");
16. }
18. @PreDestroy
20. public void Destroymethod () throws Exception {
22. System.out.println ("Destroymethod is executed");
24. }
26. }

The second is: by defining the Init-method and Destory-method methods in XML

[Java]View Plain Copy

2. Public class datainitializer{
4. public void Initmethod () throws Exception {
6. System.out.println ("Initmethod is executed");
8. }
10. public void Destroymethod () throws Exception {
12. System.out.println ("Destroymethod is executed");
14. }
16. }

[HTML]View Plain Copy

1. <Bean id="Datainitializer" class="Com.somnus.demo.DataInitializer" init-method=" Initmethod " destory-method="destroymethod "/>

The third is the implementation of the Initializingbean and Disposablebean interfaces via beans

[Java]View Plain Copy

2. Import Org.springframework.beans.factory.DisposableBean;
6. Public class Datainitializer implements initializingbean,disposablebean{
10. @Override
12. public void Afterpropertiesset () throws Exception {
14. System.out.println ("Afterpropertiesset is executed");
16. }
20. @Override
22. public Void Destroy () throws Exception {
24. System.out.println ("destroy is executed");
26. }
30. }

The first and the second are the same form, but one XML configuration, the other is the annotation form, there is a big difference is the third kind,

If a method is executed when the same bean is initialized in two ways, it is first shown in the order of execution.

Execute Afterpropertiesset () First,

Post-execution Initmethod ()

Here we look at the source code

How does this approach be implemented in spring?

By looking at the source Class (Abstractautowirecapablebeanfactory) of spring's load bean, you can see the secret

Abstractautowirecapablebeanfactory class in the Invokeinitmethods explained very clearly, the source code is as follows:

[Java]View Plain Copy

2. protected void Invokeinitmethods (String beanname, final Object Bean, rootbeandefinition mbd)
4. throws Throwable {
6. ///To determine if the bean implements the Initializingbean interface, and if the Initializingbean interface is implemented, only the Afterpropertiesset method of invoking the bean is dropped
8. Boolean Isinitializingbean = (bean instanceof Initializingbean);
10. if (Isinitializingbean && (mbd = = Null | |!mbd.isexternallymanagedinitmethod ("Afterpropertiesset" ))) {  
12. if (logger.isdebugenabled ()) {
14. Logger.debug ("invoking Afterpropertiesset () on beans with name '" + beanname + "'");
16. }
20. if (system.getsecuritymanager () = null) {
22. try {
24. Accesscontroller.doprivileged (new privilegedexceptionaction<object> () {
26. Public Object Run () throws Exception {
28. //Call Afterpropertiesset directly
30. ((Initializingbean) bean). Afterpropertiesset ();
32. return null;
34. }
36. },getaccesscontrolcontext ());
38. } catch (Privilegedactionexception PAE) {
40. throw pae.getexception ();
42. }
44. }
46. else {
48. //Call Afterpropertiesset directly
50. ((Initializingbean) bean). Afterpropertiesset ();
52. }
54. }
56. if (mbd! = null) {
58. String initmethodname = Mbd.getinitmethodname ();
60. //Determines whether the Init-method method is specified, and if the Init-method method is specified, then the established Init-method is called
62. if (initmethodname ! = NULL &&! ( Isinitializingbean && "Afterpropertiesset". Equals (initmethodname) &&
64. !mbd.isexternallymanagedinitmethod (Initmethodname)) {
66. ///To see the source of the method further, it can be found that the method specified in the Init-method method is implemented by reflection
68. Invokecustominitmethod (Beanname, Bean, mbd);
70. }
72. }

Summarize:

1:spring provides two ways for the bean to initialize the bean, implement the Initializingbean interface, implement the Afterpropertiesset method, or in the configuration file

Init-method , two different ways can be used simultaneously

2: Implementing the Initializingbean interface is a direct call to the Afterpropertiesset method, which is more efficient than the method specified by the reflection call Init-method. But

Init-method Way to eliminate the reliance on spring

3: If an error occurs when calling the Afterpropertiesset method, the method specified by Init-method is not called.

The spring container initializes the bean and takes action before destroying it