Spring的核心机制:依赖注入

对于一般的Java项目,他们都或多或少有一种依赖型的关系,也就是由一些互相协作的对象构成的。Spring把这种互相协作的关系称为依赖关系。如A组件调用B组件的方法,可称A组件依赖于B组件,依赖注入让Spring的Bean以配置文件组织在一起,而不是以硬编码的方式耦合在一起

一、理解依赖注入

依赖注入(Dependency Injection) = 控制反转(Inversion ofControl,IoC):当某个Java实例(调用者)需另一个Java实例(被调用者)时,在依赖注入模式下,创建被调用者的工作不再由调用者来完成,因此称为 控制反转 ;创建被调用者实例的工作通常由Spring容器来完成,然后注入调用者,因此也称为 依赖注入

依赖注入:程序运行过程中,如需另一个对象协作(调用它的方法、访问他的属性)时,无须在代码中创建被调用者,而是依赖于外部容器的注入。Spring的依赖注入对调用者和被调用者几乎无任何要求,完全支持对POJO间依赖关系的管理

依赖注入

设值注入:IoC容器使用属性的setter方法来注入被依赖的实例

构造注入:IoC容器使用构造器来注入被依赖的实例

理解依赖注入:

一个人(Java实例,调用者)需要一把斧子(Java实例,被调用者)

在原始社会里,几乎没有社会分工;需要斧子的人(调用者)只能自己去磨一把斧子(被调用者);对应情形为:Java程序里的调用者自己创建被调用者,通常采用new关键字调用构造器创建一个被调用者

进入工业社会,工厂出现了,斧子不再由普通人完成,而在工厂里被生产出来,此时需要斧子的人(调用者)找到工厂,购买斧子,无须关心斧子的制造过程;对应简单工厂设计模式,调用者只需定位工厂,无须管理被调用者的具体实现

进入“共产主义”社会,需要斧子的人甚至无须定位工厂,“坐等”社会提供即可;调用者无须关心被调用者的实现,无须理会工厂,等待Spring依赖注入

二、设值注入

Person接口:
public interface Person {
    // 定义使用斧子的方法
    public void useAxe();
}
Spring推荐面向接口编程,这样可更好地让规范和实现分离,从而提供更好的解耦;对于一个Java EE应用,不管是DAO组件还是业务逻辑组件,都应该先定义一个接口,该接口定义了该组件应实现的功能,但功能的实现则由其实现类提供
Axe接口:
public interface Axe {
    // Axe接口里有个砍的方法
    public String chop();
}
实现Axe:
public class StoneAxe implements Axe {
    public String chop() {
       return "石斧砍柴好慢S";
    }
}
bean.xml:
<?xml version="1.0" encoding="UTF-8"?>
<!-- Spring配置文件的根元素,使用spring-beans-3.0.xsd语义约束 -->
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://www.springframework.org/schema/beans"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

  <!-- 配置chinese实例 -->
  <bean id="chinese" class="com.Chinese">
     <!-- 将stoneAxe注入给axe属性 -->
     <property name="axe" ref="stoneAxe" />
  </bean>

  <!-- 配置stoneAxe实例 -->
  <bean id="stoneAxe" class="com.StoneAxe" />

</beans>
测试类:
public class BeanTest {
   public static void main(String[] args) {
     // 创建Spring容器
     ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
     // 获取chinese实例
     Person p = ctx.getBean("chinese", Person.class);
     // 调用useAxe()方法
     p.useAxe();
   }
}

Spring采用XML作为配置文件,从Spring2.0开始,Spring即可采用DTD来定义配置文件的语义约束,也可用XML Schema来定义(可利用Spring配置文件的扩展性,进一步简化Spring配置;还提供了一些新的标签;还允许程序员开发自定义的配置文件标签,让其他开发人员在Spring配置文件中使用这些标签:通常由第三方供应商完成);

可在Spring的projects目录的org.springframwork.beans、org.springframework.context等目录的\src\main\resources路径下找到各种*.xsd文件(Spring配置文件的XML Schema语义约束文件)

在配置文件中,Spring配置Bean实例通常会指定:

id :指定该Bean的唯一标识,程序通过id属性值来访问该Bean实例

class :指定该Bean的实现类, 此处不可再用接口 ,必须使用实现类Spring容器用XML解析器读取该属性,并利用反射来创建该实现类的实例

Spring会自动接管每个<bean.../>定义里的<property.../>元素定义,Spring会在调用无参构造器后、创建默认Bean实例后、调用对应的setter方法为程序注入属性值

每个Bean的id属性是该Bean的唯一标识,程序通过id属性访问Bean,Bean与Bean的依赖关系也通过id属性关联

Bean与Bean间的依赖关系由Spring管理,Spring采用setter方法为目标Bean注入所依赖的Bean,这种方式被称为 设值注入

使用Spring IoC容器的3个基本要点:

应用程序的各组件面向接口编程

应用程序的各组件不再由程序主动产生,而是由Spring容器来负责产生、并初始化

Spring采用配置文件、或Annotation来管理Bean的实现类、依赖关系,Spring容器则根据配置文件、利用反射来创建实例,并为之注入依赖关系

三、构造注入

在构造实例时,已经为其完成了依赖关系的初始化。这种利用构造器来设置依赖关系的方式,被称为构造注入

public class Chinese implements Person {
  private Axe axe;

  // 默认的构造器
  public Chinese() {
  }

  // 构造注入所需的带参数的构造器
  public Chinese(Axe axe) {
     this.axe = axe;
  }

  // 实现Person接口的useAxe方法
  @Override
  public void useAxe() {
     // 调用axe的chop()方法
     // 表明Person对象依赖于axe对象
     System.out.println(axe.chop());
  }
}
无须再提供设置axe属性的setter方法,仅仅提供了一个带Axe属性的构造器,Spring将通过该构造器为chinese注入所依赖的Bean实例
<?xml version="1.0" encoding="UTF-8"?>
<!-- Spring配置文件的根元素,使用spring-beans-3.0.xsd语义约束 -->
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://www.springframework.org/schema/beans"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

  <!-- 配置chinese实例 -->
  <bean id="chinese" class="com.Chinese">
     <!-- 使用构造注入,为chinese实例注入stoneAxe实例 -->
     <constructor-arg ref="stoneAxe" />
  </bean>

  <!-- 配置stoneAxe实例 -->
  <bean id="stoneAxe" class="com.StoneAxe" />

</beans>

<constructor-arg.../>元素指定了一个构造器参数,该参数类型是Axe,这指定Spring调用Chinese类里带一个Axe参数的构造器来创建chinese实例,因为使用了有参数的构造器创建实例,所以当Bean实例被创建完成后,该Bean的依赖关系已经设置完成

配置<constructor-arg.../>元素时可指定一个index属性,用于指定该构造参数值将作为第几个构造参数值;如index=“0”表明该构造参数值将作为第一个构造参数

执行效果与使用设置注入时的执行效果完全一样。区别在于:创建Person实例中Axe属性的时机不同-----设置注入是先通过无参数的构造器创建一个Bean实例,然后调用对应的setter方法注入依赖关系;而构造注入则直接调用有参数的构造器,当Bean实例创建完成后,已经完成了依赖关系的注入

四、两种注入方式的对比

相比之下,设值注入有如下优点:

与传统的JavaBean的写法更相似,程序开发人员更容易理解、接受、通过setter方法设定依赖关系显得更加直观、自然

对于复杂的依赖关系,若采用构造注入,会导致构造器过于臃肿,难以阅读;Spring在创建Bean实例时,需同时实例化其依赖的全部实例,因而导致性能下降

尤其是在某些属性可选的情况下,多参数的构造器更加笨重

相比之下,构造注入有如下优点:

可在构造器中决定依赖关系的注入顺序,优先依赖的优先注入

对于依赖关系无需变化的Bean,构造注入更有用处;因为没有setter方法,所有的依赖关系全部在构造器内设定。因此,无须担心后续的代码对依赖关系产生破坏

依赖关系只能在构造器设定,则只有组件的创建者才能改变组件的依赖关系。对组件的调用者而言,组件内部的依赖关系完全透明,更符合高内聚的原则

一般采用以设值注入为主,构造注入为辅的注入策略。对于依赖关系无须变化的注入,尽量采用构造注入;而其他的依赖关系的注入,则考虑设值注入

时间: 2024-10-11 03:06:03

Spring的核心机制:依赖注入的相关文章

spring-第一篇之spring核心机制依赖注入(DI)/控制翻转(IoC)

1.spring的核心机制:依赖注入(DI)/控制翻转(IoC) 什么是依赖:A对象需要调用B对象,所以A依赖于B. 什么是注入:A对象注入一个属性B对象. 什么是依赖注入(DI):A对象依赖于B对象,spring容器负责将B对象添加到A对象中,即将A对象的依赖对象B添加到A对象中. 什么是控制翻转(IoC):A对象依赖于B对象,它将通过new B对象的方式主动获取得B对象实例:但spring则将B对象直接送到A面前供其使用,A被动接受B对象. 依赖注入(DI)与控制翻转(IoC)的关系:只是从

Spring 的核心机制:依赖注入(控制反转)

一.说到依赖注入(控制反转),先要理解什么是依赖. Spring 把相互协作的关系称为依赖关系.假如 A 组件调用了 B 组件的方法,我们可称A 组件依赖于 B 组件. 二.什么是依赖注入. 在传统的程序设计过程中,通常由调用者来创建被调用者的实例. 在依赖注入的模式下,创建被调用者的工作不再由调用者来完成,因此称为控制反转:创建被调用者实例的工作通常由Spring 容器来完成,然后注入给调用者,因此也称为依赖注入. 三.依赖注入的好处. 依赖注入让 Spring 的 Bean 以被指文件组织在

Spring容器核心机制

Spring容器核心机制 一.背景 Spring内部最核心的机制就是IOC,控制反转.它可以让你再使用某一个对象的时候不用再去new了,只需要告诉Spring你要调用的对象的beanid就可以.这其实就是利用java里的反射,反射其实就是在运行时动态的去创建.调用对象,Spring就是在运行时,根据配置文件或注解来动态的创建对象,和调用对象里的方法的 . Spring还有一个核心就是AOP这个就是面向切面编程,可以为某一类对象 进行监督和控制(也就是 在调用这类对象的具体方法的前后去调用你指定的

回客科技 面试的 实现ioc 容器用到的技术,简述BeanFactory的实现原理,大搜车面试的 spring 怎么实现的依赖注入(DI)

前言:这几天的面试,感觉自己对spring 的整个掌握还是很薄弱.所以需要继续加强. 这里说明一下spring的这几个面试题,但是实际的感觉还是不对的,这种问题我认为需要真正读了spring的源码后说出来的东西才有意义.这种面试的问法,也只能是面试的问法,对实际的掌握还是没有丝毫意义的.所以我认为 有机会一定要读下spring的源码 来过一遍 具体实现,这样的才是有意义的做法.同意的请举手. 这里说明一下这三个spring 面试问题: 1.回客科技 面试的 实现ioc 容器用到的技术 第1种 说

采用Spring管理Bean和依赖注入

1.实例化spring容器 和 从容器获取Bean目标 实例化Spring容器常用的两种办法: 办法一: 在类途径下寻觅配置文件来实例化容器 [引荐运用] ApplicationContext ctx = new ClassPathXmlApplicationContext(new String[]{"beans.xml"}); 办法二: 在文件体系途径下寻觅配置文件来实例化容器 [这种办法能够在开发期间运用] ApplicationContext ctx = new FileSyst

Spring quartz Job不能依赖注入,Spring整合quartz Job任务不能注入

Spring quartz Job不能依赖注入,Spring整合quartz Job任务不能注入 Spring4整合quartz2.2.3中Job任务使用@Autowired不能注入 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ©Copyright 蕃薯耀 2017年9月6日 http://ww

如何把对象手动注入Spring容器并实现依赖注入

将对象注入到Spring容器并实现依赖注入 public class UserDao { @Resource AccountService accountService; public void print(){ System.out.println(accountService); } } 比如有以上这个类,实现将new UserDao()放入Spring容器中(放入工作由DefaultListableBeanFactory完成),并且AccountService会自动注入(注入工作由Auto

Spring学习一(依赖注入/Bean/注解等)

1.Spring依赖注入的方式. 2.依赖注入的类型 3.Bean的作用域 4.自动注入 5.使用注解的方式 6.在spring配置文件中引入属性文件 1.Spring依赖注入的方式 平常的java开发中,程序员在某个类中需要依赖其它类的方法,则通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理. spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中.依赖注入的另一种说法是“

Spring-----3、Spring的核心机制:依赖注入

纵观所有Java应用(从基于Applet的小应用到多层结构的企业级应用),他们都是一种典型的依赖型应用,也就是由一些互相协作的对象构成的.Spring把这种互相协作的关系称为依赖关系.如A组件调用B组件的方法,可称A组件依赖于B组件依赖注入让Spring的Bean以配置文件组织在一起,而不是以硬编码的方式耦合在一起 一.理解依赖注入 依赖注入(Dependency Injection) = 控制反转(Inversion ofControl,IoC):当某个Java实例(调用者)需另一个Java实