简单了解Spring IoC相关概念原理

Spring Ioc是Spring框架的基础,本文会简单的介绍下Spring Ioc。

Sprong Ioc即控制反转,它是一种通过描述(在java中可以是XML或注解)并通过第三方去产生或获取特定对象的方式。

Spring IoC容器

1、Spring IoC容器的设计

Spring IoC容器的设计主要是基于BeanFactory和ApplicationContext这两个接口,其中ApplicationContext是BeanFactory的一个子接口。也就是说,BeanFactory是Spring IoC容器定义的最底层接口,而ApplicationContext是其高级接口之一,因此大部分情况下会使用后者作为Spring IoC容器。

1.1 ClassPathXmlAppLicationContext

首先我们来认识一下ApplicationContext的子类ClassPathXmlAppLicationContext。先创建一个.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-4.0.xsd">
  <bean id="source" class="com.ssm.chapter.pojo.Source">
    <property name="fruit" value="橙汁" />
    <property name="sugar" value="少糖" />
    <property name="size" value="大杯" />
  </bean>
  <bean id="juiceMaker" class="com.ssm.chapter.pojo.JuiceMaker" >
    <property name="beverageShop" value="贡茶" />
    <property name="source" ref="source" />
  </bean>
  </beans>

这里定义了两个bean,这样Spring IoC容器在初始化的时候就可以找到它们,然后使用ClassPathXmlAppLicationContext容器就可以将其初始化,代码清单如下:

ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-cfg.xml");
    JuiceMaker juiceMaker = (JuiceMaker) ctx.getBean("juiceMaker");
    System.out.println(juiceMaker.makeJuice());

这样就会使用Application的实现类ClassPathXmlAppLicationContext去初始化Spring IoC,然后开发者就可以通过Ioc容器获取资源了。

1.2 Spring Bean的生命周期

Spring IoC容器的本质就是为了管理Bean。生命周期主要是为了了解Spring IoC容器初始化和销毁Bean的过程,通过对它的学习就可以知道如何在初始和销毁的时候加入自定义的方法,以满足特定的需求。注:Spring IoC容器初始化和销毁Bean的过程我这里就不介绍了啊,在网上很容易找到,这里主要是通过代码去实现生命周期的过程。

除了了解生命周期的步骤之外,还要知道生命周期的接口是针对设么而言的,首先介绍生命周期的步骤:

①如果Bean实现了接口BeanNameAware,那么就会调用setBeanName方法。

②如果Bean实现了接口BeanFactoryAware,那么就会调用setBeanFactory方法。

③如果Bean实现了接口ApplicationContextAware,且Spring IoC容器也是ApplicationContext的一个实现类,那么就会调用setApplicationContext方法。

④如果Bean实现了接口BeanPostProcessor的,那么就会调用postProcessBeforeInitialization方法。

⑤如果Bean实现了接口BeanFactoryPostProcess,那么就会调用afterPropertiesSet方法。

⑥如果Bean自定义了初始化方法,它就会地用用已定义的初始化方法。

⑦如果Bean实现了接口BeanPostProcessor,那么就会调用postProcessAfterInitialization方法,之后这个bean就会完成了初始化,开发者就可以从Spring IoC中获取Bean的服务。

⑧如果Bean实现了接口DisposableBean,那么就会调用destroy的方法。

⑨如果定义了自定义销毁方法,那么就会调用它。

此外,上面大部分的接口是针对单个Bean而言的;而BeanPostProcessor接口则是针对所有Bean而言的。为了测试BeanPostProcessor接口,可以写一个实现类:

package com.ssm.chapter.bean;

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

public class BeanPostProcessorImpl implements BeanPostProcessor {
  @Override
  public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    System.out.println("[" + bean.getClass().getSimpleName() + "]对象" + beanName + "开始初始化");
    return bean;
  }

  @Override
  public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    System.out.println("[" + bean.getClass().getSimpleName() + "]对象" + beanName + "实例化完成");
    return bean;
  }
}

这样BeanPostProcessor就被我们用代码实现了,他会处理Spring IoC容器中的所有Bean。

为了更好的展示生命周期的内容,将上面的代码中JuiceMaker类进行修改:

package com.ssm.chapter.pojo;

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;

public class JuiceMaker implements BeanNameAware, BeanFactoryAware, ApplicationContextAware,
    InitializingBean, DisposableBean{

  private String beverageShop = null;

  private Source source = null;

  public String getBeverageShop() {
    return beverageShop;
  }

  public void setBeverageShop(String beverageShop) {
    this.beverageShop = beverageShop;
  }

  public Source getSource() {
    return source;
  }

  public void setSource(Source source) {
    this.source = source;
  }

  public void init() {
    System.out.println("[" + this.getClass().getSimpleName() + "]执行自定义初始化方法");
  }

  public void myDestroy() {
    System.out.println("[" + this.getClass().getSimpleName() + "]执行自定义销毁方法");
  }

  public String makeJuice() {
    String juice = "这是一杯由" + beverageShop + "饮品店,提供的" + source.getSize() +source.getSugar() +
        source.getFruit();
    return juice;
  }

  @Override
  public void setBeanName(String name) {
    System.out.println("[" + this.getClass().getSimpleName() + "]调用BeanNameAware接口的setBeanName方法");
  }

  @Override
  public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    System.out.println("[" + this.getClass().getSimpleName() + "]调用BeanFactoryAware接口的setBeanFactory方法");
  }

  @Override
  public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    System.out.println("[" + this.getClass().getSimpleName() + "]调用ApplicationContextAware接口的setApplicationContext方法");
  }

  @Override
  public void destroy() throws Exception {
    System.out.println("[" + this.getClass().getSimpleName() + "]调用DisposableBean接口的destroy方法");
  }

  @Override
  public void afterPropertiesSet() throws Exception {
    System.out.println("[" + this.getClass().getSimpleName() + "]调用InitializingBean接口的afterPropertiesSet方法");
  }
}

这个类实现了所以生命周期中的方法,以便以观察生命周期,其中init方法是自定义的初始化方法,而myDestroy方法是自定义的销毁方法,为了进一步使用这两个自定义方法,在描述Bean的时候,也要在.xml中进行如下声明:

<bean id="beanPostProcessor"
     class="com.ssm.chapter.bean.BeanPostProcessorImpl" />
  <bean id="source" class="com.ssm.chapter.pojo.Source">
    <property name="fruit" value="橙汁" />
    <property name="sugar" value="少糖" />
    <property name="size" value="大杯" />
  </bean>
  <bean id="juiceMaker" class="com.ssm.chapter.pojo.JuiceMaker" init-method="init" destroy-method="myDestroy">
    <property name="beverageShop" value="贡茶" />
    <property name="source" ref="source" />
  </bean>

这里定义了id为JuiceMaker的Bean,其属性init-menth就是自定义的初始化方法,而destroy-method为自定义的销毁方法。下面是测试代码清单:

 ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring-cfg.xml");
    JuiceMaker juiceMaker = (JuiceMaker) ctx.getBean("juiceMaker");
    System.out.println(juiceMaker.makeJuice());
    ctx.close();

日志如下:

[Source]对象source开始初始化
[Source]对象source实例化完成
[JuiceMaker]调用BeanNameAware接口的setBeanName方法
[JuiceMaker]调用BeanFactoryAware接口的setBeanFactory方法
[JuiceMaker]调用ApplicationContextAware接口的setApplicationContext方法
[JuiceMaker]对象juiceMaker开始初始化
[JuiceMaker]调用InitializingBean接口的afterPropertiesSet方法
[JuiceMaker]执行自定义初始化方法
[JuiceMaker]对象juiceMaker实例化完成
这是一杯由贡茶饮品店,提供的大杯少糖橙汁
[JuiceMaker]调用DisposableBean接口的destroy方法
[JuiceMaker]执行自定义销毁方法

从日志中可以看出,生命周期中的方法都被执行了。也可以看到BeanPostProcessor针对的是全部Bean。我们也可以自定义初始化和销毁Bean的方法。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • Spring IOC和aop的原理及实例详解

    这篇文章主要介绍了Spring IOC和aop的原理及实例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架.特点是面向接口编程,松耦合. 1:IOC(控制反转) 别名(DI:依赖注入) 首先来一段ioc的实现原来代码: public class ClassPathXmlApplicationContext implements BeanFactory { privat

  • Spring bean的实例化和IOC依赖注入详解

    前言 我们知道,IOC是Spring的核心.它来负责控制对象的生命周期和对象间的关系. 举个例子,我们如何来找对象的呢?常见的情况是,在路上要到处去看哪个MM既漂亮身材又好,符合我们的口味.就打听她们的电话号码,制造关联想办法认识她们,然后...这里省略N步,最后谈恋爱结婚. IOC在这里就像婚介所,里面有很多适婚男女的资料,如果你有需求,直接告诉它你需要个什么样的女朋友就好了.它会给我们提供一个MM,直接谈恋爱结婚,完美! 下面就来看Spring是如何生成并管理这些对象的呢? 1.方法入口 o

  • Spring中IOC和AOP的深入讲解

    前言 Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来.它是为了解决企业应用开发的复杂性而创建的.Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情.然而,Spring的用途不仅限于服务器端的开发.从简单性.可测试性和松耦合的角度而言,任何Java应用都可以从Spring中受益

  • 详解Spring IOC 容器启动流程分析

    使用 Spring 时,XML 和注解是使用得最多的两种配置方式,虽然是两种完全不同的配置方式,但对于 IOC 容器来说,两种方式的不同主要是在 BeanDefinition 的解析上.而对于核心的容器启动流程,仍然是一致的. AbstractApplicationContext 的 refresh 方法实现了 IOC 容器启动的主要逻辑,启动流程中的关键步骤在源码中也可以对应到独立的方法.接下来以  AbstractApplicationContext 的实现类  ClassPathXmlAp

  • 关于SpringBoot获取IOC容器中注入的Bean(推荐)

    一: 注入一个TestUtils类 package com.shop.sell.Utils; import com.shop.sell.dto.CartDTO; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class TestUtils { @Bean(name="test

  • 简单实现Spring的IOC原理详解

    控制反转(InversionofControl,缩写为IoC) 简单来说就是当自己需要一个对象的时候不需要自己手动去new一个,而是由其他容器来帮你提供:Spring里面就是IOC容器. 例如: 在Spring里面经常需要在Service这个装配一个Dao,一般是使用@Autowired注解:类似如下 public Class ServiceImpl{ @Autowired Dao dao; public void getData(){ dao.getData(); } 在这里未初始化Dao直接

  • Spring为IOC容器注入Bean的五种方式详解

    这篇文章主要介绍了Spring为IOC容器注入Bean的五种方式详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一 @Import导入组件,id默认是组件的全类名 //类中组件统一设置.满足当前条件,这个类中配置的所有bean注册才能生效: @Conditional({WindowsCondition.class}) @Configuration @Import({Color.class,Red.class,MyImportSelector

  • 简单了解Spring IoC相关概念原理

    Spring Ioc是Spring框架的基础,本文会简单的介绍下Spring Ioc. Sprong Ioc即控制反转,它是一种通过描述(在java中可以是XML或注解)并通过第三方去产生或获取特定对象的方式. Spring IoC容器 1.Spring IoC容器的设计 Spring IoC容器的设计主要是基于BeanFactory和ApplicationContext这两个接口,其中ApplicationContext是BeanFactory的一个子接口.也就是说,BeanFactory是S

  • 简单谈谈Spring Ioc原理解析

    业务场景: 在使用Java进行开发业务的过程中,很多时候一个业务是由各种组件组成,在每个使用到这些组件时都会毫不犹豫的new一个组件对象来使用,在小项目中这样的做法无可厚非,也不存在什么问题.但是在业务逻辑复杂并且多人协作开发的项目中,这会导致业务和组件之间的关系错综复杂而且不便于管理,对象之间的耦合度变得很高,这就是所谓的牵一发而动全身吧. 而这个问题在spring中得到了解决,它的核心在于Ioc思想: Ioc:全文是Inversion of Control.翻译过来就是控制反转,意思是对象之

  • 创建Maven项目和Spring IOC实例过程解析

    这篇文章主要介绍了创建Maven项目和Spring IOC实例过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 把如何创建Maven项目和创建Spring IOC的例子分享给大家,希望能对大家有帮助! 一.创建Maven项目 我用的是Intellij IDEA开发工具创建Maven项目的,打开该软件后,直接点击file --->project,如下图所示, 然后就直接跟着我的图片的步骤往下走. 到了这一个就创建好了Maven项目了,然后开

  • 使用Java注解模拟spring ioc容器过程解析

    使用注解,简单模拟spring ioc容器.通过注解给对象属性注入值. 项目结构 annotation 包,用于存放自定义注解 Component 注解表示该类为组件类,并需要声明名字 package priv.haidnor.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy;

  • Spring IOC原理详解

    最近,买了本Spring入门书:springInAction.大致浏览了下感觉还不错.就是入门了点.Manning的书还是不错的,我虽然不像哪些只看Manning书的人那样专注于Manning,但怀着崇敬的心情和激情通览了一遍.又一次接受了IOC.DI.AOP等Spring核心概念.先就IOC和DI谈一点我的看法. IOC(DI):其实这个Spring架构核心的概念没有这么复杂,更不像有些书上描述的那样晦涩.java程序员都知道:java程序中的每个业务逻辑至少需要两个或以上的对象来协作完成,通

  • 浅谈Spring IoC容器的依赖注入原理

    本文介绍了浅谈Spring IoC容器的依赖注入原理,分享给大家,具体如下: IoC容器初始化的过程,主要完成的工作是在IoC容器中建立 BeanDefinition 数据映射,并没有看到IoC容器对Bean依赖关系进行注入, 假设当前IoC容器已经载入用户定义的Bean信息,依赖注入主要发生在两个阶段 正常情况下,由用户第一次向IoC容器索要Bean时触发 但我们可以在 BeanDefinition 信息中通过控制 lazy-init 属性来让容器完成对Bean的预实例化,即在初始化的过程中就

  • 简单理解Spring之IOC和AOP及代码示例

    Spring是一个开源框架,主要实现两件事,IOC(控制反转)和AOP(面向切面编程). IOC 控制反转,也可以称为依赖倒置. 所谓依赖,从程序的角度看,就是比如A要调用B的方法,那么A就依赖于B,反正A要用到B,则A依赖于B.所谓倒置,你必须理解如果不倒置,会怎么着,因为A必须要有B,才可以调用B,如果不倒置,意思就是A主动获取B的实例:Bb=newB(),这就是最简单的获取B实例的方法(当然还有各种设计模式可以帮助你去获得B的实例,比如工厂.Locator等等),然后你就可以调用b对象了.

  • spring ioc的简单实例及bean的作用域属性解析

    IoC(Inversion if Control)-控制反转是Spring俩大核心技术之一,IoC一般分为俩种类型:依赖注入(Dependency Injection,简称DI)和依赖查找(Dependency Lookup) 使用示例: 1.新建工程并导入Spring相关jar包. 2.新建数据访问层及业务逻辑层 代码结构: 代码示例: /** * 实体Bean * @author BC * */ public class User { private Integer id; private

随机推荐