spring中Bean对象的生命周期

经过测试对于具体的一个Bean，执行的流程应该是：

1.实例化：

　　常见的有构造（有参、无参）实例化、静态工厂（方法是静态，通过类名.方法返回获取）、实例工厂（专门有个类负责生产对象，需要在bean中配置类和方法名~非静态）

2.注入

　　注入有3种（set注入、构造注入、接口注入），如果有注入，则实例化注入对象，注入对象优先完成以下步骤，再注入，再完成bean类的以下步骤。没有注入直接完成下面步骤。

3.传id至方法

　　如果当前bean类有实现BeanNameAware接口，并重写setBeanName()方法，先执行此方法。

4.传BeanFactory工厂至方法

　　如果当前bean类实现BeanFactoryAware接口，并重写setBeanFactroy()方法，再执行此方法。

5.传ApplicationContext容器至方法

　　如果当前bean类实现AapplicationContextAware接口，并重写setApplicationContext()方法，再执行此方法。

6.BeanPostProcessor处理器进行前后预处理

　　另外如果存在bean类实现BeanPostProcessor接口，并重写postProcessBeforeInitialization和postProcessAfterInitialization方法。程序会先执行Before（同左）方法再执行init()方法，最后执行After（同左）方法。注意：每个对象实例化过程都会调用此方法。可以用传递的对象对对象内容进行更改。好东西啊。

7.使用代理管理事物（目标方法前打开事物，目标方法后关闭事物）

　　在postProcessAfterInitialization方法的返回中使用代理返回。代码如下：

@Override
	public Object postProcessAfterInitialization(final Object bean, String beanName)
			throws BeansException {
		System.out.println("后"+beanName);
		return Proxy.newProxyInstance(MyBeanProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				System.out.println("-----开启事物-------");
				//执行模板方法
				Object obj = method.invoke(bean, args);
				System.out.println("--------提交事物--------");
				return obj;
			}
		});
	}

8.destroy()方法

 　　此方法可以在bean中进行声明，也可以通过bean类实现DisposableBean接口，重写destroy方法()，执行销毁bean。

 小结：程序运行结果：

实现代码：

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans 
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation=
	"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd 
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd
	http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

<!-- 此类实现BeanPostProcessor接口 -->
<bean class="com.xx.service.MyBeanProcessor"/>

<!-- service -->
<bean id="userService" class="com.xx.service.UserServiceImpl" init-method="init" destroy-method="destroy" scope="singleton">
<property name="userDao" ref="userDao"/>
</bean>

<!-- dao -->
<bean id="userDao" class="com.xx.dao.UserDaoImpl"/>
</beans>

 

service层接口：

package com.xx.service;

public interface UserService {
	public void run();
}

Service层实现类：

package com.xx.service;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import com.xx.dao.UserDao;
/**
 * userService层实现类
 * @author phoebe
 *
 */
public class UserServiceImpl implements UserService,BeanNameAware,BeanFactoryAware,ApplicationContextAware,DisposableBean{

	private UserDao userDao;
	public void setUserDao(UserDao userDao) {
		System.out.println("注入dao");
		this.userDao = userDao;
	}
	public UserServiceImpl() {
		System.out.println("实例化Service");
	}
	//目标方法
	public void run(){
		System.out.println("userService is running");
	}
	//测试方法
	public void testBeanFactoryAware(){
		System.out.println("证明bean对象被传送过来了");
	}
	
	//初始方法
	public void init(){
		System.out.println("this is init method");
	}
	//销毁方法
	public void destroy(){
		System.out.println("this is destroy method");
	}

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

	@Override
	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
		System.out.println("BeanFactoryAware:"+beanFactory.containsBean("userService"));
	}
	@Override
	public void setApplicationContext(ApplicationContext applicationContext)
			throws BeansException {
		System.out.println("ApplicationContextAware:"+applicationContext.containsBean("userService"));;
	}
}

Dao层接口：

package com.xx.dao;

public interface UserDao {

	//测试方法
	public void testDao();
}

 Dao层实现类：

package com.xx.dao;

public class UserDaoImpl implements UserDao{

	public UserDaoImpl() {
		System.out.println("实例化Dao");
	}
	@Override
	public void testDao() 
	{
		System.out.println("Dao is running");
	}
}

处理器进行前后预处理

package com.xx.service;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;



import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * 处理器进行前后预处理
 * @author phoebe
 *
 */
public class MyBeanProcessor implements BeanPostProcessor {

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		System.out.println("init前:"+beanName);
		return bean;
	}

	@Override
	public Object postProcessAfterInitialization(final Object bean, String beanName)
			throws BeansException {
		System.out.println("init后"+beanName);
		return Proxy.newProxyInstance(MyBeanProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler() {
			
			@Override
			public Object invoke(Object proxy, Method method, Object[] args)
					throws Throwable {
				System.out.println("-----目标方法前：开启事物-------");
				//执行模板方法
				Object obj = method.invoke(bean, args);
				System.out.println("--------目标方法后：提交事物--------");
				return obj;
			}
		});
	}

}

测试：

package com.xx.test;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.xx.service.UserService;
/**
 * spring生命周期测试
 * @author phoebe
 *
 */
public class UserServiceTest {
	
	private ApplicationContext context = null;
	
	@Before
	public void before(){
		String beanPath="classpath:applicationContext.xml";
		context = new ClassPathXmlApplicationContext(beanPath);
	}
	@Test
	public void TestApp() throws Exception {
		
		UserService userService = context.getBean("userService",UserService.class);
		userService.run();
		context.getClass().getMethod("close").invoke(context);
		
	}
	
	
}