欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

bean装载到Spring应用上下文的生命周期

程序员文章站 2022-04-28 16:43:27
在基于Spring的应用中,应用对象生存于Spring容器中,Spring容器负责创建对象,装配对象,配置对象,并管理对象的整个生命周期,从生存到死亡。 bean装载到Spring应用上下文中的生命周期过程如图所示: 过程解释:1. Spring对bean进行实例化; 2. Spring将值和bea ......

在基于spring的应用中,应用对象生存于spring容器中,spring容器负责创建对象,装配对象,配置对象,并管理对象的整个生命周期,从生存到死亡。

bean装载到spring应用上下文中的生命周期过程如图所示:

bean装载到Spring应用上下文的生命周期

过程解释:
1. spring对bean进行实例化;

2. spring将值和bean的引用注入到bean对应的属性中;

3. 如果bean实现了beannameaware接口,spring将bean的id传递给setbeanname()方法;

4. 如果bean实现了beanfactoryaware接口,spring将调用setbeanfactory()方法,将beanfactory容器实例传入;

5. 如果bean实现了applicationcontextaware接口,spring将调用setapplicationcontext()方法,将bean所在的应用上下文的引用传入进来;

6. 如果bean实现了beanpostprocessor接口,spring将调用它们的postprocessbeforeiniitialization()方法;

7. 如果bean实现了initializingbean接口,spring将调用它们的afterpropertiesset()方法。

8. 如果bean使用initmethod声明了初始化方法,该方法也会被调用;

9. 如果bean实现了beanpostprocessor接口,spring将调用的postprocessafterinitialization()方法;

10. 此时,bean已经准备就绪,可以被应用程序使用了,它们将一直驻留在应用上下文中,直到该应用上下文被销毁;

11. 如果bean实现了disposablebean接口,spring将调用它的destroy()接口方法。

12. 如果bean使用destroy-method声明了销毁方法,该方法也会被调用。

 

测试代码:

package beanlifecycle;

import org.springframework.beans.beansexception;
import org.springframework.beans.factory.*;
import org.springframework.context.applicationcontext;
import org.springframework.context.applicationcontextaware;

/**
 * bean的定义
 */
public class myspringbeanlifecycle implements
        beannameaware,
        beanfactoryaware,
        applicationcontextaware,
        initializingbean,
        disposablebean {

    private applicationcontext applicationcontext;

    public myspringbeanlifecycle() {
        system.out.println("实例化 myspringbeanlifecycle ...");
    }

    @override
    public void setbeanname(string s) {
        system.out.println("beannameaware -> setbeanname ...");
    }

    @override
    public void setbeanfactory(beanfactory beanfactory) throws beansexception {
        system.out.println("beanfactoryaware --> setbeanfactory ...");
    }

    @override
    public void setapplicationcontext(applicationcontext applicationcontext) throws beansexception {
        system.out.println("applicationcontextaware -> setapplicationcontext ...");
    }

    @override
    public void afterpropertiesset() throws exception {
        system.out.println("initializingbean -> afterpropertiesset ...");
    }

    @override
    public void destroy() throws exception {
        system.out.println("disposablebean -> destroy...");
    }

    public void custominit() {
        system.out.println("自定义初始化方法...");
    }

    public void customdestroy() {
        system.out.println("自定义销毁方法...");
    }
}

 

package beanlifecycle;

import org.springframework.beans.beansexception;
import org.springframework.beans.factory.config.beanpostprocessor;

/**
 * 实现beanpostprocessor接口
 */
public class myspringbeanpostprocessor implements beanpostprocessor {

    @override
    public object postprocessbeforeinitialization(object bean, string beanname) throws beansexception {
        if (bean instanceof myspringbeanlifecycle) {
            system.out.println("beanpostprocessor -> postprocessbeforeinitialization ...");
        }
        return bean;
    }

    @override
    public object postprocessafterinitialization(object bean, string beanname) throws beansexception {
        if (bean instanceof myspringbeanlifecycle) {
            system.out.println("beanpostprocessor -> postprocessafterinitialization ...");
        }
        return bean;
    }
}

 

package beanlifecycle;

import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;

/**
 * bean配置类
 */
@configuration
public class beanlifecycleconfig {

    @bean(initmethod = "custominit", destroymethod = "customdestroy")
    public myspringbeanlifecycle myspringbeanlifecycle() {
        return new myspringbeanlifecycle();
    }

    @bean
    public myspringbeanpostprocessor myspringbeanpostprocessor() {
        return new myspringbeanpostprocessor();
    }
}

 

package beanlifecycle;

import org.springframework.context.annotation.annotationconfigapplicationcontext;

public class main {
    public static void main(string[] args) {
        annotationconfigapplicationcontext context = new annotationconfigapplicationcontext(beanlifecycleconfig.class);
        context.getbean(myspringbeanlifecycle.class);
        context.destroy();
    }
}

 

运行结果

实例化 myspringbeanlifecycle ...
beannameaware -> setbeanname ...
beanfactoryaware --> setbeanfactory ...
applicationcontextaware -> setapplicationcontext ...
beanpostprocessor -> postprocessbeforeinitialization ...
initializingbean -> afterpropertiesset ...
自定义初始化方法...
beanpostprocessor -> postprocessafterinitialization ...
disposablebean -> destroy...
自定义销毁方法...

 

参考《spring实战(第4版)》