Spring 的注入

一、注入（Injection）

1、什么是注入

所谓的注入，指的就是，通过 Spring 的工厂及配置文件为所创建对象的成员变量赋值

（1）为什么需要注入

我们原来对一个对象的变量进行赋值使用的是 get 和 set 的方法来完成的：

但是需要注意的是，此时我们所完成的赋值，是我们通过代码来完成的，并不是我们所说的注入

注入指的是通过 Spring 的配置文件对成员变量进行赋值

我们直接通过 set 来进行赋值的效果，是可以达到预期的，但是它并不好

因为它存在耦合，主要体现在

比如，日后如果这个名字不想叫馒头警告了，想叫别的名字，那么这个名字得在代码中更改，实际上这个名字在更改的过程中，就存在耦合了因为改代码涉及到重新编译，重新输出

（2）如何进行注入

1、类的成员变量提供 set，get 方法

2、 配置 Spring 的配置文件

配置文件之前，得先有对应的 get 和 set 方法！！！

此时，就完成了通过配置文件给 id 属性和 name 属性的赋值

2、Spring 注入原理分析（简易版）

Spring 通过底层调用对象属性对应的 set 方法来完成成员变量的赋值，这种方式我们也称之为 set 注入

二、Set 注入详解

成员变量的类型，有很多种，我们之前讲的是针对 int 和 String 类型的，所以标签使用的是 value

那如果类型变成了别的呢？比如：double ，char ，List.....

此时 <property> 里面的标签可能就要发生改变了，因为它可能是一个集合，也可能是一个数组，甚至还有可能是一个我们自己定义的类型....

针对于不同类型的成员变量，我们在 <property> 标签中，需要嵌套其它标签

<property>
 xxxxx
</property>

针对不同类型的成员变量，它有两种分类，一种叫做 JDK 类型的变量，也就是 java 原生的成员变量，另一种叫做 用户自定义类型 ，也就是我们自己提供的变量类型

那么接下来，我们就要针对这些不同的类型，来学习在 set 注入过程当中我们应该在 <property> 标签中嵌套什么标签来对对应的变量类型进行赋值

1、JDK 内置类型

（1）String + 8种基本类型

这里所嵌套的标签也就是我们之前所讲的 value 标签

<value>suns</value>

（2）数组

如果现在有一个 数组 类型的成员变量又该如何赋值呢？

        <property name="emails">
            <list>
                <value>[email protected]</value>
            </list>
        </property>

（3）Set 集合

当变量类型为 Set 集合时：

       <property name="tels">
                <set>
                    <value>1381111</value>
                    <value>1391111</value>
                    <value>1661111</value>
                </set>
        </property>

这个时候，实际上就是为 set 集合赋值三个元素，因为 set 集合是无序的，所以我们所赋值的这三个元素，虽然我们按照顺序来进行赋值，但是未来在遍历的时候，它有可能不按照这个顺序进行注入

如果此时，这里有一个重复性的数据

比如这个手机号出现了三次，那么按照 set 集合的语义，它会帮我们把重复的数据过滤掉，最终实际上 set 集合在输出的时候，还是之前那三个元素的部分，后面重复的号码被自动过滤掉了

注意：Set 集合中的 Set 标签是固定的，但是里面嵌套的 value 标签却是不一定的

我们此时在 set 里面嵌套的是 value 标签是因为我们定义的泛型是 String ，而 String 是应该用 value，所以我们现在之所以能够嵌套 value 标签使用，原因在于 Person 当中 Set 的泛型是 String 的

（4）List 集合

当类型为 list 时：

List 集合所使用的 list 标签和我们刚才学的数组一样，都是 list 标签

        <property name="adresses">
            <list>
                <value>shengzhen</value>
                <value>beijing</value>
                <value>shanghai</value>
            </list>
        </property>

List 集合是有序的！！！

所以我们在这里按照这个顺序进行赋值，那么最后 List 集合进行遍历的时候，也一定会按照这个集合进行输出

List 集合是可以重复的！！！

所以即便有三个一样的元素，那么最后输出的时候，这三个元素都会进行输出

和 Set 集合相同的是，我们之所以能在 list 里面嵌套 value 标签，是因为此时我们的泛型是 String 类型的

（5）Map 集合

当类型是 Map 类型时：

我们之前学习 Map 的时候，就已经学习到：Map 是由键值对组成的，那么作为 map 来讲，这个键值对应该封装成一个对象，这个对象我们在之前的学习内容中就已经接触过了：Map.entry

一个 entry ，封装的就是一个键值对

        <property name="qqs">
            <map>
                <entry>
                    <key>
                        <value>123</value>
                    </key>
                    <value>12415513</value>
                </entry>
            </map>
        </property>

注意：此时在 key 中嵌套 value 也是因为此时的泛型是 String 类型的

同样的，因 为 值 的泛型也是 String，所以后面使用的也是 value

（6）properties

Properties类型 是一个 特殊的Map 特殊的地方在于：key=String value=String

        <property name="p">
            <props>
                <prop key="key1">value1</prop>
                <prop key="key2">value2</prop>
            </props>
        </property>

** 这里的每一个 prop 都对应了一个键值对**

（7）复杂的 JDK 类型

需要程序员自定义类型转换器，进行处理

2、用户自定义类型

第一种方式：

1、为成员变量提供 set ，get 方法

**2、 在配置文件中进行注入（赋值） **

     <bean id="userService" class="UserServiceImpl">
       <property name="userDAO">
           <bean class="UserDAOImpl"/>
       </property>
    </bean>

第二种方式：

第一种方式存在的一些问题：

1、配置文件代码冗余

2、被注入的对象（userDAO）被多次创建，浪费（JVM）内存资源

第二种方式的步骤与之前一样：

1、为成员变量提供 get ，set 方法

2、配置文件中进行配置（这里有区别）

先创建 userDAO 对象，再来创建 userService 对象，然后<ref bean 引用 userDAO 对象

<bean id="userDAO" class="xxx.UserDAOImpl"/></bean>

<bean id="userService" class="xxx.UserServiceImpl">
     <property name="userDAO">
          <ref bean="userDAO"/>
     </property> 
</bean>

<bean id="orderService" class="xxx.OrderServiceImpl">
     <property name="userDAO">
          <ref bean="userDAO"/>
     </property> 
</bean>

#Spring4.x 废除了 <ref local=""/> 基本等效 <ref bean=""/>

userDAO 被多个引用，解决了代码冗余的问题，同时自始至终只用了一个 bean 标签，创建了一个 DAO 对象，也解决了内存资源浪费的问题

3、Set 注入的简化写法

（1）基于属性简化

JDK类型注⼊
<property name="name">
 <value>suns</value>
</property>
<property name="name" value="suns"/>

注意：value属性 只能简化 8种基本类型+String 注⼊标签

⽤户⾃定义类型
<property name="userDAO">
 <ref bean="userDAO"/>
</property>
<property name="userDAO" ref="userDAO"/>

（2）基于 p 命名空间简化

JDK类型注⼊
<bean id="person" class="xxxx.Person">
     <property name="name">
         <value>suns</value>
     </property>
</bean>

<bean id="person" class="xxx.Person" p:name="suns"/>

注意：value属性 只能简化 8种基本类型+String 注⼊标签

⽤户⾃定义类型
<bean id="userService" class="xx.UserServiceImpl">
     <property name="userDAO">
         <ref bean="userDAO"/>
     </property>
</bean>

<bean id="userService" class="xxx.UserServiceImpl" p:userDAO-ref="userDAO"/>

三、构造注入

注入：通过 Spring 的配置文件为成员变量赋值

Set 注入：Spring 调用 Set 方法，通过配置文件为成员变量赋值

构造注入：Spring 调用构造方法，为成员变量赋值

1、开发步骤

（1）提供有参构造方法

因为我们得通过有参的构造方法来为对应的成员变量进行赋值

（2）提供Spring 的配置文件进行配置

一个 <constructor-arg> 标签，对应一个构造方法中的构造参数，个数以及顺序和构造参数的顺序是一样的

2、构造方法重载

当构造方法发生了重载之后，我们要如何进行注入呢？

构造方法重载：方法名一样，但是参数表不 同

而所谓的参数表不同指的是参数的类型不同，参数的个数不同，参数的顺序不同，那么一旦构造方法发生重载，我们在注入的时候又要注意哪些细节呢？

（1）参数个数不同

**通过控制 <constructor-arg> 标签的数量来进行区分 **

    <bean id="customer2" class = "Constructor.customer">
        <constructor-arg>
            <value>xiaohei</value>
        </constructor-arg>
    </bean>

（2）构造参数个数相同时

然后，我们再对 age 进行实验：

    <bean id="customer" class = "Constructor.Customer">
        <constructor-arg>
            <value>18</value>
        </constructor-arg>
    </bean>

此时就发现了一个问题：这个 18 并没有给 age 赋值，而是给 name 赋值了

这是因为 Spring 优先选择了上面的构造方法进行使用

那么如何解决这个方法呢？

name 和 age 最大的区别就是类型不同，所以这个时候我们要额外进行一个限定：指定类型

在 <constructor-arg> 后面新增一个属性，叫做 type

此时就能解决问题了

3、注入总结

在未来写项目的时候，是使用 Set 注入更多还是 构造注入 更多呢？

使用 Set 注入更多

1、构造注入比较麻烦（存在重载的问题）

2、Spring 框架底层，大量应用了 set 注入

综上，在未来，set 注入使用的更多

四、反转控制 与 依赖注入

1、反转控制（IoC Inverse of Control）

控制：对于成员变量赋值的控制权

反转控制：把对于成员变量赋值的控制权，从代码中转移到 Spring 的工厂和配置文件中完成

优点：解耦合

底层实现：工厂设计模式

2、依赖注入(Dependency Injection DI)

注入：通过 Spring 的工厂及配置文件为对象（Bean / 组件）的成员变量赋值

依赖：当一个类需要另一个类的时候，就意味着依赖，一旦出现依赖，就可以把另一个类作为本类的成员变量，最终通过 Spring 进行注入（赋值）