![\"\"](\"http:\/\/springframework.guru\/wp-content\/uploads\/2019\/08\/lifecycle.png\")
<\/a><\/p>\nPart 1:<\/strong> Shows the different stages a bean goes through after instantiation until it is ready for use. As you can see in Part 1 of the preceding figure, the container instantiates a bean by calling its constructor and then populates its properties.<\/p>\n This is followed by several calls to the bean until the bean is in the ready state.<\/p>\n Similarly, as shown in Part 2, when the container shuts down, the container calls the bean to enable it to perform any required tasks before the bean is destroyed.<\/p>\n Spring provides several aware interfaces. These are used to access the Spring Framework infrastructure. The aware interfaces are largely used within the framework and rarely used by Spring programmers.<\/p>\n You as Spring programmers should be familiar with the following three aware interfaces.<\/p>\n The code to use the preceding aware interfaces is this.<\/p>\n The preceding bean implements the Line 13 – Line 18<\/strong>: The code overrides the Next, we will write the bean configuration to define the Finally, let us write the main class which will load the The output on running the main class is this:<\/p>\n Spring provides the The Let us start by creating a bean, named Next, we will create the The code for The preceding code implements the Spring calls the Spring calls the At runtime, Spring will inject the new bean instance and the name of the bean to both the methods.<\/p>\n Next, we will define The configuration code is this.<\/p>\n The main class to test our The output on running the main class is this.<\/p>\n Spring provides the following two callback interfaces:<\/p>\n Let’s write a bean that implements the The code of the The preceding Book bean implements the Next, we will write the bean configuration to define the The code of the The main class is this.<\/p>\n The preceding code retrieves the Book bean from the The output on running the main class is this.<\/p>\n As you can note in the output the While declaring bean in XML configuration, you can specify the The method declared in the Spring calls the method declared in the Let\u2019s use the custom init and destroy methods in a bean, named The code for In the preceding code, Next, we\u2019ll write the bean configuration, In the preceding code, Line 11 – Line 12 uses the The code of the main class is this.<\/p>\n The preceding code loads the XML configuration and tests the The output on running the preceding code is this.<\/p>\n All Spring beans go through a specific life cycle, and as we have seen, there’s I personally don’t prefer using the The Spring IoC (Inversion of Control) container manages Spring beans. A “Spring bean” is just a Spring managed instantiation of a Java class. The Spring IoC container is responsible for instantiating, initializing, and wiring beans. The container also manages the life cycle of beans. Spring provides several ways through which you can tap into the […]Continue reading<\/a><\/p>\n","protected":false},"author":111,"featured_media":4588,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_lmt_disableupdate":"","_lmt_disable":"","_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false},"version":2}},"categories":[21,6,182,1],"tags":[245,246],"class_list":["post-5812","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-spring","category-spring-core","category-spring-framework-5","category-uncategorized","tag-bean-lifecycle","tag-spring-bean-lifecycle"],"jetpack_publicize_connections":[],"aioseo_notices":[],"modified_by":"Simanta","jetpack_sharing_enabled":true,"jetpack_featured_media_url":"https:\/\/springframework.guru\/wp-content\/uploads\/2015\/03\/Banner560x292_05aweb.jpg","jetpack_shortlink":"https:\/\/wp.me\/p5BZrZ-1vK","_links":{"self":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/5812"}],"collection":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/users\/111"}],"replies":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/comments?post=5812"}],"version-history":[{"count":10,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/5812\/revisions"}],"predecessor-version":[{"id":6348,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/5812\/revisions\/6348"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/media\/4588"}],"wp:attachment":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/media?parent=5812"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/categories?post=5812"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/tags?post=5812"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
\nPart 2:<\/strong> Shows what happens to a bean once the Spring IoC container shuts down.<\/p>\nAware interfaces<\/h2>\n
\n
BeanFactoryAware<\/code>: Provides setBeanFactory()<\/code>, a callback that supplies the owning factory to the bean instance.<\/li>\nBeanNameAware<\/code>: ThesetBeanName()<\/code> callback of this interface supplies the name of the bean.<\/li>\nApplicationContextAware<\/code>: ThesetApplicationContext()<\/code> method of this interface provides the ApplicationContext<\/code> object of this bean.<\/li>\n<\/ul>\npackage guru.springframework.springbeanlifecycle.awareinterfaces.domain;\r\n\r\nimport org.springframework.beans.BeansException;\r\nimport org.springframework.beans.factory.BeanFactory;\r\nimport org.springframework.beans.factory.BeanFactoryAware;\r\nimport org.springframework.beans.factory.BeanNameAware;\r\nimport org.springframework.context.ApplicationContext;\r\nimport org.springframework.context.ApplicationContextAware;\r\n\r\nimport java.util.Arrays;\r\n\r\npublic class AwareBeanImpl implements ApplicationContextAware, BeanNameAware, BeanFactoryAware {\r\n@Override\r\npublic void setBeanFactory(BeanFactory beanFactory) throws BeansException {\r\nSystem.out.println(\"setBeanFactory method of AwareBeanImpl is called\");\r\nSystem.out.println(\"setBeanFactory:: AwareBeanImpl singleton= \"\r\n+ beanFactory.isSingleton(\"awareBean\"));\r\n}\r\n\r\n@Override\r\npublic void setBeanName(String beanName) {\r\nSystem.out.println(\"setBeanName method of AwareBeanImpl is called\");\r\nSystem.out.println(\"setBeanName:: Bean Name defined in context= \"\r\n+ beanName);\r\n}\r\n\r\n@Override\r\npublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {\r\nSystem.out.println(\"setApplicationContext method of AwareBeanImpl is called\");\r\nSystem.out.println(\"setApplicationContext:: Bean Definition Names= \"\r\n+ Arrays.toString(applicationContext.getBeanDefinitionNames()));\r\n}\r\n}\r\n<\/pre>\nApplicationContextAware<\/code>, BeanNameAware<\/code> and BeanFactoryAware<\/code> interfaces. In the preceding code:<\/p>\nsetBeanFactory()<\/code> method of the BeanFactoryAware<\/code> interface. During runtime, Spring passes the BeanFactory<\/code> object that created the bean. The code uses the BeanFactory<\/code> object to print whether or not this bean is a singleton.
\nLine 20 – Line 25<\/strong> overrides the setBeanName()<\/code> method of the BeanNameAware<\/code> interface. During runtime, Spring passes the name of the bean as a String that the code prints out. The code uses the beanName<\/code> to print the bean name defined in context.
\nIn Line 27 – Line 32<\/strong>, the code overrides the setApplicationContext()<\/code> method of the ApplicationContextAware<\/code> interface. During runtime, Spring passes the ApplicationContext<\/code> object that created the bean. The code uses the ApplicationContext<\/code> object to print the bean definition names.<\/p>\nAwareBeanImpl<\/code>.
\nThe code of the beans.xml<\/code> is this.<\/p>\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n\r\n<beans xmlns=\"http:\/\/www.springframework.org\/schema\/beans\"\r\n xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\r\n xsi:schemaLocation=\"http:\/\/www.springframework.org\/schema\/beans\r\n http:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd\">\r\n\r\n <!-- awareinterfaces-->\r\n <bean id=\"awareBean\" class=\"guru.springframework.springbeanlifecycle.awareinterfaces.domain.AwareBeanImpl\">\r\n <\/bean>\r\n\r\n<\/beans>\r\n<\/pre>\n
beans.xml<\/code> and test the aware interface methods.<\/p>\npackage guru.springframework.springbeanlifecycle;\r\n\r\nimport guru.springframework.springbeanlifecycle.awareinterfaces.domain.AwareBeanImpl;\r\nimport org.springframework.boot.SpringApplication;\r\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\r\nimport org.springframework.context.ApplicationContext;\r\nimport org.springframework.context.support.AbstractApplicationContext;\r\nimport org.springframework.context.support.ClassPathXmlApplicationContext;\r\n\r\n@SpringBootApplication\r\npublic class SpringBeanLifecycleApplication {\r\n\r\npublic static void main(String[] args) {\r\n\r\nSpringApplication.run(SpringBeanLifecycleApplication.class, args);\r\n\r\n\/\/ -------awareinterfaces---------\r\nApplicationContext context1 =\r\nnew ClassPathXmlApplicationContext(\"beans.xml\");\r\nAwareBeanImpl awareBeanImpl = (AwareBeanImpl) context1.getBean(\"awareBean\");\r\n((AbstractApplicationContext) context1).registerShutdownHook();\r\n\r\n}\r\n\r\n}\r\n<\/pre>\n \r\nsetBeanName method of AwareBeanImpl is called\r\nsetBeanName:: Bean Name defined in context= awareBean\r\nsetBeanFactory method of AwareBeanImpl is called\r\nsetBeanFactory:: AwareBeanImpl singleton= true\r\nsetApplicationContext method of AwareBeanImpl is called\r\nsetApplicationContext:: Bean Definition Names= [awareBean]\r\n<\/pre>\n
Bean Post Processor<\/h2>\n
BeanPostProcessor<\/code> interface that gives you the means to tap into the Spring context life cycle and interact with beans as they are processed.<\/p>\nBeanPostProcessor<\/code> interface contains two methods.<\/p>\n\n
postProcessBeforeInitialization<\/code>: Spring calls this method after calling the methods of the aware interfaces and before any bean initialization callbacks, such as InitializingBean’s afterPropertiesSet<\/code> or a custom init-method.<\/li>\npostProcessAfterInitialization<\/code>: Spring calls this method after any bean initialization callbacks.<\/li>\n<\/ul>\nBookBean<\/code>.<\/p>\npackage guru.springframework.springbeanlifecycle.beanpostprocessor.domain;\r\n\r\npublic class BookBean {\r\nprivate String bookName;\r\n\r\npublic BookBean() {\r\nSystem.out.println(\"Constructor of BookBean called !! \");\r\n\r\n}\r\n\r\npublic BookBean(String bookName) {\r\nthis.bookName = bookName;\r\n}\r\n\r\npublic String getBookName() {\r\nreturn bookName;\r\n}\r\n\r\npublic void setBookName(String bookName) {\r\nthis.bookName = bookName;\r\n}\r\n\r\n@Override\r\npublic String toString() {\r\nreturn \"BookBean{\" +\r\n\"bookName='\" + bookName + '\\'' +\r\n'}';\r\n}\r\n}\r\n<\/pre>\nBookBeanPostProcessor<\/code>.<\/p>\nBookBeanPostProcessor<\/code> is this.<\/p>\npackage guru.springframework.springbeanlifecycle.beanpostprocessor.domain;\r\n\r\nimport guru.springframework.springbeanlifecycle.beanpostprocessor.domain.BookBean;\r\nimport org.springframework.beans.BeansException;\r\nimport org.springframework.beans.factory.config.BeanPostProcessor;\r\n\r\npublic class BookBeanPostProcessor implements BeanPostProcessor {\r\n\r\n@Override\r\npublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {\r\nSystem.out.println(\"Post Process Before Initialization method is called : Bean Name \" + beanName);\r\nreturn bean; }\r\n\r\n@Override\r\npublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {\r\nSystem.out.println(\"Post Process After Initialization method is called : Bean Name \" + beanName);\r\n\r\nreturn bean;\r\n}\r\n}\r\n<\/pre>\nBeanPostProcessor<\/code> interface and overrides the postProcessBeforeInitialization()<\/code> and postProcessAfterInitialization()<\/code> methods.<\/p>\npostProcessBeforeInitialization()<\/code> method after calling the methods of the aware interfaces.<\/p>\npostProcessAfterInitialization()<\/code> method after any bean initialization callbacks, such as InitializingBean’s afterPropertiesSet<\/code> or a custom init-method. We will discuss both going ahead.<\/p>\nBookBean<\/code> and BookBeanProcessor<\/code> as beans in the XML configuration.<\/p>\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n\r\n<beans xmlns=\"http:\/\/www.springframework.org\/schema\/beans\"\r\n xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\r\n xsi:schemaLocation=\"http:\/\/www.springframework.org\/schema\/beans\r\n http:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd\">\r\n\r\n <bean id=\"bookBeanPost\" class=\"guru.springframework.springbeanlifecycle.beanpostprocessor.domain.BookBean\">\r\n <property name=\"bookName\" value=\"Gone with the Wind\"><\/property>\r\n <\/bean>\r\n <bean id=\"bookBeanPostProcessor\"\r\n class=\"guru.springframework.springbeanlifecycle.beanpostprocessor.domain.BookBeanPostProcessor\"\/>\r\n<\/beans>\r\n<\/pre>\n
BeanPostProcessor<\/code> is this.<\/p>\npackage guru.springframework.springbeanlifecycle;\r\n\r\nimport guru.springframework.springbeanlifecycle.beanpostprocessor.domain.BookBean;\r\nimport org.springframework.boot.SpringApplication;\r\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\r\nimport org.springframework.context.ApplicationContext;\r\nimport org.springframework.context.support.AbstractApplicationContext;\r\nimport org.springframework.context.support.ClassPathXmlApplicationContext;\r\n\r\n@SpringBootApplication\r\npublic class SpringBeanLifecycleApplication {\r\n\r\npublic static void main(String[] args) {\r\n\r\nSpringApplication.run(SpringBeanLifecycleApplication.class, args);\r\n\/\/ -------beanpostprocessor------\r\nApplicationContext context4 =\r\nnew ClassPathXmlApplicationContext(\"beans.xml\");\r\nBookBean bookBean = (BookBean) context4.getBean(\"bookBeanPost\");\r\n((AbstractApplicationContext) context4).registerShutdownHook();\r\n}\r\n}\r\n<\/pre>\n \r\nConstructor of BookBean called !!\r\nPost Process After Initialization method is called: Bean Name bookBeanPost\r\nPost Process Before Initialization method is called: Bean Name bookBeanPost\r\n<\/pre>\n
InitializingBean and DisposableBean Callback Interfaces<\/h2>\n
\n
InitializingBean<\/code>: Declares the afterPropertiesSet()<\/code> method which can be used to write the initialization logic. The container calls the method after properties are set.<\/li>\nDisposableBean<\/code>: Declares the destroy()<\/code> method which can be used to write any cleanup code. The container calls this method during bean destruction in shutdown.<\/li>\n<\/ul>\nInitalizingBean<\/code> and DisposableBean<\/code> interfaces.<\/p>\nBook<\/code> bean is this.<\/p>\npackage guru.springframework.springbeanlifecycle.callbackinterfaces.domain;\r\nimport org.springframework.beans.factory.DisposableBean;\r\nimport org.springframework.beans.factory.InitializingBean;\r\npublic class Book implements InitializingBean, DisposableBean {\r\nprivate String bookName;\r\npublic Book() {\r\nSystem.out.println(\"Constructor of Book bean is called !! \");\r\n}\r\n\r\n@Override\r\npublic void destroy() throws Exception {\r\nSystem.out.println(\"Destroy method of Book bean called !! \");\r\n}\r\n@Override\r\npublic void afterPropertiesSet() throws Exception {\r\nSystem.out.println(\"afterPropertiesSet method of Book bean is called !! \");\r\n}\r\npublic Book(String bookName) {\r\nthis.bookName = bookName;\r\n}\r\npublic String getBookName() {\r\nreturn bookName;\r\n}\r\npublic void setBookName(String bookName) {\r\nthis.bookName = bookName;\r\n}\r\n@Override\r\npublic String toString() {\r\nreturn \"Book{\" +\r\n\"bookName='\" + bookName + '\\'' +\r\n'}';\r\n}\r\n}\r\n<\/pre>\nInitializingBean<\/code> and DisposableBean<\/code> interfaces and overrides their afterPropertiesSet()<\/code> and destroy()<\/code> method.<\/p>\nBook<\/code> bean.<\/p>\nbeans.xml<\/code> file is this.<\/p>\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n\r\n<beans xmlns=\"http:\/\/www.springframework.org\/schema\/beans\"\r\n xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\r\n xsi:schemaLocation=\"http:\/\/www.springframework.org\/schema\/beans\r\n http:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd\">\r\n\r\n <!-- callbackinterfaces-->\r\n <bean id=\"bookBean\" class=\"guru.springframework.springbeanlifecycle.callbackinterfaces.domain.Book\">\r\n <property name=\"bookName\" value=\"Believe in Yourself\"\/>\r\n <\/bean>\r\n<\/beans>\r\n<\/pre>\n
package guru.springframework.springbeanlifecycle;\r\n\r\nimport guru.springframework.springbeanlifecycle.callbackinterfaces.domain.Book;\r\nimport org.springframework.boot.SpringApplication;\r\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\r\nimport org.springframework.context.ApplicationContext;\r\nimport org.springframework.context.support.AbstractApplicationContext;\r\nimport org.springframework.context.support.ClassPathXmlApplicationContext;\r\n\r\n@SpringBootApplication\r\npublic class SpringBeanLifecycleApplication {\r\n\r\npublic static void main(String[] args) {\r\n\r\nSpringApplication.run(SpringBeanLifecycleApplication.class, args);\r\n\r\n\/\/ -------callbackinterfaces-------\r\nApplicationContext context =\r\nnew ClassPathXmlApplicationContext(\"beans.xml\");\r\nBook book = (Book) context.getBean(\"bookBean\");\r\nSystem.out.println(book.getBookName());\r\n((AbstractApplicationContext) context).registerShutdownHook();\r\n\r\n}\r\n\r\n}\r\n<\/pre>\nApplicationContext<\/code> and prints out the value of the bookName<\/code> property.<\/p>\n \r\nConstructor of Book bean is called !!\r\nafterPropertiesSet method of Book bean is called !!\r\nBelieve in Yourself\r\ndestroy method of Book bean is called !!\r\n<\/pre>\n
afterPropertiesSet()<\/code> method got called first.<\/p>\nCustom Init and Destroy Method<\/h2>\n
init-method<\/code> and destroy-method<\/code> attributes in the <\/code> tag. Both the attributes specify custom methods in the bean class.<\/p>\ninit-method<\/code> attribute is called after Spring initializes bean properties through setter or constructor arguments. You can use this method to validate the injected properties or perform any other tasks.<\/p>\ndestroy-method<\/code> attribute just before the bean is destroyed.<\/p>\nBookCustomBean<\/code>.<\/p>\nBookCustomBean<\/code>; is this.<\/p>\npackage guru.springframework.springbeanlifecycle.custominitanddestroy.domain;\r\n\r\npublic class BookCustomBean {\r\nprivate String bookName;\r\n\r\npublic BookCustomBean() {\r\nSystem.out.println(\"Constructor of BookCustomBean bean is called !! \");\r\n}\r\n\r\npublic void customDestroy() throws Exception {\r\n\r\nSystem.out.println(\"Custom destroy method of BookCustomBean called !! \");\r\n}\r\n\r\npublic void customInit() throws Exception {\r\nSystem.out.println(\"Custom Init method of BookCustomBean called !! \");\r\n}\r\n\r\npublic BookCustomBean(String bookName) {\r\nthis.bookName = bookName;\r\n}\r\n\r\npublic String getBookName() {\r\nreturn bookName;\r\n}\r\n\r\npublic void setBookName(String bookName) {\r\nthis.bookName = bookName;\r\n}\r\n\r\n@Override\r\npublic String toString() {\r\nreturn \"Book{\" +\r\n\"bookName='\" + bookName + '\\'' +\r\n'}';\r\n}\r\n\r\n}\r\n<\/pre>\ncustomInit<\/code> and customDestroy<\/code> are regular methods that prints output messages.<\/p>\nbeans.xml<\/code>.<\/p>\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n\r\n<beans xmlns=\"http:\/\/www.springframework.org\/schema\/beans\"\r\n xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\r\n xsi:schemaLocation=\"http:\/\/www.springframework.org\/schema\/beans\r\n http:\/\/www.springframework.org\/schema\/beans\/spring-beans-3.0.xsd\">\r\n\r\n <!-- Declare custom init and destroy methods-->\r\n <bean id=\"customLifeCycleBookBean\"\r\n class=\"guru.springframework.springbeanlifecycle.custominitanddestroy.domain.BookCustomBean\"\r\n init-method=\"customInit\"\r\n destroy-method=\"customDestroy\">\r\n <property name=\"bookName\" value=\"Life and Laughing\"><\/property>\r\n <\/bean>\r\n\r\n<\/beans><\/pre>\n
init-method<\/code> and destroy-method<\/code> attributes with the values, customInit<\/code> and customDestroy<\/code>.<\/p>\npackage guru.springframework.springbeanlifecycle;\r\n\r\nimport guru.springframework.springbeanlifecycle.custominitanddestroy.domain.BookCustomBean;\r\nimport org.springframework.boot.SpringApplication;\r\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\r\nimport org.springframework.context.ApplicationContext;\r\nimport org.springframework.context.support.AbstractApplicationContext;\r\nimport org.springframework.context.support.ClassPathXmlApplicationContext;\r\n\r\n@SpringBootApplication\r\npublic class SpringBeanLifecycleApplication {\r\n\r\npublic static void main(String[] args) {\r\n\r\nSpringApplication.run(SpringBeanLifecycleApplication.class, args);\r\n\/\/ -------custominitanddestroy------\r\nApplicationContext context3 =\r\nnew ClassPathXmlApplicationContext(\"beans.xml\");\r\n\r\nBookCustomBean bookCustomBean = (BookCustomBean) context3.getBean(\"customLifeCycleBookBean\");\r\n((AbstractApplicationContext) context3).registerShutdownHook();\r\n}\r\n}\r\n<\/pre>\ninit-method<\/code> and destroy-method<\/code>.<\/p>\n \r\nConstructor of BookCustomBean bean is called !!\r\nCustom Init method of BookCustomBean called !!\r\nCustom destroy method of BookCustomBean called !!\r\n<\/pre>\n
Summary<\/h2>\n
\nactually, a lot goes on under the hood. Most of this is handled by the framework and as a Spring developer, you will seldom require to get into it that often. However, as you get into more and more complex applications with the Spring framework, at times you have to be aware of what goes on during a bean lifecycle.<\/p>\nInitializingBean<\/code> and DisposableBean<\/code> interfaces. Primarily because it tight couples your code to Spring. A better approach is specifying the init-method and destroy-method attributes in your bean configuration file.
\nThe source code for this post can be found here on GitHub<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"