关闭

Spring(4)-IOC-Spring的核心机制:依赖注入(面向接口)

6124人阅读 评论(1) 收藏 举报
分类:
Spring框架的核心功能有两个:
1>Spring容器作为超级大工厂,负责创建管理所有的java对象,这些java对象被称为Bean;
2>Spring容器管理容器中Bean之间的依赖关系,Spring使用一种被称为依赖注的方式来管理Bean之间的依赖关系;
一,依赖注入
A对象调用B对象,在传统模式下有如下两种做法:
1>原始做法:调用者主动创建被依赖对象,然后在调用被依赖对象的方法;
2>简单工厂模式:调用者先找到被依赖对象的工厂,然后主动通过工厂去获取被依赖对象,最后在调用被依赖对象的方法;
对于简单工厂方式,大致需要把握三点:
1>将被依赖对象的创建交给工厂完成;
2>调用者面向被依赖对象的接口编程;
3>调用者通过工厂来获得被依赖的组件;
通过这三点改造,可以保证调用者只须与被依赖对象的接口耦合,这就避免了类层次的硬编码耦合,但是缺点是调用者组件需要主动通过工厂去获取被依赖对象,这就会带来调用组件与被依赖对象工厂的耦合;
依赖注入通常有如下两种:
1>设值注入:IoC容器使用成员变量的setter方法来注入被依赖对象;
2>构造注入:IoC容器使用构造器来注入被依赖对象;
1,设值注入:
Spring推荐面向接口编程,这样可以更好的让规范和实现分离,从而提供更好的解耦,对于一个JavEE应用,不管是DAO组件,还是业务逻辑组件,都应该先定义一个接口,该接口定义了该组件应该实现的功能,但功能的实现则由其实现类提供,以便于后期的升级和维护,下面的示例更加规范:
<span style="font-size:18px;">package com.anlw.service;

public interface Person {
    //定义一个使用斧头的方法
    public void useAxe();
}</span>

<span style="font-size:18px;">package com.anlw.service;

public interface Axe {
    //Axe接口定义一个chop()的方法
    public String chop();
}</span>

<span style="font-size:18px;">package com.anlw.service.impl;

import com.anlw.service.Axe;

public class StoneAxe implements Axe {

    @Override
    public String chop() {
        // TODO Auto-generated method stub
        return "斧头砍柴好慢~";
    }
}</span>

<span style="font-size:18px;">package com.anlw.service.impl;

import com.anlw.service.Axe;
import com.anlw.service.Person;

public class Chinese implements Person {
    private Axe axe;
    //设值注入所需的setter方法
    public void setAxe(Axe axe){
        this.axe = axe;
    }
    //实现Perosn接口的useAxe()方法
    @Override
    public void useAxe() {
        //调用axe的chop()方法
        //表明Person对象依赖axe对象
        System.out.println(axe.chop());
    }
}</span>

<span style="font-size:18px;"><?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.xsd">

    <!--配置chinese实例,其实现类是Chinese类 -->
    <bean id="chinese" class="com.anlw.service.impl.Chinese">
        <!--驱动调用chinese的setAxe方法将容器中的stoneAxe作为参数传入 -->
        <property name="axe" ref="stoneAxe"></property>
    </bean>
    <!--配置stoneAxe实例,其实现类是StoneAxe  -->
    <bean id="stoneAxe" class="com.anlw.service.impl.StoneAxe"></bean>
</beans></span>

Spring配置文件配置bean实例通常会指定两个属性:
1>id:指定该Bean的唯一标识,Spring会根据id属性值来管理bean,程序通过id属性值来访问该bean实例;
2>class:指定该bean的实现类,此处不可再用接口,必须使用实现类,Spring容器会根据xml解析器读取该属性值,并利用反射来创建该实现类的实例;
测试方法:

<span style="font-size:18px;">import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.anlw.service.Person;
import com.anlw.service.impl.Chinese;

public class Test {
    public static void main(String[] args) {
        //创建Spring容器
        ApplicationContext  ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //下面两个是重载方法,获取id为person的Bean
        Person c = (Person) ctx.getBean("chinese");
        //Person c = ctx.getBean("chinese", Person.class);
        //调用方法
        c.useAxe();
    }
}</span>

Spring IoC容器的三个基本要点:
1>应用程序的各组件面向接口编程。面向接口编程可以将组件之间的耦合关系提升到接口层次,从而有利于项目后期的扩展;
2>应用程序的各组件不再由程序主动创建,而是由Spring容器负责产生并初始化;
3>Spring采用配置文件或注解来管理bean的实现类、依赖关系,Spring容器则根据配置文件或注解,利用反射来创建实例,并为之注入依赖关系;


2,构造注入:
通过setter方法为目标bean注入依赖关系的方式被称为设值注入,另外还有一种注入方式,这种方式在构造实例时,已经为其完成了依赖关系的初始化,这种利用构造器来设置依赖关系的方式,被称为构造注入;
<bean>元素总是默认驱动Spring调用无参构造器来创建对象,那怎么驱动Spring调用有参构造器去创建对象呢?答案是<constructor-arg>子元素,每个<constructor-arg>子元素代表一个构造器参数,如果<bean>元素包含N个<constructor-arg>子元素,就会驱动Spring调用带N个参数定的构造器来创建对象;
对上面的设值注入的示例做两步更改:
1>

<span style="font-size:18px;">package com.anlw.service.impl;

import com.anlw.service.Axe;
import com.anlw.service.Person;

public class Chinese implements Person {
    private Axe axe;
    //构造注入所需的带参数的构造器
    public Chinese(Axe axe){
        this.axe = axe;
    }
    //实现Perosn接口的useAxe()方法
    @Override
    public void useAxe() {
        //调用axe的chop()方法
        //表明Person对象依赖axe对象
        System.out.println(axe.chop());
    }
}</span>

2>

<span style="font-size:18px;"><?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.xsd">

    <!--配置chinese实例,其实现类是Chinese类 -->
    <bean id="chinese" class="com.anlw.service.impl.Chinese">
        <!--下面只有一个Chinese子元素驱动Spring调用Chinese带一个参数的构造器来创建对象 -->
        <constructor-arg ref="stoneAxe"></constructor-arg>
    </bean>
    <!--配置stoneAxe实例,其实现类是StoneAxe  -->
    <bean id="stoneAxe" class="com.anlw.service.impl.StoneAxe"></bean>
</beans></span>

上面是构造注入的示例;
其反射代码如下:

<span style="font-size:18px;">String idStr = "chinese";//解析<bean>元素得到id属性值为chinese
String refStr = "stoneAxe";//解析<constructor-arg>元素得到的ref属性值为stoneAxre
Object paramBean = container.get("refStr");
//Spring会用反射的方式执行下面的代码,此处为了降低阅读难度,该行代码没有使用反射
Object obj = new com.anlw.service.impl.Chinese(paramBean);
//container代表Spring容器
container.put(idStr,obj);</span>

由此可以看出,使用了有参构造器创建实例,当Bean实例被创建完成后,该Bean的依赖关系已经设置完成,与设值注入的区别在于:创建Person实例中Axe属性的时机不同,设置注入是先通过无参数的构造器创建一个Bean实例,然后调用对应的setter方法注入依赖关系;而构造注入则直接调用有参构造器,当bean实例创建完成后,已经完成了依赖关系的注入;
配置<constructor-arg>元素时可以指定一个index属性,用于指定该构造参数值将作为第几个构造参数值,例如index="0"表明该构造参数值将作为第一个构造参数值;

注意几点:
1>
如果配置文件为:
<!-- 定义名为bean1的Bean,对应的实现类是lee.Test1-->
<bean id="bean1" class="lee.Test1">
    <constructor-arg value="hello"/>
    <constructor-arg value="23"/>
</bean>
上面的粗体字代码相当于让Spring调用如下代码:(Spring底层用反射执行该代码)
Object bean1 = new lee.Test("hello","23");
由于Spring本身提供了功能强大的类型转换机制,因此如果lee.Test1只包含一个Test1(String,int)构造器,那么上面配置文件相当于让Spring执行如下代码:(Spring底层用反射执行该代码)
Object bean1 = new lee.Test("hello",23);
那么如果lee.Test1既含有Test1(String,int)构造器,又含有Test1(String,String)构造器,肯定指定Test1(String,String)这个,因为23毕竟是字符串,正确匹配;
为了明确指定数据类型,Spring为<constructor-arg>元素指定了一个type属性,例如<constructor-arg value="23" type="int"/>

两种注入方式的对比:
相比之下,设值注入有如下优点;
1>与传统的JavaBean的写法更相似,程序开发人员更容易理解,接受,通过setter方法设定依赖关系显得更加直观,自然;
2>对于复杂的依赖关系,如果采用构造注入,会导致构造器非常臃肿,难以阅读,Spring在创建Bean实例时,需要同时实例化其依赖的全部实例,因而导致性能下降,而使用设置注入则能避免这些问题;
3>尤其在某些成员变量可选的情况下,多参数的构造器更加笨重;

某些特定的场景下,构造注入有如下优势:
1>构造注入可以在构造器中决定依赖关系的注入顺序,优先依赖的优先注入,例如组件中其他依赖关系的注入,常常需要依赖DataSource的注入。采用构造注入,可以在代码中清晰的决定注入顺序;
2>对于依赖关系无需变化的Bean,构造注入更有用处,因为没有setter方法,所有的依赖关系全部在构造器内设定,因此无需担心后续的代码对依赖关系产生破环;
3>依赖关系只能在构造器中设定,则只有组件的创建者才能改变组件的依赖关系,对组件的调用者而言,组件内部的依赖关系完全透明,更符合高内聚的原则;
建议采用以设值注入为主,构造注入为辅的注入策略;
对于依赖关系无需变化的注入,尽量采用构造注入;
而其他依赖关系的注入,则考虑采用设值注入;




0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:37549次
    • 积分:595
    • 等级:
    • 排名:千里之外
    • 原创:25篇
    • 转载:0篇
    • 译文:0篇
    • 评论:5条
    文章分类
    最新评论