`

Spring核心机制之依赖注入

阅读更多
资料来源:http://java.9sssd.com/javafw/art/1340

Java应用(从applets的小范围到全套n层服务端企业应用)是一种典型的依赖型应用,它就是由一些互相适当地协作的对象构成的。因此,我们说这些对象间存在依赖关系。加入A组件调用了B组件的方法,我们就可以称A组件依赖于B组件。我们通过使用依赖注入,Java EE应用中的各种组件不需要以硬编码方式耦合在一起,甚至无需使用工厂模式。当某个Java 实例需要其他Java 实例时,系统自动提供所需要的实例,无需程序显示获取,这种自动提供java实例我们谓之为依赖注入,也可以称之为控制反转(Inversion of Control IoC)。

其实不管是控制反转还是依赖注入,他们都可以这样理解:当某个Java实例(调用者)需要另一个Java实例(被调用者)时,在传统的程序设计过程中,通常有调用者来创建被调用者的实例。但是在依赖注入/控制反转模式下,创建被调用者的工作不再是有调用者来完成,而是由Spring容器来完成,然后注入调用者。

对于Spring而言,Spring采用动态、灵活的方式来管理各种对象。对象与对象之间的具体实现都是透明的。Spring的依赖注入对调用者和被调用者几乎没有任何要求,完全支持对POJO之间依赖关系的管理。

依赖注入通常有如下两种:

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

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

一、设值注入

设值注入是指IoC容器使用属性的setter方法来注入被依赖的实例。这种注入方式比较简单、直观。

下面是Person接口,该接口定义了一个Person规范。

View Row Code
1 public interface Person {
2     //定义使用斧子的方法
3     public void useAxe();
4 }
Axe接口:

View Row Code
1 public interface Axe {
2     //Axe接口里面有个砍的方法
3     public String chop();
4 }
Person的实现类。

View Row Code
1 public class Chinese implements Person {
2     private Axe axe;
3     private String name;
4
5     // 设值注入所需的setter方法
6     public void setAxe(Axe axe) {
7         this.axe = axe;
8     }
9
10     public void setName(String name) {
11         this.name = name;
12     }
13
14     // 实现Person接口的userAxe方法
15     public void useAxe() {
16         // 调用axe的chop方法,表明Person对象依赖于Axe对象
17         System.out.println("我是"+name+"用"+axe.chop());
18     }
19
20 }
上面的代码实现了Person接口的userAxe()方法,实现该方法时调用了axe的的chop()方法,这就是典型的依赖关系。

在这里Spring容器的作用就是已松耦合的方式来管理这种调用关系。在上面的Chinese类中,Chinese类并不知道它要调用的axe实例在哪里,也不知道axe实例是如何实现的,它只是需要调用一个axe实例,这个Axe实例将由Spring容器负责注入。

Axe的实现类:StoneAxe类

View Row Code
1 public class StoneAxe implements Axe{
2
3     public String chop() {
4         return "石斧砍柴好慢啊!!!";
5     }
6
7 }
直到这里,程序依然不知道Chinese类和Axe实例耦合,Spring也不知道!实际上,Spring需要使用XML配置文件来指定实例之间的依赖关系。

Spring采用了XML文件作为配置文件。

对于本应用的XML配置文件如下:

View Row Code
1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3     xmlns="http://www.springframework.org/schema/beans"
4     xsi:schemaLocation="http://www.springframework.org/schema/beans
5     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
6
7     <!-- 配置Chinese实例,其实现类是Chinese -->
8     <bean id="chinese" class="com.spring.service.impl.Chinese">
9         <!-- 将StoneAxe注入给axe属性 -->
10         <property name="axe" ref="stoneAxe" />
11         <property name="name" value="孙悟空"/>
12     </bean>
13    
14    
15     <!-- 配置stoneAxe实例 -->
16     <bean id="stoneAxe" class="com.spring.service.impl.StoneAxe" />
17 </beans>
在配置文件中,Spring配置Bean实例通常会指定两个属性:

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

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

从上面可以看出Bean于Bean之间的依赖关系放在配置文件里组织,而不是写在代码里。通过配置文件的指定,Spring能够精确地为每个Bean注入属性。因此,配置文件里的<bean…/>元素的class属性值不能是接口,而必须是真正的实现类。

Spring会自动接管每个<bean…/>定义里的<property …/>元素定义,Spring会在调用无参数的构造器、创建默认的Bean实例后,调用相应的setter方法为程序注入属性值。<property…/>定义的属性值将不再有该Bean来主动设置、管理,而是接受Spring的注入。

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

测试程序:

View Row Code
1 public class BeanTest {
2     public static void main(String[] args) {
3         //创建Spring容器
4         ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");
5         //获取Chinese实例
6         Person person = ctx.getBean("chinese",Person.class);
7         person.useAxe();
8     }
9
10 }
执行上面的程序,执行结果如下:



主程序调用Person的userAxe()方法时,该方法的方法体内需要使用Axe实例,但程序没有任何地方将特定的Person实例和Axe实例耦合在一起,也就是说程序没有为Person实例传入Axe实例,Axe实例有Spring在运行期间注入。

Person实例不仅不需要了解Axe实例的具体实现,甚至无须了解Axe的创建过程。Spring容器根据配置文件的指定,创建Person实例时,不仅创建了Person的默认实例,同时也为该实例依赖注入其所依赖的Axe实例。

Bean与Bean之间的依赖关系有Spring管理,Spring采用setter方法为目标Be阿玛尼注入所依赖的Bean,这种方式被称之为设值注入。

从上面的实例我们可以看出,依赖注入以配置文件管理Bean实例之间的耦合,让Bean实例之间的耦合从代码层次分离出来。

Spring IoC容器有如下3个基本要点:

1、 应用程序的各个组件面向接口编程。面向接口编程可以将各个组件的耦合提升到接口层次,从而有利于项目后期的扩展。

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

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

二、构造注入

构造注入就是利用构造器来设置依赖关系的方式。

Japanese类:

View Row Code
1 public class Japanese implements Person{
2
3     private Axe axe;
4     //默认构造器
5     public Japanese(){
6        
7     }
8    
9     //构造注入所需的带参数构造器
10     public Japanese(Axe axe){
11         this.axe = axe;
12     }
13    
14     public void useAxe() {
15         System.out.println(axe.chop());
16     }
上面的Chinese类并没有setter方法,仅仅只是提供了一个带Axe属性的构造器,Spring将通过该构造器为Chinese注入所依赖的Bean实例。

构造注入的配置文件需要做一些修改。为了使用构造注入,使用<constructor-arg…/>元素来指定构造器的参数。如下:

View Row Code
1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3     xmlns="http://www.springframework.org/schema/beans"
4     xsi:schemaLocation="http://www.springframework.org/schema/beans
5     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
6
7     <!-- 配置Japanese实例 -->
8     <bean id="japanese" class="com.spring.service.impl.Japanese">
9         <!-- 使用构造注入 ,为Japanese实例注入SteelAxe实例-->
10         <constructor-arg ref="stoneAxe"/>
11     </bean>
12    
13     <!-- 配置stoneAxe实例 -->
14     <bean id="stoneAxe" class="com.spring.service.impl.StoneAxe" />
15 </beans>
上面的配置文件使用<contructor-arg…/>元素指定了一个构造器参数,该参数类型是Axe,这指定Spring调用Chinese类里带一个Axe参数的构造器来创建chinese实例,因为使用了有参数的构造器创建实例,所以当Bean实例被创建完成后,该Bean的依赖关系也就已经设置完成。

他的执行效果与设值注入的执行效果一样。但是还是有点却别:创建Person实例中Axe的属性时机不同—设值注入式先通过无参数的构造器创建一个Bean实例,然后调用它的setter方法注入依赖关系,而构造注入则是直接调用有参数的构造器,当Bean实例创建完成后,依赖关系也已经完成。

三、两种注入方式的对比

Spring支持两种依赖注入方式,这两种依赖注入方式并没有好坏之分,只是适合的场景有所不同。

设值注入有如下优点:

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

2、 对于复杂的依赖关系,如果采用构造注入,会导致构造器过于臃肿,难以阅读。Spring在创建Bean实例时,需要同时实例化其依赖的全部实例,因此导致性能下降。而设值注入,则可以避免这些问题。

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

但是构造器也有如下优势:

1、 构造注入可以再构造器中决定依赖关系的注入顺序,优先依赖的优先注入。

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

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

通过上面的对比。所以建议用以设值注入为主,构造注入为辅的注入策略。对于依赖关系无须变化的注入,尽量采用构造注入;而其他的依赖关系,则考虑设值注入。
分享到:
评论

相关推荐

    Spring 核心机制(依赖注入)

    ### Spring核心机制——依赖注入详解 #### 一、引言 Spring框架作为一款优秀的轻量级Java应用开发框架,其核心理念之一就是依赖注入(Dependency Injection, DI)。依赖注入不仅能够帮助开发者降低代码间的耦合度...

    详解Spring的核心机制依赖注入

    详解Spring的核心机制依赖注入 对于一般的Java项目,他们都或多或少有一种依赖型的关系,也就是由一些互相协作的对象构成的。Spring把这种互相协作的关系称为依赖关系。如A组件调用B组件的方法,可称A组件依赖于B...

    详解Spring基于Annotation的依赖注入实现

    Spring的核心特性之一就是依赖注入,它通过在运行时自动配置对象及其依赖关系,极大地简化了Java应用程序的开发过程。 ### 依赖注入(DI) 依赖注入是一种设计模式,用于减少代码之间的耦合度。在传统的编程方式中...

    Spring 控制反转 依赖注入

    **Spring 框架中的控制反转 (IoC) 和...总之,Spring的控制反转和依赖注入机制是其核心特性,它们提高了代码的可测试性、降低了耦合度,并使应用程序更加灵活。理解并熟练运用这些概念,对提升开发效率和质量至关重要。

    spring依赖注入底层详解

    Spring依赖注入是Spring框架的核心特性之一,它极大地简化了Java应用程序的开发,使得对象之间的依赖关系得以解耦,提高了代码的可测试性和可维护性。本文将深入探讨Spring依赖注入的底层实现机制。 首先,我们要...

    spring依赖注入的实现原理

    在Spring框架中,依赖注入是核心特性之一,通过控制反转(Inversion of Control,IoC)实现了组件之间的解耦。 ### 依赖注入的基本概念 依赖注入允许开发者在不修改代码的情况下,通过配置来改变对象间的依赖关系。...

    Spring 学习笔记《依赖注入》源文件

    总结来说,Spring的依赖注入机制是其核心特性之一,它极大地提升了代码的可测试性和可维护性。通过对依赖的解耦,开发者可以更专注于业务逻辑,而不是对象的创建和管理。在实际项目中,结合使用构造器和setter注入,...

    模仿Spring依赖注入

    【Spring依赖注入详解】 ...总结,Spring的依赖注入机制是其核心特性之一,它极大地提高了代码的可读性、可维护性和可测试性。理解并熟练掌握依赖注入,能够帮助开发者构建更健壮、更灵活的Java应用。

    springIOC控制反转 依赖注入实例

    在传统的程序设计中,我们通常手动创建对象并管理它们之间的依赖关系,而在Spring中,这些任务由IOC容器来处理,实现了从依赖管理到依赖注入的转变。 控制反转(IOC)意味着应用程序不再直接创建对象,而是将对象的...

    第三章 Spring4 依赖注入

    Spring4的依赖注入是其核心功能之一,通过构造器、setter方法或属性注解实现。它提高了代码的可读性、可测试性和可维护性。在实际开发中,结合注解和XML配置,可以灵活应对各种复杂的依赖关系。理解并熟练运用依赖...

    Spring学习笔记(6)----编码剖析Spring依赖注入的原理

    本篇学习笔记将深入剖析Spring依赖注入的原理,通过源码分析帮助我们理解这一核心机制。 首先,依赖注入允许我们解耦组件之间的关系,使得各个组件可以独立地进行开发、测试和维护。在Spring中,DI主要通过两种方式...

    spring依赖注入例子

    Spring框架的依赖注入(Dependency Injection,简称DI)是其核心特性之一,它使得对象之间的关系在运行时由Spring容器管理,而不是硬编码在类内部。这样可以提高代码的可测试性和可维护性,因为对象的依赖关系变得松...

    模拟Spring的依赖注入

    本篇文章将深入探讨如何通过Java代码来模拟Spring的依赖注入机制。 **依赖注入的概念** 依赖注入是一种设计模式,它允许对象在运行时获取其依赖项,而不是在构造函数或初始化方法中硬编码这些依赖项。这样做的好处...

    使用反射和注解模拟Spring的依赖注入

    在Java编程中,Spring框架是应用最广泛的IoC(Inversion of Control,控制反转)和DI...通过模拟Spring的依赖注入,开发者可以更好地领悟到IoC和DI的核心思想,从而在实际开发中更有效地利用Spring框架提供的功能。

    Spring_依赖注入_面向接口编程

    依赖注入(DI)是Spring框架的核心特性之一,它允许我们把对象的依赖关系从代码中解耦出来,转而由Spring容器来管理。在传统的编程模式中,对象通常自行创建和管理它们所依赖的对象,但在Spring中,这些依赖是由外部...

    模拟spring依赖注入

    模拟Spring的依赖注入,旨在理解其核心机制,让我们一起深入探讨这一主题。 首先,我们要明白什么是依赖注入。在传统的编程中,一个对象通常会直接创建或查找它所依赖的对象,这会导致类之间的紧密耦合。依赖注入则...

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

    Spring IoC容器的依赖注入原理是Spring框架的核心机制之一,负责将服务对象(Bean)实例化并将其提供给客户端使用。依赖注入原理可以分为两个阶段:IoC容器初始化和Bean实例化。 在IoC容器初始化阶段,主要完成的...

    Spring学习笔记(5)----依赖注入的简单实现

    在Spring框架的学习中,依赖注入(Dependency Injection,简称DI)是一个核心概念,它极大地提高了代码的可测试性和可维护性。本篇笔记将探讨Spring如何实现依赖注入,并通过实例进行详细解析。 首先,理解依赖注入...

Global site tag (gtag.js) - Google Analytics