4.spring的di的配置使用

最新推荐文章于 2020-03-08 00:05:20 发布

anjunshuangChina

最新推荐文章于 2020-03-08 00:05:20 发布

阅读量270

点赞数 2

分类专栏： spring 文章标签： spring di配置使用

原文链接：http://sishuok.com/forum/posts/list/2447.html

版权

spring 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1.依赖和依赖注入

传统的应用程序设计中所说的依赖一般指类与类之间的关系

泛化：表示类与类之间的继承关系，接口与接口之间的继承关系。

实现：类对接口的实现。

依赖：当类与类之间有使用关系时，就属于依赖关系，不同于关联关系，依赖不具有拥有关系，而是一种相识关系，只在某个特定地方（比如某个方法体内）才有关系。

关联：表示类与类活类与接口之间的依赖关系，表现了拥有关系，具体到代码可以用实例变量来表示。

聚合：属于关联的特殊情况，体现部分-整体关系，是一种弱拥有关系，整体和部分可以有不一样的生命周期，是一种弱关联。

组合：属于是关联的特殊情况，也体现了体现部分-整体关系，是一种强“拥有关系”；整体与部分有相同的生命周期，是一种强关联；

Spring IoC容器的依赖有两层含义：Bean依赖容器和容器注入Bean的依赖资源：

Bean依赖容器：也就是说Bean要依赖于容器，这里的依赖是指容器负责创建Bean并管理Bean的生命周期，正是由于由容器来控制创建Bean并注入依赖，也就是控制权被反转了，这也正是IoC名字的由来，此处的有依赖是指Bean和容器之间的依赖关系。

容器注入Bean的依赖资源：容器负责注入Bean的依赖资源，依赖资源可以是Bean、外部文件、常量数据等，在Java中都反映为对象，并且由容器负责组装Bean之间的依赖关系，此处的依赖是指Bean之间的依赖关系，可以认为是传统类与类之间的“关联”、“聚合”、“组合”关系。

为什么要应用依赖注入，应用依赖注入能给我们带来哪些好处呢？

动态替换Bean依赖对象，程序更灵活：替换Bean依赖对象，无需修改源文件：应用依赖注入后，由于可以采用配置文件方式实现，从而能随时动态的替换Bean的依赖对象，无需修改java源文件；

更好实践面向接口编程，代码更清晰：在Bean中只需指定依赖对象的接口，接口定义依赖对象完成的功能，通过容器注入依赖实现；

更好实践优先使用对象组合，而不是类继承：因为IoC容器采用注入依赖，也就是组合对象，从而更好的实践对象组合。

采用对象组合，Bean的功能可能由几个依赖Bean的功能组合而成，其Bean本身可能只提供少许功能或根本无任何功能，全部委托给依赖Bean，对象组合具有动态性，能更方便的替换掉依赖Bean，从而改变Bean功能；
而如果采用类继承，Bean没有依赖Bean，而是采用继承方式添加新功能，，而且功能是在编译时就确定了，不具有动态性，而且采用类继承导致Bean与子Bean之间高度耦合，难以复用。

增加Bean可复用性：依赖于对象组合，Bean更可复用且复用更简单；

降低Bean之间耦合：由于我们完全采用面向接口编程，在代码中没有直接引用Bean依赖实现，全部引用接口，而且不会出现显示的创建依赖对象代码，而且这些依赖是由容器来注入，很容易替换依赖实现类，从而降低Bean与依赖之间耦合；

代码结构更清晰：要应用依赖注入，代码结构要按照规约方式进行书写，从而更好的应用一些最佳实践，因此代码结构更清晰。

从以上我们可以看出，其实依赖注入只是一种装配对象的手段，设计的类结构才是基础，如果设计的类结构不支持依赖注入，Spring IoC容器也注入不了任何东西，从而从根本上说“如何设计好类结构才是关键，依赖注入只是一种装配对象手段”。

前边IoC一章我们已经了解了Bean依赖容器，那容器如何注入Bean的依赖资源，Spring IoC容器注入依赖资源主要有以下两种基本实现方式：

构造器注入：就是容器实例化Bean时注入那些依赖，通过在在Bean定义中指定构造器参数进行注入依赖，包括实例工厂方法参数注入依赖，但静态工厂方法参数不允许注入依赖；

setter注入：通过setter方法进行注入依赖；

方法注入：能通过配置方式替换掉Bean方法，也就是通过配置改变Bean方法功能。

2.构造器注入

使用构造器注入通过配置构造器参数实现，构造器参数就是依赖。除了构造器方式，还有静态工厂、实例工厂方法可以进行构造器注入。

2.1实例化

构造器注入可以根据参数索引注入、参数类型注入或Spring3支持的参数名注入，但参数名注入是有限制的，需要使用在编译程序时打开调试模式（即在编译时使用“javac –g:vars”在class文件中生成变量调试信息，默认是不包含变量调试信息的，从而能获取参数名字，否则获取不到参数名字）或在构造器上使用@ConstructorProperties（java.beans.ConstructorProperties）注解来指定参数名。

public class HelloImpl3 implements HelloApi{
    private String message;
    private int index;

    public HelloImpl3(){}

    public HelloImpl3(int index, String message){
        this.index = index;
        this.message = message;
    }

    @Override
    public void sayHello() {
        System.out.println("index:" + index + " message:" + message);
    }
}

    <!-- 通过构造器参数索引方式依赖注入 -->
    <bean id="byIndex" class="com.anjunshuang.spring.di.HelloImpl3">
        <constructor-arg index="0" value="1"/>
        <constructor-arg index="1" value="Hello World! byIndex"/>
    </bean>
    <!-- 通过构造器参数类型方式依赖注入 -->
    <bean id="byType" class="com.anjunshuang.spring.di.HelloImpl3">
        <constructor-arg type="java.lang.String" value="Hello World! byType"/>
        <constructor-arg type="int" value="2"/>
    </bean>
    <!-- 通过构造器参数名称方式依赖注入 -->
    <bean id="byName" class="com.anjunshuang.spring.di.HelloImpl3">
        <constructor-arg name="message" value="Hello World! byName"/>
        <constructor-arg name="index" value="3"/>
    </bean>

public class HelloImpl3Test {

    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring/constructorDependencyInject.xml");
        HelloApi helloApi1 = context.getBean("byIndex", HelloApi.class);
        helloApi1.sayHello();

        HelloApi helloApi2 = context.getBean("byType", HelloApi.class);
        helloApi2.sayHello();

        HelloApi helloApi3 = context.getBean("byName", HelloApi.class);
        helloApi3.sayHello();
    }
}

3.静态工厂注入和动态工厂注入

省略：iioc中已有一样的例子

4.setter注入

setter注入，是通过在通过构造器、静态工厂或实例工厂实例好Bean后，通过调用Bean类的setter方法进行注入依赖。

setter注入方式只有一种根据setter名字进行注入

setter方法注入的约定

JavaBean：是本质就是一个POJO类，但具有一下限制：

该类必须要有公共的无参构造器，如public HelloImpl4() {}；

属性为private访问级别，不建议public，如private String message;

属性必要时通过一组setter（修改器）和getter（访问器）方法来访问；

setter方法，以“set” 开头，后跟首字母大写的属性名，如“setMesssage”,简单属性一般只有一个方法参数，方法返回值通常为“void”;

getter方法，一般属性以“get”开头，对于boolean类型一般以“is”开头，后跟首字母大写的属性名，如“getMesssage”，“isOk”；

还有一些其他特殊情况，比如属性有连续两个大写字母开头，如“URL”,则setter/getter方法为：“setURL”和“getURL”，其他一些特殊情况请参看“Java Bean”命名规范。

setter和构造方法只是配置文件中使用的标签略有区别吗？

5.注入Bean Id

用于注入Bean的ID，ID是一个常量不是引用，且类似于注入常量，但提供错误验证功能，配置方式如下所示：

<property name="id"><idref bean="bean1"/></property>
<property name="id"><idref local="bean2"/></property>

第二种方式（<idref bean="bean1"/>）可以在容器初始化时校验被引用的Bean是否存在，如果不存在将抛出异常，而第一种方式（<idref local="bean2"/>）只有在Bean实际使用时才能发现传入的Bean的ID是否正确，可能发生不可预料的错误。因此如果想注入Bean的ID，推荐使用第二种方式。

6.注入集合、数组和字典

Spring不仅能注入简单类型数据，还能注入集合（Collection、无序集合Set、有序集合List）类型、数组(Array)类型、字典(Map)类型数据、Properties类型数据，接下来就让我们一个个看看如何注入这些数据类型的数据。

set和list雷同；只是标签不同而已

public class ListTestBean {

    private List<String> values;

    public List<String> getValues() {
        return values;
    }

    public void setValues(List<String> values) {
        this.values = values;
    }
}

    <bean id="listBean" class="com.anjunshuang.spring.di.ListTestBean">
        <property name="values">
            <list>
                <value>1</value>
                <value>2</value>
                <value>3</value>
                <value>4</value>
                <value>5</value>
                <value>6</value>
                <value>7</value>
            </list>
        </property>
    </bean>

public class ListTestBeanTest {

    public static void main(String[] args) {
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("spring/listInject.xml");
        ListTestBean listBean = beanFactory.getBean("listBean", ListTestBean.class);
        for (String str:listBean.getValues()) {
            System.out.println(str);
        }
    }
}

注入数组类型

public class ArrayTestBean {

    private String[] array1;
    private String[][] array2;

    public String[] getArray1() {
        return array1;
    }

    public void setArray1(String[] array1) {
        this.array1 = array1;
    }

    public String[][] getArray2() {
        return array2;
    }

    public void setArray2(String[][] array2) {
        this.array2 = array2;
    }
}

    <!--一维数组-->
    <bean id="array1" class="com.anjunshuang.spring.di.ArrayTestBean">
        <property name="array1">
            <array value-type="java.lang.String" merge="default">
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </array>
        </property>
    </bean>

    <!--二维数组-->
    <bean id="array2" class="com.anjunshuang.spring.di.ArrayTestBean">
        <property name="array2">
            <array>
                <array value-type="java.lang.String" merge="default">
                    <value>1</value>
                    <value>2</value>
                    <value>3</value>
                </array>
                <array value-type="java.lang.String" merge="default">
                    <value>a</value>
                    <value>b</value>
                    <value>c</value>
                </array>
            </array>
        </property>
    </bean>

public class ArrayTestBeanTest {

    public static void main(String[] args) {
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("spring/ArrayInject.xml");
        ArrayTestBean array1 = beanFactory.getBean("array1", ArrayTestBean.class);
        System.out.println("一维数组...");
        System.out.println(Arrays.toString(array1.getArray1()));
        System.out.println(Arrays.deepToString(array1.getArray1()));

        System.out.println("二维数组...");
        ArrayTestBean array2 = beanFactory.getBean("array2", ArrayTestBean.class);
        System.out.println(Arrays.toString(array2.getArray2()));
        System.out.println(Arrays.deepToString(array2.getArray2()));

        //遍历必不可少
        for (String[] strA:array2.getArray2()) {
            for (String str : strA) {
                System.out.println(str);
            }
        }
    }
}

注入字典（map）类型

字典类型是包含键值对数据的数据结构，需要使用<map>标签来配置注入，其属性“key-type”和“value-type”分别指定“键”和“值”的数据类型，其含义和<list>标签的“value-type”含义一样，在此就不罗嗦了，并使用<key>子标签来指定键数据，<value>子标签来指定键对应的值数据

例子：省略...

Properties注入

Spring能注入java.util.Properties类型数据，需要使用<props>标签来配置注入，键和值类型必须是String，不能变，子标签<prop key=”键”>值</prop>来指定键值对

public class PropertiesTestBean {

    private Properties values;

    public Properties getValues() {
        return values;
    }

    public void setValues(Properties values) {
        this.values = values;
    }
}

    <bean id="propertiesBean1" class="com.anjunshuang.spring.di.PropertiesTestBean">
        <property name="values">
            <props value-type="java.lang.String" merge="default">
                <prop key="1">less</prop>
                <prop key="2">2</prop>
            </props>
        </property>
    </bean>

    <!--两种不同的配置关系，可用多种符号进行分隔-->
    <bean id="propertiesBean2" class="com.anjunshuang.spring.di.PropertiesTestBean">
        <property name="values">
            <value>
                1 = 11
                2 = 22;
                3 = 33,
                4 = 44
            </value>
        </property>
    </bean>

public class PropertiesTestBeanTest {

    public static void main(String[] args) {
        BeanFactory beanFactory = new ClassPathXmlApplicationContext("spring/propertiesInject.xml");
        PropertiesTestBean propertiesBean1 = beanFactory.getBean("propertiesBean1", PropertiesTestBean.class);
        System.out.println(propertiesBean1.getValues().getProperty("1"));

        PropertiesTestBean propertiesBean2 = beanFactory.getBean("propertiesBean2", PropertiesTestBean.class);
        System.out.println(propertiesBean2.getValues().getProperty("3"));

//        遍历必须可少
        for(String key:propertiesBean2.getValues().stringPropertyNames()){
            System.out.println(propertiesBean2.getValues().getProperty(key));
        }
    }
}

7.配置Bean之间的依赖关系，引用其他Bean

引用其他Bean的步骤与注入常量的步骤一样，可以通过构造器注入及setter注入引用其他Bean，只是引用其他Bean的注入配置稍微变化了一下：可以将“<constructor-arg index="0" value="Hello World!"/>”和“<property name="message" value="Hello World!"/>”中的value属性替换成bean属性，其中bean属性指定配置文件中的其他Bean的id或别名。另一种是把<value>标签替换为<.ref bean=”beanName”>，bean属性也是指定配置文件中的其他Bean的id或别名。

8.其他引用方式

除了最基本配置方式以外，Spring还提供了另外两种更高级的配置方式，<ref local=””/>和<ref parent=””/>：

（1）<ref local=””/>配置方式：用于引用通过<bean id=”beanName”>方式中通过id属性指定的Bean，它能利用XML解析器的验证功能在读取配置文件时来验证引用的Bean是否存在。因此如果在当前配置文件中有相互引用的Bean可以采用<ref local>方式从而如果配置错误能在开发调试时就发现错误。

如果引用一个在当前配置文件中不存在的Bean将抛出如下异常：

org.springframework.beans.factory.xml.XmlBeanDefinitionStoreException: Line21 inXML document from class path resource [chapter3/beanInject2.xml] is invalid; nested exception is org.xml.sax.SAXParseException: cvc-id.1: There is no ID/IDREF binding for IDREF 'helloApi'.

<ref local>具体配置方式如下：

（2）<ref parent=””/>配置方式：用于引用父容器中的Bean，不会引用当前容器中的Bean，当然父容器中的Bean和当前容器的Bean是可以重名的，获取顺序是先查找当前容器中的Bean，如果找不到再从父容器找。具体配置方式如下：

    <!-- spring/parentBeanInject.xml表示父容器配置-->
    <!--注意此处可能子容器也定义一个该Bean-->
    <bean id="helloApi" class="com.anjunshuang.spring.di.HelloImpl4">
        <property name="index" value="1"/>
        <property name="message" value="Hello Parent!"/>
    </bean>

    <!-- spring/localBeanInject.xml表示当前容器配置-->
    <!-- 注意父容器中也定义了id 为 helloApi的Bean -->
    <bean id="helloApi" class="com.anjunshuang.spring.di.HelloImpl4">
        <property name="index" value="1"/>
        <property name="message" value="Hello Local!"/>
    </bean>

    <!-- 通过local注入 4.x版本已废弃<ref local="helloApi"/>-->
    <bean id="bean1" class="com.anjunshuang.spring.di.HelloApiDecorator">
        <constructor-arg index="0" ref="helloApi"></constructor-arg>
    </bean>

    <!-- 通过parent注入 -->
    <bean id="bean2" class="com.anjunshuang.spring.di.HelloApiDecorator">
        <property name="helloApi"><ref parent="helloApi"></ref></property>
    </bean>

public class LocalAndparentBeanInjectTest {

    public static void main(String[] args) {
        //初始化父容器
        ApplicationContext parentBeanContext = new ClassPathXmlApplicationContext("spring/parentBeanInject.xml");
        //初始化当前容器
        ApplicationContext beanContext = new ClassPathXmlApplicationContext(new String[] {"spring/localBeanInject.xml"}, parentBeanContext);
        HelloApi bean1 = beanContext.getBean("bean1", HelloApi.class);
        bean1.sayHello();//该Bean引用local bean
        HelloApi bean2 = beanContext.getBean("bean2", HelloApi.class);
        bean2.sayHello();//该Bean引用parent bean
    }
}

8.内部Bean定义

内部Bean就是在<property>或<constructor-arg>内通过<bean>标签定义的Bean，该Bean不管是否指定id或name，该Bean都会有唯一的匿名标识符，而且不能指定别名，该内部Bean对其他外部Bean不可见。

废什么话呀，例子搞起

    <bean id="bean" class="com.anjunshuang.spring.di.HelloApiDecorator">
        <property name="helloApi">
            <bean id="helloApi" class="com.anjunshuang.spring.ioc.HelloImpl"/>
        </property>
    </bean>

public class InnerBeanInjectTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring/innerBeanInject.xml");
        HelloApi bean = context.getBean("bean", HelloApi.class);
        bean.sayHello();
    }
}

anjunshuangChina

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
4.spring的di的配置使用

1.依赖和依赖注入传统的应用程序设计中所说的依赖一般指类与类之间的关系泛化：表示类与类之间的继承关系，接口与接口之间的继承关系。实现：类对接口的实现。依赖：当类与类之间有使用关系时，就属于依赖关系，不同于关联关系，依赖不具有拥有关系，而是一种相识关系，只在某个特定地方（比如某个方法体内）才有关系。关联：表示类与类活类与接口之间的依赖关系，表现了拥有关系，具体到代码可以用实例变量...
复制链接

扫一扫