总结：Spring中Bean的生命周期详解

spring中Bean的生命周期总结

  想了解spring中Bean的生命周期就必须要先知道spring是什么 ？
Spring是分层的JavaSE/EE应用full-stack轻量级开源框架。主要针对三层架构设计的。
full-stack（全栈）：
  Spring功能非常强大，能够服务于Java开发过程中的各个层面。
轻量级：
  资源消耗较低，运行速度较快。

Spring的体系结构：

• 应用层技术：数据访问与数据成、Web集成、Web实现
• 中间层技术：AOP、Aspects、Instrumentation、Messaging
• 底层核心容器（核心容器Ioc）：Beans、Core、Context、SqEL

  详情可见： http://c.biancheng.net/view/4242.html

下面我们来介绍Spring中Bean的生命周期：

  在spring中，从BeanFactory或ApplicationContext取得的实例为Singleton，也就是预设为每一个Bean的别名只能维持一个实例，而不是每次都产生一个新的对象使用Singleton模式产生单一实例，对单线程的程序说并不会有什么问题，但对于多线程的程序，就必须注意安全(Thread-safe)的议题，防止多个线程同时存取共享资源所引发的数据不同步问题。

  然而在spring中可以设定每次从BeanFactory或ApplicationContext指定别名并取得Bean时都产生一个新的实例：例如：

  在spring中，singleton属性默认是true，只有设定为false，则每次指定别名取得的Bean时都会产生一个新的实例。

  一个Bean从创建到销毁，如果是用BeanFactory来生成,管理Bean的话，会经历几个执行阶段：

案例分析：

  创建一个实体Bean代码如下：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

public class Student implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean {

    private String name;
    private String gender;
    private String age;

    public Student() {
        System.out.println("无参构造被调用了....");
    }

    public Student(String name, String gender, String age) {
        System.out.println("有参构造被调用了....");
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("name属性赋值....");
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        System.out.println("gender属性赋值....");
        this.gender = gender;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        System.out.println("age属性赋值....");
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age='" + age + '\'' +
                '}';
    }

    // 这是BeanFactoryAware接口方法
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("调用了BeanFactoryAware.setBeanFactory()方法...");
    }

    // 这是BeanNameAware接口方法
    @Override
    public void setBeanName(String name) {
        System.out.println("调用了BeanNameAware.setBeanName()方法...");
    }

    // 这是DiposibleBean接口方法
    @Override
    public void destroy() throws Exception {
        System.out.println("调用了DiposibleBean.destory()方法...");
    }

    // 这是InitializingBean接口方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("调用了InitializingBean.afterPropertiesSet()方法...");
    }
	//Student的Bean的初始化方法
	public void initStudent() {
		System.out.println("Student的Bean的初始化方法执行....");
	}
	
	//Student的Bean的销毁方法
	public void destroyStudent() {
		System.out.println("Student的Bean的销毁方法执行....");
	}
}

  创建实现BeanPostProcessor接口的实现类，如下：主要是postProcessBeforeInitialization()和postProcessAfterInitialization()方法。这两个方法的第一个参数都是要处理的Bean对象，第二个参数都是Bean的name。返回值也都是要处理的Bean对象。

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

public class BeanPostProcessorImpl implements BeanPostProcessor {
    public BeanPostProcessorImpl() {
        super();
    }

    @Override
    public int hashCode() {
        return super.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return super.toString();
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(beanName + "实例化之前的操作");
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(beanName + "实例化之后的操作");
        return null;
    }
}

工厂后的处理器接口方法，如下代码示例：

  applicationContext.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">
 
   <!-- init-method：指定初始化的方法-->
   <!-- destroy-method：指定销毁的方法 -->
		<bean id="student" class="com.zhiChao.liuLiu.Student" init-method="initStudent" destroy-method="destroyStudent">
		<property name="name" value="zhiChao"></property>
		</bean>
</beans>

测试代码：

package com.itheima.web.servlet;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        System.out.println("初始化容器开始...");

        ApplicationContext factory = new ClassPathXmlApplicationContext("application.xml");
        System.out.println("容器初始化成功");
        //得到student，并使用
        Student student = factory.getBean("student", Student.class);
        System.out.println(student);

        System.out.println("开始关闭容器！");
        ((ClassPathXmlApplicationContext) factory).registerShutdownHook();

    }
}

运行后控制台输出结果为：

    以上就是bean的一生，相信您也有了更加清晰的认识！！！