Spring IOC

最新推荐文章于 2024-03-18 14:30:11 发布
最新推荐文章于 2024-03-18 14:30:11 发布
阅读量286 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Spring diagram 文章标签： Spring ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u012270113/article/details/80802914

 

 

 

 

 

Bean 的生命周期

1.根据XML中定义的Bean，调用无参构造方法。

2.设置Bean的属性。

3.检查是否实现各种Aware接口，依次是 BeanNameAware, BeanFactoryAware, ApplicationContextAware。若有，则调用相关接口的方法, 即：setBeanName（String beanName）,setBeanFactory(BeanFactory beanFactory),setApplicationContext(ApplicationContext applicationContext)

4.检查是否实现各种BeanPostProcessor. 先调用其postProcessBeforeInitialization，更改Bean的属性。

5.检查是否实现Initializating接口，若有，调用其afterPropertiesSet(）方法。

6.检查XML中Bean是否有init-method方法，若有，调用之。

7.检查是否实现各种BeanPostProcessor. 先调用其postProcessAfterInitialization，更改Bean的属性。

8.应用程序可以使用这个Bean

9.检查是否实现DisposableBean接口，若有，调用其destory方法。

10.检查XML中Bean 是否有destroy-method，若有，调用之。

 

下面的例子剔除各种BeanPostProcessor, 看看效果。

package com.spring.ioc.springBeanTest.lifeCycle;

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;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * @author qsk
 */
public class Person implements BeanNameAware,
    BeanFactoryAware,
    ApplicationContextAware,
    InitializingBean,
    DisposableBean {

  private String name;
  private String address;
  private int phone;

  private String beanName;
  private BeanFactory beanFactory;
  private ApplicationContext applicationContext;

  public Person() {
    System.out.println("【构造器】调用Person的构造器实例化");
  }

  public Person(String name, String address, int phone) {
    super();
    this.name = name;
    this.address = address;
    this.phone = phone;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    System.out.println("【注入属性】注入属性name");
    this.name = name;
  }

  public String getAddress() {
    return address;
  }

  public void setAddress(String address) {
    System.out.println("【注入属性】注入属性address");
    this.address = address;
  }

  public int getPhone() {
    return phone;
  }

  public void setPhone(int phone) {
    System.out.println("【注入属性】注入属性phone");
    this.phone = phone;
  }

  @Override
  public String toString() {
    return "Person [address=" + address + ", name=" + name + ", phone=" + phone + "]";
  }

  // 这是BeanNameAware接口方法
  @Override
  public void setBeanName(String arg0) {
    System.out.println("【BeanNameAware接口】调用BeanNameAware.setBeanName()");
    this.beanName = arg0;
  }

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

  // 这是ApplicationContext接口方法
  @Override
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    this.applicationContext = applicationContext;
    System.out.println("【ApplicationContextAware】 调用setApplicationContext方法" + applicationContext);
  }

  // 这是InitializingBean接口方法
  @Override
  public void afterPropertiesSet() throws Exception {
    System.out.println("【InitializingBean接口】调用InitializingBean.afterPropertiesSet()");
  }

  // 通过<bean>的init-method属性指定的初始化方法
  public void myInit() {
    System.out.println("【init-method】调用<bean>的init-method属性指定的初始化方法");
  }

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

  // 通过<bean>的destroy-method属性指定的初始化方法
  public void myDestory() {
    System.out.println("【destroy-method】调用<bean>的destroy-method属性指定的初始化方法");
  }
}
package com.spring.ioc.springBeanTest.lifeCycle;

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

public class BeanLifeCycle {

  public static void main(String[] args) {

    System.out.println("现在开始初始化容器");

    ApplicationContext factory = new ClassPathXmlApplicationContext("beanLifeCyclebeans.xml");
    System.out.println("容器初始化成功");
   
    System.out.println("现在开始关闭容器！");
    ((ClassPathXmlApplicationContext) factory).registerShutdownHook();
  }
}
<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans 
            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

   
    <bean id="person2" class="com.spring.ioc.springBeanTest.lifeCycle.Person" init-method="myInit"
          destroy-method="myDestory" >
        <property name="name" value="zz"></property>
    </bean>

</beans>

结果如下：

Bean 作用域

singleton：定义bean的范围为每个spring容器一个实例(默认值)；容器启动初始化就同时自动创建了一个bean的对象。

prototype：定义bean可以被多次实例化(使用一次就创建一次)；创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。

有例为证，Person类和测试类还是上面的代码，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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans 
            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">



    <bean id="person2" class="com.spring.ioc.springBeanTest.lifeCycle.Person" init-method="myInit"
          destroy-method="myDestory" >
        <property name="name" value="zz"></property>
    </bean>

    <bean id="person3" class="com.spring.ioc.springBeanTest.lifeCycle.Person" init-method="myInit"
          destroy-method="myDestory" scope="prototype" >
        <property name="name" value="zz3"></property>
    </bean>


</beans>

效果如下：

可以看到定义scope为prototype的person3并没有在容器加载的时候被调用，仅仅是singleton的实例，在容器加载的时候被调用。

更改测试类如下：

 

package com.spring.ioc.springBeanTest.lifeCycle;

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

public class BeanLifeCycle {

  public static void main(String[] args) {

    System.out.println("现在开始初始化容器");

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


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

效果如下：

 

可以看到，仅仅在显示getBean调用时，prototype的person3才会真正初始。

接下来，继续修改Person类 ，

package com.spring.ioc.springBeanTest.lifeCycle;

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

public class BeanLifeCycle {

  public static void main(String[] args) {

    System.out.println("现在开始初始化容器");

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

    System.out.println();
    Person person22 = factory.getBean("person2", Person.class);
    System.out.println(person22);

    System.out.println();
    Person person3 = factory.getBean("person3", Person.class);
    System.out.println(person3);

    System.out.println();
    Person person32 = factory.getBean("person3", Person.class);
    System.out.println(person32);

    System.out.println("\nSingleton ");
    System.out.println(person2 == person22);

    System.out.println("\nPrototype");
    System.out.println(person3 == person32);
    
    System.out.println("现在开始关闭容器！");
    ((ClassPathXmlApplicationContext) factory).registerShutdownHook();
  }
}

效果如下：

Referrence:

http://www.cnblogs.com/zrtqsk/p/3735273.html

spring bean生命周期四---Spring Bean 初始化阶段（Initialization）
qq_36697880的博客
02-19 2526
目录 概述 一、initializeBean 2.1、invokeAwareMethods - 激活 Aware 方法 2.2、Spring Bean 初始化前阶段 第七次调用后置处理器 2.3、invokeInitMethods - 激活自定义的init方法 2.4、Spring Bean 初始化后阶段 第八次调用后置处理器postProcessAfterInitialization 三、Spring Bean 初始化完成阶段 四、测试代码案例： 概述 本文是笔者阅读Sprin..
Springboot扩展点系列_InitializingBean
皮球
10-26 635
到这里InitializingBean#afterPropertiesSet方法和init-method是什么时候开始调用，是用什么方式来调用的呢，已经分析清楚了，同时还了解到InitializingBean#afterPropertiesSet方法和init-method有类似的效果，执行时机也比较接近，但是是两个完全不同的东西，且InitializingBean#afterPropertiesSet方法的执行时机要稍早于init-method。是用什么方式来调用的呢？
InitializingBean学习
weixin_44877172的博客
03-18 802
Spring之InitializingBean
spring之创建spring后处理器
NeQrhk
11-26 437
Bean后处理器允许在初始化回调方法前后进行附加的bean处理，bean处理器的主要特性是逐个处理IoC容器的所有bean实例，而不只是单个bean实例，一般bean后处理器用于检查bean属性有效性，或者根据特殊条件修改bean属性。 bena后处理器的基本要求是实现beanPostProcessor接口，你可以实现postProcessBeforeInitialization() 和
InitializingBean接口使用方法
苍白的咏叹调的博客
12-06 2330
1.定义 InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。 2.使用方法 1）编写一个类引用InitializingBean接口，重写其中的afterPropertiesSet方法，在其中写自己的方法 @Component public class TestComponent implements InitializingBean { private sta
浅析InitializingBean初始化接口
Ryo的博客
10-18 316
InitializingBean接口为Bean提供了初始化的方法，它只包含afterPropertiesSet方法，在初始化bean的时候会执行该办法。 Spring为bean提供了两种初始化的方式：一、实现InitializingBean接口，实现afterPropertiesSet方法。二、在配置文件中通过init-method指定初始化方法。 我们来看下这两种初始化的方式有什么区别 pack...
spring ioc
03-06
标题 "Spring IOC" 描述了我们讨论的核心主题——Spring 框架中的依赖注入（Inversion of Control，简称 IOC）机制。Spring 是一个广泛应用的 Java 应用开发框架，其核心特性之一就是IOC，它极大地简化了软件组件...
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器启动流程分析 Spring IOC 容器是 Java 企业级应用程序的核心组件之一，它提供了一个统一的依赖注入机制，使得应用程序的组件之间能够松耦合。Spring IOC 容器的启动流程是整个 Spring 框架的核心...
springIoc实现原理
04-20
**Spring Ioc 实现原理详解** Spring Ioc（Inversion of Control，控制反转）是Spring框架的核心特性之一，它改变了传统应用程序中对象的创建和管理方式。在传统的软件设计中，对象的创建和依赖关系的维护通常由...
SPRING IOC注入方式过程解析
08-25
SPRING IOC注入方式过程解析 SPRING IOC是一种轻量级的控制反转（Inversion of Control）容器框架，主要用于解耦合Java应用程序中的组件。其中，IOC（Inversion of Control）注入是SPRING IOC的核心机制之一。下面...
Spring实现一个简单的SpringIOC容器
08-30
Spring的IOC（Inversion of Control，控制反转）容器是其核心特性之一，它负责管理和装配应用程序中的对象。本文将深入探讨如何实现一个简单的Spring IOC容器，以及涉及的主要知识点。 首先，控制反转是一种设计...
spring bean初始化和销毁方法
H405282968的博客
05-31 157
spring bean初始化和销毁方法 转载于:https://www.cnblogs.com/westward/p/6923468.html
Spring中Bean的生命周期详解
啥都不会ccc的博客
03-17 368
最近在复习spring的知识，看到了spring中bean的生命周期，发现和自己以前的理解有很大的出入，就重新查了一些资料，也看了一些csdn上的文章，并根据自己的理解，对spring中bean的生命周期重新进行一次详细的总结(ps:因为是个人理解,可能会出现一些错误,欢迎指正)。 首先我们来看一张图： 这张图是我从csdn上看到的一篇博客中的（https://b...
日常记录：InitializingBean是什么？
qq_36551991的博客
05-27 534
前言 今天在项目看到一个InitializingBean，不了解是什么作用，特意查了下 InitializingBean 其实，InitializingBean接口是为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。 InitializingBean源码 public interface InitializingBean { void afterPropertiesSet() throws Exception
BeanFactory容器设计简述
liu_shi_jun的专栏
04-30 365
先上uml类图 XmlBeanFactory是BeanFactory体系中最底层的一个实现，它提供了IoC容器的最基本功能，包括加载xml资源，解析并注册BeanDefinitions，bean配装等。 来看一下这个类的方法， 可以看到这个类自身只提供了一个从xml文件解析加载beans的功能，核心功能都是通过父类DefaultListableBeanFactory来实现的。Defa...
Spring的体系结构组成
qq_41089939的博客
11-25 421
1. Spring的体系结构组成？ (一).核心容器(Core Container) Spring最基础的功能，提供IOC和依赖注入特性，从BeanFactory实现消除对单例的需要，并允许从逻辑中分离依赖和配置； 基于Core和Bean的Context提供了一种框架风格来访问对象； (二).数据访问(Data Access/Integration) JDBC模块，提供对JDBC的抽象，它可消除冗长的JDBC编码和解析数据库厂商特有的错误代码。 ORM模块，提供了常用的“对象/关系”映射API的集成层
一、Spring MVC 源码学习（BeanFactory及其体系结构）
qq2413273056的博客
09-10 488
        一、BeanFactory体系结构 摘自:《Spring技术内幕：深入解析 Spring架构与设计原理》              1.1 BeanFactory接口设计 public interface BeanFactory { String FACTORY_BEAN_PREFIX = "&amp;"; Object getBean(String nam...
Spring BeanFactory 类图详解
AntizZ 的博客
12-11 4295
1.Spring BeanFactory 大致的类图:
Spring的BeanFactory体系结构一
高级java程序员联盟
12-24 375
工作中使用spring 有几年的时间了，一直使用spring里面的一些核心的api，也没有去深入学习具体的结构体系，最近心血来潮想对里面的体系结构做一个深入的学习。特整理了一张beanFactory结构体系图： [img]http://dl.iteye.com/upload/picture/pic/78494/d13e3946-c5d2-352b-89d0-0ae1507...
Spring ioc
最新发布
06-01
<bean id="userDao" class="com.mayuanfei.springioc.dao.impl.UserDaoImpl" /> ``` 示例代码（注解配置）： ```java @Component public class UserDaoImpl implements UserDao { // 实现方法 } ``` ##### (2) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值