Spring第六篇：依赖的手动注入

　　主要内容：

1. 构造器注入的3种方式详解

2. set方法注入详解

3. 注入容器中的其他bean的2种方式

4. 其他常见类型注入详解

　　构造函数的方式和set属性的方式，spring中也是通过这两种方式实现注入的。

　　一、通过构造器注入：构造器的参数就是被依赖的对象

　　1、根据构造器参数索引注入：

<bean id="diByConstructorParamIndex" class="类型全路径名称">
    <constructor-arg index="0" value="111"/>
    <constructor-arg index="1" value="222"/>
</bean>

　　参数位置的注入对参数顺序有很强的依赖性，若构造函数参数位置被人调整过，会导致注入出错。

　　不过通常情况下，不建议去在代码中修改构造函数，如果需要新增参数的，可以新增一个构造函数来实现，这算是一种扩展，不会影响目前已有的功能。

　　2、根据构造器参数类型注入：

<bean id="diByConstructorParamType" class="类型全路径名称"> 
　　　<constructor-arg type="参数类型" value="参数值"/> 
　　　<constructor-arg type="参数类型" value="参数值"/> 
</bean>

　　按照参数位置或者按照参数的类型注入，都有一个问题，很难通过bean的配置文件，知道这个参数是对应实体类中的那个属性的，代码的可读性不好。

　　3、根据构造器参数名称注入

<bean id="diByConstructorParamName" class="com.javacode2018.lesson001.demo5.UserModel">
    <constructor-arg name="参数名称" value="参数值"/>
    <constructor-arg name="参数名称" value="参数值"/>
</bean>

　　java通过反射的方式可以获取到方法的参数名称，不过源码中的参数通过编译之后会变成class对象，通常情况下源码变成class文件之后，参数的真实名称会丢失，参数的名称会变成arg0,arg1,arg2这样的，和实际参数名称不一样了。

　　参数名称可能不稳定的问题，spring提供了解决方案，通过ConstructorProperties注解来定义参数的名称，将这个注解加在构造方法上面，如下：

@ConstructorProperties({"第一个参数名称", "第二个参数的名称",..."第n个参数的名称"})
public 类名(String p1, String p2...,参数n) {
}

　　实例类上的构造函数，增加注解

@ConstructorProperties({"name", "desc"})
    public CarModel(String p1, String p2) {
        this.name = p1;
        this.desc = p2;
    }

　　bean.xml文件更改配置元数据信息

<!-- 通过构造器参数的名称注入 -->
    <bean id="diByConstructorParamName" class="类的全路径名称">
        <constructor-arg name="desc" value="描述"/>
        <constructor-arg name="name" value="222"/>
    </bean>

　　二、setter方式注入

　　javaBean特性的：

• 属性都是private访问级别的

• 属性通常情况下通过一组setter（修改器）和getter（访问器）方法来访问

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

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

　　spring对符合javabean特点类，提供了setter方式的注入，会调用对应属性的setter方法将被依赖的对象注入进去。

<bean id="" class="">
    <property name="属性名称" value="属性值" />
    ...
    <property name="属性名称" value="属性值" />
</bean>　

　　setter注入相对于构造函数注入要灵活一些，构造函数需要指定对应构造函数中所有参数的值，而setter注入的方式没有这种限制，不需要对所有属性都进行注入，可以按需进行注入。

　　上面介绍的都是注入普通类型的对象，都是通过value属性来设置需要注入的对象的值的，value属性的值是String类型的，spring容器内部自动会将value的值转换为对象的实际类型。

　　若我们依赖的对象是容器中的其他bean对象的时候，需要用下面的方式进行注入。

　　注入容器中的bean有两种写法：

• ref属性方式

• 内置bean的方式

　　ref属性方式

　　将上面介绍的constructor-arg或者property元素的value属性名称替换为ref，ref属性的值为容器中其他bean的名称，如：

　　构造器方式，将value替换为ref：

<constructor-arg name="属性名称" ref="需要注入的bean的名称"/>

　　setter方式，将value替换为ref：

<property name="属性名称" ref="需要注入的bean的名称" />

　　bean.xml文件配置：

<!-- 通过构造器方式注入容器中的bean -->
    <bean id="diBeanByConstructor" class="全路径类名">
        <!-- 通过ref引用容器中定义的其他bean，user对应上面定义的id="user"的bean -->
        <constructor-arg index="0" ref="user"/>
        <constructor-arg index="1">
            <bean class="全路径类名">
                <constructor-arg index="0" value="1211"/>
                <constructor-arg index="1" value="22223"/>
            </bean>
        </constructor-arg>
    </bean>

    <!-- 通过setter方式注入容器中的bean -->
    <bean id="diBeanBySetter" class="全路径类名">
        <!-- 通过ref引用容器中定义的其他bean，user对应上面定义的id="user"的bean -->
        <property name="userModel" ref="user"/>
        <property name="carModel">
            <bean class="全路径类名">
                <constructor-arg index="0" value="1231"/>
                <constructor-arg index="1" value="222"/>
            </bean>
        </property>
    </bean>

　　三、其他类型注入

　　注入java.util.List（list元素）

<list>
    <value>Spring</value>
    或
    <ref bean="bean名称"/>
    或
    <list></list>
    或
    <bean></bean>
    或
    <array></array>
    或
    <map></map>
</list>

　　注入java.util.Set（set元素）

<set>
    <value>Spring</value>
    或
    <ref bean="bean名称"/>
    或
    <list></list>
    或
    <bean></bean>
    或
    <array></array>
    或
    <map></map>
</set>

　　注入java.util.Map（map元素）

<map>
    <entry key="Java" value="30" key-ref="key引用的bean名称" value-ref="value引用的bean名称"/>
    或
    <entry>
        <key>
            value对应的值，可以为任意类型
        </key>
        <value>
            value对应的值，可以为任意类型
        </value>
    </entry>
</map>

　　注入数组（array元素）

<array>
    数组中的元素
</array>　

　　注入java.util.Properties（props元素）

　　Properties类相当于键值都是String类型的Map对象，使用props进行注入，如下：

<props>
    <prop key="key1">java高并发系列</prop>
    <prop key="key2">mybatis系列</prop>
    <prop key="key3">mysql系列</prop>
</props>

　　实例类简例：

public class DiOtherTypeModel {
    private List<String> list1;
    private Set<UserModel> set1;
    private Map<String, Integer> map1;
    private int[] array1;
    private Properties properties1;

    public List<String> getList1() {
        return list1;
    }

    public void setList1(List<String> list1) {
        this.list1 = list1;
    }

    public Set<UserModel> getSet1() {
        return set1;
    }

    public void setSet1(Set<UserModel> set1) {
        this.set1 = set1;
    }

    public Map<String, Integer> getMap1() {
        return map1;
    }

    public void setMap1(Map<String, Integer> map1) {
        this.map1 = map1;
    }

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

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

    public Properties getProperties1() {
        return properties1;
    }

    public void setProperties1(Properties properties1) {
        this.properties1 = properties1;
    }

    @Override
    public String toString() {
        return "DiOtherTypeModel{" +
                "list1=" + list1 +
                ", set1=" + set1 +
                ", map1=" + map1 +
                ", array1=" + Arrays.toString(array1) +
                ", properties1=" + properties1 +
                '}';
    }
}

　　bean.xml配置信息

<bean id="user1" class="com.javacode2018.lesson001.demo5.UserModel"/>
    <bean id="user2" class="com.javacode2018.lesson001.demo5.UserModel"/>

    <bean id="diOtherType" class="com.javacode2018.lesson001.demo5.DiOtherTypeModel">
        <!-- 注入java.util.List对象 -->
        <property name="list1">
            <list>
                <value>Spring</value>
                <value>SpringBoot</value>
            </list>
        </property>

        <!-- 注入java.util.Set对象 -->
        <property name="set1">
            <set>
                <ref bean="user1"/>
                <ref bean="user2"/>
                <ref bean="user1"/>
            </set>
        </property>

        <!-- 注入java.util.Map对象 -->
        <property name="map1">
            <map>
                <entry key="路人甲Java" value="30"/>
                <entry key="路人" value="28"/>
            </map>
        </property>

        <!-- 注入数组对象 -->
        <property name="array1">
            <array>
                <value>10</value>
                <value>9</value>
                <value>8</value>
            </array>
        </property>

        <!-- 注入java.util.Properties对象 -->
        <property name="properties1">
            <props>
                <prop key="key1">java高并发系列</prop>
                <prop key="key2">mybatis系列</prop>
                <prop key="key3">mysql系列</prop>
            </props>
        </property>

    </bean>