Spring点滴四:Spring Bean生命周期

Spring Bean 生命周期示意图:

了解Spring的生命周期非常重要,我们可以利用Spring机制来定制Bean的实例化过程。

---------------------------------------------------------------------------------------------------------------------------------------------------

spring-service.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 -->
    <bean id="narCodeService" class="com.test.service.impl.NarCodeServiceImpl">
    </bean>
    <bean id="beanLifecycle" class="com.test.spring.BeanLifecycle" init-method="init">
        <property name="name" value="张三"></property>
        <property name="sex" value="男"></property>
    </bean>
</beans>

Service Class:

package com.test.spring;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanClassLoaderAware;
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;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.context.EnvironmentAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.context.annotation.ImportAware;
import org.springframework.core.env.Environment;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.type.AnnotationMetadata;

import com.sun.org.apache.xml.internal.security.Init;

/**
 * 测试Spring Bean的生命周期
 * @author zss
 *
 */
public class BeanLifecycle implements InitializingBean,DisposableBean
,BeanFactoryAware,BeanNameAware,BeanPostProcessor{
    private String name;
    private String sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("》》》调用BeanLifecycle对象"+this.getName()+"属性set方法,设值为:"+name);
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        System.out.println("》》》调用BeanLifecycle对象"+this.getSex()+"属性set方法,设值为:"+sex);
        this.sex = sex;
    }
    public void init (){
        System.out.println("》》》init方法被调用");
    }

    public void  close() {
        System.out.println("》》》close方法被调用");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println(this);
        System.out.println("》》》BeanLifecycle调用了InitailizingBean的afterPorpertiesSet方法了.....");

    }

    @Override
    public void destroy() throws Exception {
        System.out.println("》》》BeanLifecycle从Spring IoC容器中移除了.......");
    }

//    @Override
//    public void setApplicationContext(ApplicationContext paramApplicationContext)
//            throws BeansException {
//        System.out.print("》》》调用ApplicationContextAware接口setApplicationContext方法:");
//        System.out.println(paramApplicationContext);
//
//    }

//    @Override
//    public void setResourceLoader(ResourceLoader paramResourceLoader) {
//        System.out.print("》》》调用ResourceLoaderAware接口setResourceLoader方法:");
//        System.out.println(paramResourceLoader);
//    }

//    @Override
//    public void setImportMetadata(AnnotationMetadata paramAnnotationMetadata) {
//        System.out.println(333333);
//    }

//    @Override
//    public void setEnvironment(Environment paramEnvironment) {
//        System.out.print("》》》调用EnvironmentAware接口setEnvironment方法:");
//        System.out.println(paramEnvironment);
//    }

    @Override
    public void setBeanName(String paramString) {
        System.out.println("》》》调用BeanNameAware接口setBenaName方法: "+paramString);

    }

    @Override
    public void setBeanFactory(BeanFactory paramBeanFactory)
            throws BeansException {

        System.out.print("》》》调用BeanFactoryAware接口setBeanFactory方法:");
        System.out.println(paramBeanFactory);

    }

//    @Override
//    public void setBeanClassLoader(ClassLoader paramClassLoader) {
//        System.out.print("》》》调用BeanClassLoaderAware接口setBeanClassLoader方法:");
//        System.out.println(paramClassLoader);
//    }

//    @Override
//    public void setApplicationEventPublisher(
//            ApplicationEventPublisher paramApplicationEventPublisher) {
//        System.out.print("》》》调用ApplicationEventPublisherAware接口setApplicationEventPublisher方法:");
//        System.out.println(paramApplicationEventPublisher);
//    }

    @Override
    public String toString() {
        return "BeanLifecycle [name=" + name + ", sex=" + sex + "]";
    }

    @Override
    public Object postProcessAfterInitialization(Object arg0, String arg1)
            throws BeansException {
        System.out.println("调用了postProcessAfterInitialization方法");
        return null;
    }

    @Override
    public Object postProcessBeforeInitialization(Object arg0, String arg1)
            throws BeansException {
        System.out.println("调用了postProcessBeforeInitialization方法");
        return null;
    }

}

Test:

package com.test.spring;

import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class T {
    ClassPathXmlApplicationContext applicationcontext=null;
    @Before
    public void before() {
        System.out.println("》》》Spring ApplicationContext容器开始初始化了......");
        applicationcontext= new ClassPathXmlApplicationContext(new String[]{"test1-service.xml"});
        System.out.println("》》》Spring ApplicationContext容器初始化完毕了......");
    }
    @Test
    public void  test() {
        BeanLifecycle beanLifecycle =applicationcontext.getBean("beanLifecycle",BeanLifecycle.class);
        //applicationcontext.close();
        applicationcontext.registerShutdownHook();
    }
}

测试结果:

》》》Spring ApplicationContext容器开始初始化了......
2017-03-18 20:29:20  INFO:ClassPathXmlApplicationContext-Refreshing org[email protected]6c7e6b26: startup date [Sat Mar 18 20:29:20 CST 2017]; root of context hierarchy
2017-03-18 20:29:20  INFO:XmlBeanDefinitionReader-Loading XML bean definitions from class path resource [test1-service.xml]
》》》调用BeanLifecycle对象null属性set方法,设值为:周四上
》》》调用BeanLifecycle对象null属性set方法,设值为:男
》》》调用BeanNameAware接口setBenaName方法: beanLifecycle
》》》调用BeanFactoryAware接口setBeanFactory方法:org.s[email protected]2b763bac: defining beans [narCodeService,beanLifecycle]; root of factory hierarchy
BeanLifecycle [name=张三, sex=男]
》》》BeanLifecycle调用了InitailizingBean的afterPorpertiesSet方法了.....
》》》init方法被调用
调用了postProcessBeforeInitialization方法
》》》Spring ApplicationContext容器初始化完毕了......
2017-03-18 20:29:20  INFO:ClassPathXmlApplicationContext-Closing org[email protected]6c7e6b26: startup date [Sat Mar 18 20:29:20 CST 2017]; root of context hierarchy
》》》BeanLifecycle从Spring IoC容器中移除了.......
》》》close方法被调用
时间: 2024-12-12 09:16:36

Spring点滴四:Spring Bean生命周期的相关文章

【Spring学习】Bean生命周期

我理解的Bean生命周期包括两个方面: Bean何时创建,何时销毁 Bean从创建到销毁的执行流程 一.Bean创建与销毁 Bean的创建时机主要由几个配置项共同来决定,包括: scope属性,决定是Bean是单例模式(singleton)还是多例模式(prototype),默认为单例singleton: lazy-init属性,只对单例模式有效,决定是否延时加载,默认为false,表示在容器初始化时,就会生成单例: RequestMapping属性,这个注解MVC中才有,当有该属性时,lazy

一步步剖析spring bean生命周期

关于spring bean的生命周期,是深入学习spring的基础,也是难点,本篇文章将采用代码+图文结论的方式来阐述spring bean的生命周期, 本篇文章将阐述清楚下图. 一  项目结构及源码 1.程序目录结构 2.applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/sc

Spring事务,Bean生命周期

一.事务相关: 1.Spring事务基于Spring AOP切面编程: 2.AOP基于代理模式,得到需要开启事务的代码的代理对象: 3.而没有开启事务的Service方法里调用了开启事务 @Transactional 的方法时,整个代码是不会开启事务的,原理还是代理模式插入事务的依据是最外层的注解: 4.对于上面3,反之,则可以,这是事务的传播机制. 二.Bean生命周期: 2.1生命周期图: 出自:<精通Spring 4.x> 2.2不同级别的接口分类: 1.Bean本身的方法:Bean的构

Spring Environment(三)生命周期

Spring Environment(三)生命周期 Spring 系列目录(https://www.cnblogs.com/binarylei/p/10117436.html) Spring Environment 属性配置管理系列文章: Spring Environment(一)API 介绍 Spring Environment(二)源码分析 Spring Environment(三)生命周期 一.Environment 初始化 每个 ApplicationContext 容器初始化时都会执行

bean生命周期

那在spring中bean的生命周期究竟是怎样的呢 1. 容器寻找Bean的定义信息并将其实例化 2. 使用依赖注入,spring按照Bean定义信息配置Bean的所有属性 3. 如果Bean实现了BeanNameAware接口,工厂调用Bean的SetBeanName()方法传递Bean的ID 4. 如果Bean实现了BeanFactoryAware接口,工厂调用setBeanFactory()方法传入工厂自身 5. 如果BeanPostProcessor和Bean关联,那么其postProc

Bean 生命周期

对于普通的Java对象,当new的时候创建对象,当它没有任何引用的时候被垃圾回收机制回收.而由Spring IoC容器托管的对象,它们的生命周期完全由容器控制. Bean生命周期流程 1.实例化Bean 实例化Bean对于BeanFactory容器,当客户向容器请求一个尚未初始化的bean时,或初始化bean的时候需要注入另一个尚未初始化的依赖时,容器就会调用createBean进行实例化. 对于ApplicationContext容器,当容器启动结束后,便实例化所有的bean. 容器通过获取B

Maven学习(四):生命周期与maven插件

一.maven 生命周期 (一)简介 Maven强大的一个重要的原因是它有一个十分完善的生命周期模型(lifecycle),这个生命周期可以从两方面来理解: 1.顾名思义,运行Maven的每个步骤都由它来定义的,这种预定义的默认行为使得我们使用Maven变得简单,相比而言,Ant的每个步骤都要你手工去定义. 2.这个模型是一种标准,在不同的项目中,使用Maven的接口是一样的,这样就不用去仔细理解每个项目的构建了,一般情况下,mvn clean install  这样的命令是通用的. 3.一个M

Android学习路线(十四)Activity生命周期——停止和重启(Stopping and Restarting)一个Activity

先占个位置,下次翻译~ :p Properly stopping and restarting your activity is an important process in the activity lifecycle that ensures your users perceive that your app is always alive and doesn't lose their progress. There are a few of key scenarios in which

微信小程序把玩(四)应用生命周期

原文:微信小程序把玩(四)应用生命周期 App() 函数用来注册一个小程序,注意必须在 app.js 中注册,且不能注册多个. 使用方式也跟Android中的Application中初始化一些全局信息以供使用. 方法: 应用生命周期代码: