bean生命周期的四个阶段（bean的生命周期可以引用的接口）

Bean的生命周期可以简单分为11个周期：

1.构造方法。不管是反射获取和静态工厂获取都会调用Bean嵌套类的构造方法。

2.封装属性。封装Bean嵌套类的属性，值可以在对应xml文件的<Bean>标签内用<property>设置

3.实现BeanNameAware接口，实现setBeanName()方法。该方法是用来设置Bean的name，传来的值为xml里该Bean的Id值

4.实现BeanfactoryAware接口，实现setBeanFactory()方法。不设置的话有默认DefaultListableBeanFactory类。

5.重点。在Xml文件里配置实现BeanPostProcessor的类，实现接口的postProcessBeforeInitialization()方法,是预处理方法。比如权限的访问可以在这个方法中进行设置

6.实现InitializingBean接口，实现afterPropertiesSet()方法

7.调用自定义Bean初始化函数，初始化的方法需要在对应的类里面配，而且要写到xml文件里的init-method属性中

8.重点。在Xml文件里配置实现BeanPostProcessor的类，实现postProcessAfterInitialization()方法，后处理方法。和第七步在同一类下。

9.调用业务方法，调用获取到对象的方法即可。

10.实现DisposableBean接口，实现destroy()方法，父容器关闭时会调用。

11.实现自定义destory()方法，关闭时调用。

Xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="MyStudentStaticService" class="com.baidu.student.MyStudentStaticService" init-method="initMy" destroy-method="desMy" factory-method="getStudentService">
<property name="name" value="aa"></property>
</bean>
<bean class="com.baidu.student.MyBeanProcess"></bean>
</beans>

Bean嵌套的对象：

package com.baidu.student;
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.beans.factory.InitializingBean;
public class StudentService implements BeanNameAware,BeanFactoryAware,InitializingBean,DisposableBean{
private String name;
public String getName() {
return name;
}
//--------------bean的11个声明周期----------------
public StudentService(String a) {
System.out.println("1.调用Bean对应的类构造方法");
}
public void setName(String name) {
this.name = name;
System.out.println("2.封装属性属性值在对应的Bean的xml文件里写---" name);
}
@Override
public void setBeanName(String name) {
//这个name==studentService
System.out.println("3.实现BeanNameAware接口，实现setBeanName()方法---" name);
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
//
System.out.println("4.实现BeanFactoryAware接口，实现setBeanFactory()方法----Factory为" beanFactory.getClass());
}
//第五步在BeanProcess实现类里
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("6.实现InitializingBean接口，实现afterPropertiesSet()方法");
}
public void initMy() {
System.out.println("7.调用自定义Bean初始化函数，初始化的方法需要在对应的类里面配，而且要写到xml文件里");
}
//第八步在BeanProcess实现类里
public void say() {
System.out.println("9.调用业务方法，使用获取到的类的方法");
}
@Override
public void destroy() throws Exception {
System.out.println("10.实现DisposableBean接口，实现destroy()方法");
}
public void desMy() {
System.out.println("11.实现自定义destory()方法，关闭时调用");
}
}

继承Bean类：

package com.baidu.student;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanProcess implements BeanPostProcessor{
//该类需要在xml文件中配置
@Override
public Object postProcessAfterInitialization(Object bean, String name) throws BeansException {
System.out.println("8.重点。在Xml文件里配置实现BeanPostProcessor的类，实现postProcessAfterInitialization()方法，后处理方法");
return bean;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String name) throws BeansException {
System.out.println(name);
System.out.println("5.重点。在Xml文件里配置实现BeanPostProcessor的类，实现接口的postProcessBeforeInitialization()方法,预处理方法");
return bean;
}
}

测试方法：

public class Test2 {
@Test
public void test() {
ClassPathXmlapplicationContext applicationContext=new ClassPathXmlApplicationContext("beans2.xml");
StudentService studentService = (StudentService) applicationContext.getBean("MyStudentStaticService");
studentService.say();
System.out.println(studentService.getName());
applicationContext.close();
}
}

结果：

bean生命周期的四个阶段,bean的生命周期可以引用的接口(1)