经过测试对于具体的一个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);
		
	}
	
	
}