04 Spring对IoC的实现

<repositories>
    <repository>
        <id>repository.spring.milestone</id>
        <name>Spring Milestone Repository</name>
        <url>https://repo.spring.io/milestone</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.0.0-M2</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
</dependencies>

<properties>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
</properties>

```Java title:UserDao.java
package com.powernode.spring6.dao;

/**
 * @author 动力节点
 * @version 1.0
 * @className UserDao
 * @since 1.0
 **/
public class UserDao {

    public void insert(){
        System.out.println("正在保存用户数据。");
    }
}

private UserDao userDao;

// 使用set方式注入，必须提供set方法。
// 反射机制要调用这个方法给属性赋值的。
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

public void save(){
    userDao.insert();
}

```XML title:Spring.xml
<?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">

    <bean id="userDaoBean" class="com.powernode.spring6.dao.UserDao"/>

    <bean id="userServiceBean" class="com.powernode.spring6.service.UserService">
        <property name="userDao" ref="userDaoBean"/>
    </bean>

</beans>

<bean id="userDaoBean" class="com.powernode.spring6.dao.UserDao"/>

<bean id="userServiceBean" class="com.powernode.spring6.service.UserService">
    <property name="userDao" ref="userDaoBean"/>
</bean>

实现原理：  
1. 通过 property 标签获取到属性名：userDao  
2. 通过属性名推断出 set 方法名：setUserDao  
3. 通过反射机制调用 setUserDao () 方法给属性赋值  
4. property 标签的 name 是属性名。  
5. property 标签的 ref 是要注入的 bean 对象的 id。(通过 ref 属性来完成 bean 的装配，这是 bean 最简单的一种装配方式。装配指的是：创建系统组件之间关联的动作)  
可以把 set 方法注释掉，再测试一下：

![[04.02-2.webp]]

经过测试，底层实际上调用了 `setUserDao()` 方法。所以需要确保这个方法的存在。

现在把属性名修改一下，但方法名还是 `setUserDao()`，我们来测试一下：

```java title:UserService.java
package com.powernode.spring6.service;

import com.powernode.spring6.dao.UserDao;

/**
 * @author 动力节点
 * @version 1.0
 * @className UserService
 * @since 1.0
 **/
public class UserService {

    private UserDao aaa;

    // 使用set方式注入，必须提供set方法。
    // 反射机制要调用这个方法给属性赋值的。
    public void setUserDao(UserDao userDao) {
        this.aaa = userDao;
    }

    public void save(){
        aaa.insert();
    }
}

**总结：setter 注入的核心实现原理：通过反射机制调用 set 方法来给属性赋值，让两个对象之间产生关系。**

### 4.2.2 构造注入

核心原理：通过调用构造方法来给属性赋值。

```java title:OrderDao.java
package com.powernode.spring6.dao;

/**
 * @author 动力节点
 * @version 1.0
 * @className OrderDao
 * @since 1.0
 **/
public class OrderDao {
    public void deleteById(){
        System.out.println("正在删除订单。。。");
    }
}

// 通过反射机制调用构造方法给属性赋值
public OrderService(OrderDao orderDao) {
    this.orderDao = orderDao;
}

public void delete(){
    orderDao.deleteById();
}

运行结果如下：

![[04.02-4.webp]]

 如果构造方法有两个参数：

```java title:OrderService
package com.powernode.spring6.service;

import com.powernode.spring6.dao.OrderDao;
import com.powernode.spring6.dao.UserDao;

/**
 * @author 动力节点
 * @version 1.0
 * @className OrderService
 * @since 1.0
 **/
public class OrderService {
    private OrderDao orderDao;
    private UserDao userDao;

    // 通过反射机制调用构造方法给属性赋值
    public OrderService(OrderDao orderDao, UserDao userDao) {
        this.orderDao = orderDao;
        this.userDao = userDao;
    }

    public void delete(){
        orderDao.deleteById();
        userDao.insert();
    }
}

执行测试程序：
![[04.02-5.webp]]

不使用参数下标，使用参数的名字可以吗？
```xml title:spring.xml
<bean id="orderDaoBean" class="com.powernode.spring6.dao.OrderDao"/>

<bean id="orderServiceBean" class="com.powernode.spring6.service.OrderService">
  <!--这里使用了构造方法上参数的名字-->
  <constructor-arg name="orderDao" ref="orderDaoBean"/>
  <constructor-arg name="userDao" ref="userDaoBean"/>
</bean>

<bean id="userDaoBean" class="com.powernode.spring6.dao.UserDao"/>

执行测试程序：
![[04.02-7.webp]]

配置文件中构造方法参数的类型顺序和构造方法参数的类型顺序不一致呢？
```XML title:spring.xml
<bean id="orderDaoBean" class="com.powernode.spring6.dao.OrderDao"/>

<bean id="orderServiceBean" class="com.powernode.spring6.service.OrderService">
  <!--顺序已经和构造方法的参数顺序不同了-->
  <constructor-arg ref="userDaoBean"/>
  <constructor-arg ref="orderDaoBean"/>
</bean>

<bean id="userDaoBean" class="com.powernode.spring6.dao.UserDao"/>

<bean id="userDaoBean" class="com.powernode.spring6.dao.UserDao"/>

<bean id="userServiceBean" class="com.powernode.spring6.service.UserService">
    <property name="userDao" ref="userDaoBean"/>
</bean>

外部 Bean 的特点：bean 定义到外面，在 property 标签中使用 ref 属性进行注入。通常这种方式是常用。

### 4.3.2 注入内部 Bean

内部 Bean 的方式：在 bean 标签中嵌套 bean 标签。
```XML title:spring-inner-bean.xml
<?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">

    <bean id="userServiceBean" class="com.powernode.spring6.service.UserService">
        <property name="userDao">
            <bean class="com.powernode.spring6.dao.UserDao"/>
        </property>
    </bean>

</beans>

private UserDao userDao;

public void setUserDao(UserDao userDao){
    this.userDao = userDao;
}

那如果对象的属性是 int 类型呢？
```Java title:对象的属性是int类型
public class User{

    private int age;

    public void setAge(int age){
        this.age = age;
    }

}

public void setAge(int age) {
    this.age = age;
}

@Override
public String toString() {
    return "User{" +
            "age=" + age +
            '}';
}

第二步：编写 spring 配置文件：spring-simple-type. xml
```XML title:spring-simple-type.xml
<?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">
    <bean id="userBean" class="com.powernode.spring6.beans.User">
        <!--如果像这种int类型的属性，我们称为简单类型，这种简单类型在注入的时候要使用value属性，不能使用ref-->
        <!--<property name="age" value="20"/>-->
        <property name="age">
            <value>20</value>
        </property>
    </bean>
</beans>

第四步：运行测试程序
![[04.03-2.webp]]

需要特别注意：如果给简单类型赋值，使用 value 属性或 value 标签。而不是 ref。

简单类型包括哪些呢？可以通过 Spring 的源码来分析一下：BeanUtils 类
```Java title:BeanUtils.java
public class BeanUtils{

    //.......

    /**
     * Check if the given type represents a "simple" property: a simple value
     * type or an array of simple value types.
     * <p>See {@link #isSimpleValueType(Class)} for the definition of <em>simple
     * value type</em>.
     * <p>Used to determine properties to check for a "simple" dependency-check.
     * @param type the type to check
     * @return whether the given type represents a "simple" property
     * @see org.springframework.beans.factory.support.RootBeanDefinition#DEPENDENCY_CHECK_SIMPLE
     * @see org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#checkDependencies
     * @see #isSimpleValueType(Class)
     */
    public static boolean isSimpleProperty(Class<?> type) {
        Assert.notNull(type, "'type' must not be null");
        return isSimpleValueType(type) || (type.isArray() && isSimpleValueType(type.getComponentType()));
    }

    /**
     * Check if the given type represents a "simple" value type: a primitive or
     * primitive wrapper, an enum, a String or other CharSequence, a Number, a
     * Date, a Temporal, a URI, a URL, a Locale, or a Class.
     * <p>{@code Void} and {@code void} are not considered simple value types.
     * @param type the type to check
     * @return whether the given type represents a "simple" value type
     * @see #isSimpleProperty(Class)
     */
    public static boolean isSimpleValueType(Class<?> type) {
        return (Void.class != type && void.class != type &&
                (ClassUtils.isPrimitiveOrWrapper(type) ||
                Enum.class.isAssignableFrom(type) ||
                CharSequence.class.isAssignableFrom(type) ||
                Number.class.isAssignableFrom(type) ||
                Date.class.isAssignableFrom(type) ||
                Temporal.class.isAssignableFrom(type) ||
                URI.class == type ||
                URL.class == type ||
                Locale.class == type ||
                Class.class == type));
    }

    //........
}

public void setDriver(String driver) {
    this.driver = driver;
}

public void setUrl(String url) {
    this.url = url;
}

public void setUsername(String username) {
    this.username = username;
}

public void setPassword(String password) {
    this.password = password;
}

@Override
public String toString() {
    return "MyDataSource{" +
            "driver='" + driver + '\'' +
            ", url='" + url + '\'' +
            ", username='" + username + '\'' +
            ", password='" + password + '\'' +
            '}';
}

@Override
public Connection getConnection() throws SQLException {
    return null;
}

@Override
public Connection getConnection(String username, String password) throws SQLException {
    return null;
}

@Override
public PrintWriter getLogWriter() throws SQLException {
    return null;
}

@Override
public void setLogWriter(PrintWriter out) throws SQLException {

}

@Override
public void setLoginTimeout(int seconds) throws SQLException {

}

@Override
public int getLoginTimeout() throws SQLException {
    return 0;
}

@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
    return null;
}

@Override
public <T> T unwrap(Class<T> iface) throws SQLException {
    return null;
}

@Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
    return false;
}

执行测试程序：
![[04.03-3.webp]]
你学会了吗？  

接下来，我们编写一个程序，把所有的简单类型全部测试一遍：  
编写一个类 A：

```Java title:A.java
package com.powernode.spring6.beans;

import java.net.URI;
import java.net.URL;
import java.time.LocalDate;
import java.util.Date;
import java.util.Locale;

/**
 * @author 动力节点
 * @version 1.0
 * @className A
 * @since 1.0
 **/
public class A {
    private byte b;
    private short s;
    private int i;
    private long l;
    private float f;
    private double d;
    private boolean flag;
    private char c;

    private Byte b1;
    private Short s1;
    private Integer i1;
    private Long l1;
    private Float f1;
    private Double d1;
    private Boolean flag1;
    private Character c1;

    private String str;

    private Date date;

    private Season season;

    private URI uri;

    private URL url;

    private LocalDate localDate;

    private Locale locale;

    private Class clazz;

    // 生成setter方法
    // 生成toString方法
}

enum Season {
    SPRING, SUMMER, AUTUMN, WINTER
}

<bean id="a" class="com.powernode.spring6.beans.A">
    <property name="b" value="1"/>
    <property name="s" value="1"/>
    <property name="i" value="1"/>
    <property name="l" value="1"/>
    <property name="f" value="1"/>
    <property name="d" value="1"/>
    <property name="flag" value="false"/>

    <property name="c" value="a"/>
    <property name="b1" value="2"/>
    <property name="s1" value="2"/>
    <property name="i1" value="2"/>
    <property name="l1" value="2"/>
    <property name="f1" value="2"/>
    <property name="d1" value="2"/>
    <property name="flag1" value="true"/>
    <property name="c1" value="a"/>

    <property name="str" value="zhangsan"/>
    <!--注意：value后面的日期字符串格式不能随便写，必须是Date对象toString()方法执行的结果。-->
    <!--如果想使用其他格式的日期字符串，就需要进行特殊处理了。具体怎么处理，可以看后面的课程！！！！-->
    <property name="date" value="Fri Sep 30 15:26:38 CST 2022"/>
    <property name="season" value="WINTER"/>
    <property name="uri" value="/save.do"/>
    <!--spring6之后，会自动检查url是否有效，如果无效会报错。-->
    <property name="url" value="http://www.baidu.com"/>
    <property name="localDate" value="EPOCH"/>
    <!--java.util.Locale 主要在软件的本地化时使用。它本身没有什么功能，更多的是作为一个参数辅助其他方法完成输出的本地化。-->
    <property name="locale" value="CHINESE"/>
    <property name="clazz" value="java.lang.String"/>
</bean>

public Clazz() {
}

public Clazz(String name) {
    this.name = name;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

@Override
public String toString() {
    return "Clazz{" +
            "name='" + name + '\'' +
            '}';
}

```java title:测试方法
@Test
public void testCascade(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-cascade.xml");
    Student student = applicationContext.getBean("student", Student.class);
    System.out.println(student);
}

public void setFavariteFoods(String[] favariteFoods) {
    this.favariteFoods = favariteFoods;
}

@Override
public String toString() {
    return "Person{" +
            "favariteFoods=" + Arrays.toString(favariteFoods) +
            '}';
}

当数组中的元素是非简单类型：一个订单中包含多个商品。

```java title:Goods.java
package com.powernode.spring6.beans;

/**
 * @author 动力节点
 * @version 1.0
 * @className Goods
 * @since 1.0
 **/
public class Goods {
    private String name;

    public Goods() {
    }

    public Goods(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Goods{" +
                "name='" + name + '\'' +
                '}';
    }
}

public Order() {
}

public Order(Goods[] goods) {
    this.goods = goods;
}

public void setGoods(Goods[] goods) {
    this.goods = goods;
}

@Override
public String toString() {
    return "Order{" +
            "goods=" + Arrays.toString(goods) +
            '}';
}

执行结果：

![[04.03-6.webp]]

要点：
- 如果数组中是简单类型，使用 `value` 标签。
- 如果数组中是非简单类型，使用 `ref` 标签。

### 4.3.6 注入 List

**List**：有序可重复

```java title:People.java
package com.powernode.spring6.beans;

import java.util.List;

/**
 * @author 动力节点
 * @version 1.0
 * @className People
 * @since 1.0
 **/
public class People {
    // 一个人有多个名字
    private List names;

    public void setNames(List names) {
        this.names = names;
    }

    @Override
    public String toString() {
        return "People{" +
                "names=" + names +
                '}';
    }
}

<bean id="peopleBean" class="com.powernode.spring6.beans.People">
    <property name="names">
        <list>
            <value>铁锤</value>
            <value>张三</value>
            <value>张三</value>
            <value>张三</value>
            <value>狼</value>
        </list>
    </property>
</bean>

public void setPhones(Set phones) {
    this.phones = phones;
}

//......

@Override
public String toString() {
    return "People{" +
            "phones=" + phones +
            ", names=" + names +
            '}';
}

public void setAddrs(Map addrs) {
    this.addrs = addrs;
}

//......

@Override
public String toString() {
    return "People{" +
            "addrs=" + addrs +
            ", phones=" + phones +
            ", names=" + names +
            '}';
}

```xml title:spring-collection.xml
<?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">

    <bean id="peopleBean" class="com.powernode.spring6.beans.People">
        <property name="names">
            <list>
                <value>铁锤</value>
                <value>张三</value>
                <value>张三</value>
                <value>张三</value>
                <value>狼</value>
            </list>
        </property>
    </bean>
</beans>                      

执行结果：
![[04.03-10.webp]]
注意：注入 List**的时候使用 list 标签，如果 List**中是简单类型使用 value 标签，反之使用 ref 标签。

### 4.3.7 注入 Set

**Set**：无序不可重复

```java title:People.java
package com.powernode.spring6.beans;

import java.util.List;
import java.util.Set;

/**
 * @author 动力节点
 * @version 1.0
 * @className People
 * @since 1.0
 */
public class People {
    // 一个人有多个电话
    private Set phones;

    public void setPhones(Set phones) {
        this.phones = phones;
    }

    //......

    @Override
    public String toString() {
        return "People{" +
                "phones=" + phones +
                ", names=" + names +
                '}';
    }
}

<bean id="peopleBean" class="com.powernode.spring6.beans.People">
    <property name="phones">
        <set>
            <!--非简单类型可以使用ref，简单类型使用value-->
            <value>110</value>
            <value>110</value>
            <value>120</value>
            <value>120</value>
            <value>119</value>
            <value>119</value>
        </set>
    </property>
</bean>

<bean id="peopleBean" class="com.powernode.spring6.beans.People">
    <property name="addrs">
        <map>
            <!--如果key不是简单类型，使用 key-ref 属性-->
            <!--如果value不是简单类型，使用 value-ref 属性-->
            <entry key="1" value="北京大兴区"/>
            <entry key="2" value="上海浦东区"/>
            <entry key="3" value="深圳宝安区"/>
        </map>
    </property>
</bean>

<bean id="peopleBean" class="com.powernode.spring6.beans.People">
    <property name="properties">
        <props>
            <prop key="driver">com.mysql.cj.jdbc.Driver</prop>
            <prop key="url">jdbc:mysql://localhost:3306/spring</prop>
            <prop key="username">root</prop>
            <prop key="password">123456</prop>
        </props>
    </property>
</bean>

<bean id="vipBean" class="com.powernode.spring6.beans.Vip">
    <!--空串的第一种方式-->
    <!--<property name="email" value=""/>-->
    <!--空串的第二种方式-->
    <property name="email">
        <value/>
    </property>
</bean>

```java title:VipTest.java
@Test
public void testNull(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-null.xml");
    Vip vipBean = applicationContext.getBean("vipBean", Vip.class);
    System.out.println(vipBean);
}

<bean id="vipBean" class="com.powernode.spring6.beans.Vip" />

执行结果：
![[04.03-15.webp]]
    - 第二种方式：使用\<null/>

```xml title:spring-null.xml
<?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">

    <bean id="vipBean" class="com.powernode.spring6.beans.Vip">
        <property name="email">
            <null/>
        </property>
    </bean>

</beans>                                 

```xml title:spring-special.xml
<?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">
    <bean id="mathBean" class="com.powernode.spring6.beans.Math">
        <property name="result" value="2 &lt; 3"/>
    </bean>
</beans>             

执行结果：
![[04.3-1.png]]

我们再来使用 CDATA 方式：
```xml title:spring-special-cdata.xml
<?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">

    <bean id="mathBean" class="com.powernode.spring6.beans.Math">
        <property name="result">
            <!--只能使用value标签-->
            <value><![CDATA[2 < 3]]></value>
        </property>
    </bean>

</beans>                                               

public void setName(String name) {
    this.name = name;
}

public void setAge(int age) {
    this.age = age;
}

@Override
public String toString() {
    return "Customer{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
}

```XML title:spring-p.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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">

    <bean id="customerBean" class="com.powernode.spring6.beans.Customer" p:name="zhangsan" p:age="20"/>

</beans>

执行结果：
![[04.04-1.png]]
把 setter 方法去掉：
![[04.04-2.png]]

所以 p 命名空间实际上是对 set 注入的简化。


---
## 4.5 c 命名空间注入

**c 命名空间是简化构造方法注入的**。

使用 c 命名空间的两个前提条件： 
- 第一：需要在 xml 配置文件头部添加信息：xmlns: c\="[http://www.springframework.org/schema/c](http://www.springframework.org/schema/c)" 
- 第二：需要提供构造方法。

```Java title:MyTime.java
package com.powernode.spring6.beans;

/**
 * @author 动力节点
 * @version 1.0
 * @className MyTime
 * @since 1.0
 **/
public class MyTime {
    private int year;
    private int month;
    private int day;

    public MyTime(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    @Override
    public String toString() {
        return "MyTime{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
}

<!--<bean id="myTimeBean" class="com.powernode.spring6.beans.MyTime" c:year="1970" c:month="1" c:day="1"/>-->

<bean id="myTimeBean" class="com.powernode.spring6.beans.MyTime" c:_0="2008" c:_1="8" c:_2="8"/>

```Java title:测试程序.java
@Test
public void testC(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-c.xml");
    MyTime myTimeBean = applicationContext.getBean("myTimeBean", MyTime.class);
    System.out.println(myTimeBean);
}

```java title:MyDataSource2.java
package com.powernode.spring6.beans;  

import java.util.Properties;  

/**  
* @author 动力节点  
* @version 1.0  
* @className MyDataSource2  
* @since 1.0  
*/  
public class MyDataSource2 {  
    private Properties properties;  

    public void setProperties(Properties properties) {  
        this.properties = properties;  
    }  

    @Override  
    public String toString() {  
        return "MyDataSource2{" +  
                "properties=" + properties +  
                '}';  
    }  
}  

<util:properties id="prop">
    <prop key="driver">com.mysql.cj.jdbc.Driver</prop>
    <prop key="url">jdbc:mysql://localhost:3306/spring</prop>
    <prop key="username">root</prop>
    <prop key="password">123456</prop>
</util:properties>

<bean id="dataSource1" class="com.powernode.spring6.beans.MyDataSource1">
    <property name="properties" ref="prop"/>
</bean>

<bean id="dataSource2" class="com.powernode.spring6.beans.MyDataSource2">
    <property name="properties" ref="prop"/>
</bean>

```java title:UserService.java
package com.powernode.spring6.service;  

import com.powernode.spring6.dao.UserDao;  

/**  
* @author 动力节点  
* @version 1.0  
* @className UserService  
* @since 1.0  
*/  
public class UserService {  

    private UserDao aaa;  

    // 这个set方法非常关键  
    public void setAaa(UserDao aaa) {  
        this.aaa = aaa;  
    }  

    public void save(){  
        aaa.insert();  
    }  
}  

<bean id="userService" class="com.powernode.spring6.service.UserService" autowire="byName"/>

<bean id="aaa" class="com.powernode.spring6.dao.UserDao"/>

这个配置起到关键作用：  
-  `UserServiceBean` 中需要添加 `autowire="byName"`，表示通过名称进行装配。  
-  `UserService` 类中有一个 `UserDao` 属性，而 `UserDao` 属性的名字是 aaa，对应的 set 方法是 `setAaa ()`，正好和 `UserDaoBean` 的 id 是一样的。这就是根据名称自动装配。  

```java title:TestAutowireByName.java
@Test  
public void testAutowireByName(){  
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-autowire.xml");  
    UserService userService = applicationContext.getBean("userService", UserService.class);  
    userService.save();  
}  

在执行测试程序：  
![[04.07-2.png]]

通过测试得知，aaa 属性并没有赋值成功。也就是并没有装配成功。  
我们将 spring 配置文件修改以下：  

```xml title:spring-autowire.xml
<?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">

  <bean id="userService" class="com.powernode.spring6.service.UserService" autowire="byName"/>
  <!--这个id修改了-->
  <bean id="dao" class="com.powernode.spring6.dao.UserDao"/>

</beans>         

```java title:AccountService.java
package com.powernode.spring6.service;  

import com.powernode.spring6.dao.AccountDao;  

/**  
* @author 动力节点  
* @version 1.0  
* @className AccountService  
* @since 1.0  
*/  
public class AccountService {  
    private AccountDao accountDao;  

    public void setAccountDao(AccountDao accountDao) {  
        this.accountDao = accountDao;  
    }  

    public void save(){  
        accountDao.insert();  
    }  
}  

<!--byType表示根据类型自动装配-->
<bean id="accountService" class="com.powernode.spring6.service.AccountService" autowire="byType"/>

<bean class="com.powernode.spring6.dao.AccountDao"/>

```java title:TestAutowireByType.java
@Test  
public void testAutowireByType(){  
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-autowire.xml");  
    AccountService accountService = applicationContext.getBean("accountService", AccountService.class);  
    accountService.save();  
}  

<bean id="accountService" class="com.powernode.spring6.service.AccountService" autowire="byType"/>

<bean id="x" class="com.powernode.spring6.dao.AccountDao"/>
<bean id="y" class="com.powernode.spring6.dao.AccountDao"/>

执行测试程序：  
![[04.07-6.png]]
测试结果说明了，**当 byType 进行自动装配的时候，配置文件中某种类型的 Bean 必须是唯一的，不能出现多个。**  


---
## 4.8 Spring 引入外部属性配置文件

我们都知道编写数据源的时候是需要连接数据库的信息的，
例如：`driver url username password` 等信息。

这些信息可以单独写到一个属性配置文件中吗，这样用户修改起来会更加的方便。当然可以。  

第一步：写一个数据源类，提供相关属性。
```java
package com.powernode.spring6.beans;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;

/**
 * @author 动力节点
 * @version 1.0
 * @className MyDataSource
 * @since 1.0
 **/
public class MyDataSource implements DataSource {
    @Override
    public String toString() {
        return "MyDataSource{" +
                "driver='" + driver + '\'' +
                ", url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    private String driver;
    private String url;
    private String username;
    private String password;

    public void setDriver(String driver) {
        this.driver = driver;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    //......
}

第三步：在 spring 配置文件中引入 context 命名空间。
```XML title:spring-properties.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

</beans>

<context:property-placeholder location="jdbc.properties"/>

<bean id="dataSource" class="com.powernode.spring6.beans.MyDataSource">
    <property name="driver" value="${driver}"/>
    <property name="url" value="${url}"/>
    <property name="username" value="${username}"/>
    <property name="password" value="${password}"/>
</bean>