spring中Bean对象的生命周期

2023-03-06 16:48:55

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

1.实例化：

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

2.注入

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

3.传id至方法

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

4.传BeanFactory工厂至方法

　　如果当前bean类实现BeanFactroyAware接口，并重写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);

	}

}

码农公寓