`

Spring Bean 初始化过程

springjavabeanweb 
阅读更多
Life类
Java代码 复制代码 收藏代码
  1. package com.open.bean;   
  2. import org.springframework.beans.BeansException;   
  3. import org.springframework.beans.factory.BeanFactory;   
  4. import org.springframework.beans.factory.BeanFactoryAware;   
  5. import org.springframework.beans.factory.BeanNameAware;   
  6. import org.springframework.beans.factory.DisposableBean;   
  7. import org.springframework.beans.factory.InitializingBean;   
  8. public class Life implements BeanFactoryAware, BeanNameAware,   
  9.         InitializingBean, DisposableBean {   
  10.     private String msg;   
  11.     public Life() {   
  12.         System.out.println("msg="+msg);   
  13.         System.out.println("构造函数");   
  14.     }   
  15.     public void setBeanFactory(BeanFactory beanFactory) throws BeansException {   
  16.         System.out.println("setBeanFactory");   
  17.     }   
  18.     public void setBeanName(String name) {   
  19.         System.out.println("setBeanName");   
  20.     }   
  21.     public void init() {   
  22.         System.out.println("初始化");   
  23.     }   
  24.     public Object postProcessBeforeInitialization(Object bean, String beanName)   
  25.             throws BeansException {   
  26.         System.out.println("postProcessBeforeInitialization");   
  27.         return null;   
  28.     }   
  29.     public Object postProcessAfterInitialization(Object bean, String beanName)   
  30.             throws BeansException {   
  31.         System.out.println("postProcessAfterInitialization");   
  32.         return null;   
  33.     }   
  34.     public void afterPropertiesSet() throws Exception {   
  35.         System.out.println("afterPropertiesSet");   
  36.     }   
  37.     public void destroy() throws Exception {   
  38.         System.out.println("destroy");   
  39.     }   
  40.     public String getMsg() {   
  41.         return msg;   
  42.     }   
  43.     public void setMsg(String msg) {   
  44.         this.msg = msg;   
  45.     }   
  46. }  
package com.open.bean;
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 Life implements BeanFactoryAware, BeanNameAware,
        InitializingBean, DisposableBean {
    private String msg;
    public Life() {
        System.out.println("msg="+msg);
        System.out.println("构造函数");
    }
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("setBeanFactory");
    }
    public void setBeanName(String name) {
        System.out.println("setBeanName");
    }
    public void init() {
        System.out.println("初始化");
    }
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("postProcessBeforeInitialization");
        return null;
    }
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("postProcessAfterInitialization");
        return null;
    }
    public void afterPropertiesSet() throws Exception {
        System.out.println("afterPropertiesSet");
    }
    public void destroy() throws Exception {
        System.out.println("destroy");
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
}

 

 

BeanPostProcessorImp类

Java代码 复制代码 收藏代码
  1. package com.open.bean;   
  2. import org.springframework.beans.BeansException;   
  3. import org.springframework.beans.factory.config.BeanPostProcessor;   
  4. public class BeanPostProcessorImp implements BeanPostProcessor {   
  5.     public Object postProcessBeforeInitialization(Object bean, String beanName)   
  6.             throws BeansException {   
  7.         System.out.println("postProcessBeforeInitialization");   
  8.         return bean;   
  9.     }   
  10.     public Object postProcessAfterInitialization(Object bean, String beanName)   
  11.             throws BeansException {   
  12.         System.out.println("postProcessAfterInitialization");   
  13.         return bean;   
  14.     }   
  15. }  
package com.open.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class BeanPostProcessorImp implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("postProcessBeforeInitialization");
        return bean;
    }
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("postProcessAfterInitialization");
        return bean;
    }
}

 

 

BeanCounter类

Java代码 复制代码 收藏代码
  1. package com.open.bean;   
  2. import org.springframework.beans.BeansException;   
  3. import org.springframework.beans.factory.config.BeanFactoryPostProcessor;   
  4. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;   
  5. public class BeanCounter implements BeanFactoryPostProcessor {   
  6.     public void postProcessBeanFactory(   
  7.             ConfigurableListableBeanFactory beanFactory) throws BeansException {   
  8.         System.out.println("类的数量＝"+beanFactory.getBeanDefinitionCount());   
  9.     }   
  10. }  
package com.open.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
public class BeanCounter implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(
            ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("类的数量＝"+beanFactory.getBeanDefinitionCount());
    }
}

  

 

 

 

bean.xml

Java代码 复制代码 收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"  
  3.     "http://www.springframework.org/dtd/spring-beans.dtd">   
  4. <beans>   
  5.     <bean id="life" name="life_name" class="com.open.bean.Life"    
  6.         init-method="init">   
  7.         <property name="msg" value="lifexxxx"/>   
  8.     </bean>       
  9.     <bean id="processor" class="com.open.bean.BeanPostProcessorImp"/>   
  10.     <bean id="counter" class="com.open.bean.BeanCounter"/>   
  11. </beans>  
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
    "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean id="life" name="life_name" class="com.open.bean.Life" 
        init-method="init">
        <property name="msg" value="lifexxxx"/>
    </bean>    
    <bean id="processor" class="com.open.bean.BeanPostProcessorImp"/>
    <bean id="counter" class="com.open.bean.BeanCounter"/>
</beans>

 

 

 

测试类

 

Java代码 复制代码 收藏代码
  1. package com.open.bean;   
  2. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  3. public class Test {   
  4.     public static void main(String[] args) {   
  5.         ClassPathXmlApplicationContext cx=   
  6.             new ClassPathXmlApplicationContext("bean.xml");   
  7.          Life life=(Life)cx.getBean("life");        
  8.     }   
  9. }      
package com.open.bean;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext cx=
            new ClassPathXmlApplicationContext("bean.xml");
         Life life=(Life)cx.getBean("life");     
    }
}

 

 

输出结果

 

类的数量＝3
msg=null
构造函数
setBeanName
setBeanFactory
postProcessBeforeInitialization
afterPropertiesSet
初始化
postProcessAfterInitialization

分享到：
| Spring MVC 3 深入总结
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    详解Spring 中如何控制2个bean中的初始化顺序

    Spring 中控制 2 个 bean 的初始化顺序 在 Spring 框架中，控制多个 bean 的初始化顺序是一个常见的问题。本篇文章将详细介绍如何控制 2 个 bean 的初始化顺序，提供了多种实现方式，并分析了每种方式的优缺。 ...

    Spring Bean创建初始化流程.docx

    9. **Bean初始化**： 最后，`initializeBean(beanName, exposedObject, mbd)`对创建好的Bean进行初始化，包括调用初始化方法（如果有`@PostConstruct`注解的方法），以及执行AOP代理等操作。 整个流程中，Spring...

    Spring bean初始化及销毁你必须要掌握的回调方法.docx

    下面将详细介绍如何通过不同方式定义Spring Bean的初始化和销毁回调方法。 **初始化回调方法** 1. **@PostConstruct注解** 这个Java标准注解用于标记一个方法，该方法将在对象完全构造后但在业务逻辑执行前被调用...

    springBean加载过程源码解析文档，附有代码类名和行数

    Spring Bean 加载过程是 Spring 框架中最核心的部分之一，涉及到 ApplicationContext 的初始化、Bean 的加载和注册等过程。在 Spring Boot 应用程序中，SpringApplication 负责加载和管理 Bean。 SpringApplication...

    Spring实例化Bean顺序

    但是，这并不总是可靠的，因为Spring通常会延迟初始化Bean，除非显式要求或存在依赖关系。 2. **依赖注入**：Spring容器会根据Bean之间的依赖关系来决定实例化顺序。如果一个Bean依赖于另一个Bean，那么被依赖的...

    Spring Bean的初始化和销毁实例详解

    Spring Bean的初始化和销毁实例详解 Spring Bean的初始化和销毁是Spring框架中一个非常重要的概念，它们都是Bean生命周期中不可或缺的一部分。在Spring框架中，我们可以使用多种方式来控制Bean的初始化和销毁，以下...

    Spring Bean 加载顺序 .

    7. **Bean初始化**： 实例化完成后，Spring会执行Bean的初始化方法，包括调用`@PostConstruct`注解的方法。同时，如果Bean实现了InitializingBean接口，其`afterPropertiesSet()`方法也会被调用。 8. **初始化后...

    Spring Bean重复执行两次（实例被构造两次）问题分析

    这个问题可能是由多种原因引起的，涉及到Spring的初始化过程和容器的行为。以下是对该问题的详细分析： 首先，我们需要理解Spring Bean的生命周期。在Spring容器初始化时，它会根据配置加载Bean的定义，并根据需要...

    spring bean的生命周期

    - **XML配置**：在传统的Spring应用中，Bean的定义通常写在XML配置文件中，如`springbean-xml`中的配置。 - **注解配置**：使用`@Component`，`@Service`，`@Repository`和`@Controller`注解标记类，配合`@...

    spring bean XML配置入门

    一旦XML配置加载到Spring容器中，容器将根据配置创建Bean实例，并按照定义进行初始化、依赖注入，最后完成Bean的生命周期管理。 10. **实践操作**： 在实际开发中，我们可以使用Eclipse的Spring插件来简化Bean...

    spring的bean加载顺序样例项目

    在Spring框架中，Bean的加载顺序是一个重要的概念，它涉及到Spring容器如何管理和初始化Bean的过程。在"spring的bean加载顺序样例项目"中，我们可以通过分析和实验来深入理解这一主题。下面将详细阐述Spring Bean的...

    浅谈spring容器中bean的初始化

    本文将深入探讨Spring容器中Bean的初始化过程。 首先，Spring容器根据XML配置文件（如`applicationContext.xml`）来解析Bean的定义。在示例中，我们定义了一个名为`people`的Bean，它对应于`People`类。默认情况下...

    Spring源码学习六：bean初始化1

    在本篇文章中，我们将深入探讨Spring源码中关于Bean初始化的过程，特别是`finishBeanFactoryInitialization()`方法和`preInstantiateSingletons()`方法。 首先，`finishBeanFactoryInitialization(Confi‌...

    Spring bean 动态注册，jar包热替换

    Spring bean 一般通过配置文件和注解进行加载，如果要实现jar或class...测试示例中是spring boot 的部分代码，动态加载的内容为接口实现类，且初始化时加载本地的实现类，动态加载后改为非程序加载目录中的jar实现类。

    详解Spring简单容器中的Bean基本加载过程

    3. 加载 bean：Spring 会加载 bean，并将其实例化。 4. 获取 bean：应用程序可以从容器中获取 bean 并使用它。 在加载 bean 的过程中，Spring 会使用 Resource 对象来表示 XML 文件，然后使用 ...

    spring bean life cycle

    此外，Spring提供了一种名为BeanPostProcessor的接口，它允许我们自定义Bean实例化和初始化过程中的逻辑。通过实现`postProcessBeforeInitialization()`和`postProcessAfterInitialization()`方法，可以在Bean初始化...

    spring容器初始化bean和销毁bean之前进行一些操作的方法

    此外，Spring提供了BeanPostProcessor接口，允许我们在Bean初始化前后进行自定义处理。通过实现`postProcessBeforeInitialization()`和`postProcessAfterInitialization()`方法，可以在Bean实例化和初始化之后进行...

    实例化Spring bean的两种工厂方法

    Spring Bean是Spring IoC容器管理的对象，这些对象的生命周期、依赖关系以及初始化行为由Spring容器控制。实例化Spring Bean的方式多种多样，包括XML配置、注解配置以及Java配置等。而工厂方法是其中一种自定义实例...

    初始化后可访问Spring管理的Bean

    初始化后可访问Spring管理的Bean

Magicbox
Global site tag (gtag.js) - Google Analytics