Spring bean生命周期详解

上下文ApplicationContext容器中的生命周期:

bean: java

package com.pas.service;
//引包
public class PersonService implements BeanNameAware, BeanFactoryAware,
		ApplicationContextAware, InitializingBean, DisposableBean {

	private String name;

	public PersonService() {
		System.out.println("Person" + this.hashCode() + "实例化!");
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
		System.out.println("set方法被调用");
	}

	public void sayHi() {
		System.out.println("hi:" + this.name);
	}
        //自定义的初始化函数
	public void myinit() {
		System.out.println("myinit被调用");
	}

	@Override
	public void setBeanName(String name) {
		System.out.println("setBeanName被调用:" + name);
	}

	/*
	 * 传递bean工厂
	 */
	@Override
	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
		System.out.println("setBeanFactory被调用");
	}

	@Override
	public void setApplicationContext(ApplicationContext applicationContext)
			throws BeansException {
		System.out.println("setApplicationContext被调用");
	}

	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("afterPropertiesSet被调用");
	}
        //自定义的销毁方法,配置见配置文件节
	public void mydes() throws Exception {
		System.out.println("mydes被调用,释放各类资源");
	}

	@Override
	public void destroy() throws Exception {
		System.out.println("destroy被调用,释放各类资源");
	}
}
测试函数:
package com.pas.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.pas.service.PersonService;

public class Test {
	public static void main(String[] args) {
		/*
		 * 上下文ApplicationContext中的生命周期:(此处为单例scope)
		 * 一、实例化(默认使用无参数的构造函数)
		 * 	    能够重载一个无参数的构造方法
		 *    若是须要使用有参的构造函数实例化,须要指定factory-method等参数
		 * 二、设置属性(注入属性)
		 * 		调用set方法设置属性
		 * 三、若是实现bean名字关注BeanNameAware,调用BeanNameAware的setBeanName方法
		 * 四、若是实现bean工厂关注BeanFactoryAware,调用其setBeanFactory可获得factory
		 * 五、若是你实现了 ApplicationContextAware接口,则调用方法 setApplicationContext
		 * 		该方法传递ApplicationContext
		 * 六、若是bean 和 一个后置处理器关联,则会自动去调用 
		 * 		postProcessBeforeInitialization方法
		 * 		(面向全部对象编程,切面编程)
		 * 七、若是实现InitializingBean接口,则调用afterPropertiesSet
		 * 八、若是配置了自定义的初始化方法,(init-method="myinit")则执行其与7以后,postProcessAfterInitialization方法
		 * 九、若是bean 和 一个后置处理器关联,
		 * 		则会自动去调用 postProcessAfterInitialization方法
		 * 十、使用咱们的bean
		 * 十一、容器关闭
		 * 十二、能够经过实现DisposableBean 接口来调用方法 destory
		 * 1三、能够在<bean destory-method="mydes"/> 调用定制的销毁方法
		 * 
		 * 		实际开发中常见为:1->2->6->10->9->11 
		 * 		实例化->set方法->后置处理器before->使用->后置处理器before->容器关闭
		 */
		ApplicationContext ac = new ClassPathXmlApplicationContext(
				"applicationContext.xml");
		
		out("xml加载完毕");
		try {
			PersonService ps=(PersonService) ac.getBean("personService2");
			ps.sayHi();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public static void out(Object s)
	{
		System.out.println(s);
	}
}

配置文件applicationContext.xml: spring

<!-- scope="prototype"为原型模式,每次获取都建立新对象 -->
	<bean id="personService" destroy-method="mydes" 
            init-method="myinit" class="com.pas.service.PersonService">
		<property name="name">
			<value>pingansheng</value>
		</property>
	</bean>
	<bean id="personService2" scope="prototype" 
                class="com.pas.service.PersonService">
		<property name="name">
			<value>小红</value>
		</property>
	</bean>
	<!-- 配置自定义的后置处理器 -->
	<bean id="postProcessor" class="com.pas.service.MyBeanPostProcessor" />

后置处理器MyBeanPostProcessor: shell

package com.pas.service;
//import
public class MyBeanPostProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		System.out.println("以前作些事");
		System.out.println("postProcessBeforeInitialization被调用");
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName)
			throws BeansException {
		System.out.println("以后作些事");
		System.out.println("postProcessAfterInitialization被调用");
		return bean;
	}

}
测试输出:
bean工厂加载完毕
Person1640499969实例化!
set方法被调用
setBeanName被调用:personService
setBeanFactory被调用
afterPropertiesSet被调用
myinit被调用
hi:pingansheng
图示:


Bean工厂容器bean的生命周期: 编程

大部分代码相同,测试代码稍有差异: app

package com.pas.test;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;

import com.pas.service.PersonService;

public class Test {
	public static void main(String[] args) {
		/*
		 * bean工厂中bean的生命周期:
		 * 一、实例化(默认使用无参数的构造函数)
		 * 	    能够重载一个无参数的构造方法
		 *    若是须要使用有参的构造函数实例化,须要指定factory-method等参数
		 * 二、设置属性(注入属性)
		 * 		调用set方法设置属性
		 * 三、若是实现bean名字关注BeanNameAware,调用BeanNameAware的setBeanName方法
		 * 四、若是实现bean工厂关注BeanFactoryAware,调用其setBeanFactory可获得factory
		 * 五、若是实现InitializingBean接口,则调用afterPropertiesSet
		 * 六、若是配置了自定义的初始化方法,(init-method="myinit")则执行其与7以后,postProcessAfterInitialization方法
		 * 七、使用咱们的bean
		 * 八、容器关闭
		 * 九、能够经过实现DisposableBean 接口来调用方法 destory
		 * 十、能够在<bean destory-method="mydes"/> 调用定制的销毁方法
		 */
		
		BeanFactory fc=new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
		out("bean工厂加载完毕");
		try {
			PersonService ps=(PersonService) fc.getBean("personService");
			ps.sayHi();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	
	public static void out(Object s)
	{
		System.out.println(s);
	}
}



控制台输出:
bean工厂加载完毕
Person371789756实例化!
set方法被调用
setBeanName被调用:personService
setBeanFactory被调用
afterPropertiesSet被调用
myinit被调用
hi:pingansheng



图示:
相关文章
相关标签/搜索