03-Spring基于xml的IOC配置--spring的依赖注入

1、概念

依赖注入：Dependency Injection（简称DI注入）。它是 spring 框架核心 ioc 的具体实现。 简单理解：可以在一个类中不通过new的方式依赖其它对象。目的是为了解耦。

 

PS：工程依旧沿用02课程的，maven和applicationContet.xml可以直接去02复制粘贴。

 

2、构造方法注入属性

2.1 创建Phone对象

public class Phone {

}

2.2 调整Student类。学生拥有姓名、年龄和手机。

public class Student {
    private String name;
    private Integer age;
    private Phone phone;

    public Student(String name, Integer age, Phone phone) {
        this.name = name;
        this.age = age;
        this.phone = phone;
        System.out.println("I'm " + name + ", age " + age + ", phone " + phone);
    }

    public Phone getPhone() {
        return phone;
    }

    public void setPhone(Phone phone) {
        this.phone = phone;
    }

    public void say() {
        System.out.println("I'm a Student");
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

2.3 修改applicationContext.xml文件装配Student的bean标签

<?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">

    <!--
        1. spring会通过反射的方式创建对象，并将该对象以key和value的方式存入到IOC容器中。
        2. bean标签的id就是key，vaule就是类的全路径
        3. 通过bean标签将对象创建并存入到IOC容器中的方式，我们可以称之为装配bean
        4. 只要可以正常new出来的对象，都可以通过这种方式装配到IOC容器中
    -->
    <!-- 装配Phone对象到IOC容器中 -->
    <bean id="phone" class="com.demo.domain.Phone"/>

    <!-- 装配Studnt对象到IOC容器中 -->
    <bean id="student" class="com.demo.domain.Student">
        <!--
            constructor-arg标签:
                name属性：指定参数在构造函数中的名称，指定给谁赋值
                value属性：只能是基本数据类型和String类型的
                ref属性：指定其它bean类型，且必须在IOC容器中
        -->
        <constructor-arg name="name" value="zhangsan"/>
        <constructor-arg name="age" value="21"/>
        <constructor-arg name="phone" ref="phone"/>

    </bean>

    <!-- 使用静态工厂方法将Teacher对象装配到IOC容器中 -->
    <bean id="teacher" class="com.demo.factory.StaticFactory" factory-method="createTeacher"/>

    <!-- 使用实例工厂方法实例化bean -->
    <!-- 1. 装配实例工厂-->
    <bean id="instanceFactory" class="com.demo.factory.InstanceFactory"/>
    <!-- 2. 使用实例工厂创建cat对象-->
    <bean id="cat" factory-bean="instanceFactory" factory-method="createCat"/>

</beans>

2.4 运行方法

 

 

3、Setter方法注入

3.1 修改Teacher类

public class Teacher {

    private String name;

    private Integer age;

    private Phone phone;

    public Phone getPhone() {
        return phone;
    }

    public void setPhone(Phone phone) {
        this.phone = phone;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public void say() {
        System.out.println("I'm a teacher. name: " + name + ", age: " + age + ", phone: " + phone);
    }
}

3.2 修改applicationContext.xml中装配Teacher对象的bean标签

<?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">

    <!--
        1. spring会通过反射的方式创建对象，并将该对象以key和value的方式存入到IOC容器中。
        2. bean标签的id就是key，vaule就是类的全路径
        3. 通过bean标签将对象创建并存入到IOC容器中的方式，我们可以称之为装配bean
        4. 只要可以正常new出来的对象，都可以通过这种方式装配到IOC容器中
    -->
    <!-- 装配Phone对象到IOC容器中 -->
    <bean id="phone" class="com.demo.domain.Phone"/>

    <!-- 装配Studnt对象到IOC容器中 -->
    <bean id="student" class="com.demo.domain.Student">
        <!--
            constructor-arg标签:
                name属性：指定参数在构造函数中的名称，指定给谁赋值
                value属性：只能是基本数据类型和String类型的
                ref属性：指定其它bean类型，且必须在IOC容器中
        -->
        <constructor-arg name="name" value="zhangsan"/>
        <constructor-arg name="age" value="21"/>
        <constructor-arg name="phone" ref="phone"/>

    </bean>

    <!-- 使用静态工厂方法将Teacher对象装配到IOC容器中 -->
    <bean id="teacher" class="com.demo.factory.StaticFactory" factory-method="createTeacher">
        <!--
             property标签
                name属性：找的类中set方法后面的部分
                value属性：给属性赋值是基本数据类型和String类型的
                ref：给属性赋值是其他bean类型的。
         -->
        <property name="name" value="lisi"/>
        <property name="age" value="25"/>
        <property name="phone" ref="phone"/>
    </bean>

    <!-- 使用实例工厂方法实例化bean -->
    <!-- 1. 装配实例工厂-->
    <bean id="instanceFactory" class="com.demo.factory.InstanceFactory"/>
    <!-- 2. 使用实例工厂创建cat对象-->
    <bean id="cat" factory-bean="instanceFactory" factory-method="createCat"/>

</beans>

3.3 运行getTeaccherObjectFromSrpingIoc方法

 

 PS：我们看到打印了两句话。为什么？

　　这是因为加载配置文件的时候，初始化对象装配到IOC容器中，由于Student对象是有参构造，并且在构造方法中打印了一句话。

4、P名称空间注入

4.1 在applicationContext.xml文件中添加P名称空间

xmlns:p="http://www.springframework.org/schema/p"

 

 4.2 修改cat类

public class Cat {
    private String name;
    private Integer age;
    private Phone phone;

    public String getName() {
        return name;
    }

    public Phone getPhone() {
        return phone;
    }

    public void setPhone(Phone phone) {
        this.phone = phone;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public void say() {
        System.out.println("I'm a cat. name: " + name + ", age: " + age + ", phone: " + phone);
    }
}

4.3 修改applicationContext.xml文件中装配cat对象bean标签

<?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"
       xmlns:p="http://www.springframework.org/schema/p">

    <!--
        1. spring会通过反射的方式创建对象，并将该对象以key和value的方式存入到IOC容器中。
        2. bean标签的id就是key，vaule就是类的全路径
        3. 通过bean标签将对象创建并存入到IOC容器中的方式，我们可以称之为装配bean
        4. 只要可以正常new出来的对象，都可以通过这种方式装配到IOC容器中
    -->
    <!-- 装配Phone对象到IOC容器中 -->
    <bean id="phone" class="com.demo.domain.Phone"/>

    <!-- 装配Studnt对象到IOC容器中 -->
    <bean id="student" class="com.demo.domain.Student">
        <!--
            constructor-arg标签:
                name属性：指定参数在构造函数中的名称，指定给谁赋值
                value属性：只能是基本数据类型和String类型的
                ref属性：指定其它bean类型，且必须在IOC容器中
        -->
        <constructor-arg name="name" value="zhangsan"/>
        <constructor-arg name="age" value="21"/>
        <constructor-arg name="phone" ref="phone"/>

    </bean>

    <!-- 使用静态工厂方法将Teacher对象装配到IOC容器中 -->
    <bean id="teacher" class="com.demo.factory.StaticFactory" factory-method="createTeacher">
        <!--
             property标签
                name属性：找的类中set方法后面的部分
                value属性：给属性赋值是基本数据类型和String类型的
                ref：给属性赋值是其他bean类型的。
         -->
        <property name="name" value="lisi"/>
        <property name="age" value="25"/>
        <property name="phone" ref="phone"/>
    </bean>

    <!-- 使用实例工厂方法实例化bean -->
    <!-- 1. 装配实例工厂-->
    <bean id="instanceFactory" class="com.demo.factory.InstanceFactory"/>
    <!-- 2. 使用实例工厂创建cat对象-->
    <bean id="cat" factory-bean="instanceFactory" factory-method="createCat" p:name="tom" p:age="21"
          p:phone-ref="phone"/>

</beans>

4.4 运行getCatObjectFromSrpingIoc方法

 

 

5、复杂类型的注入

5.1 创建HelloWorld实体类

import java.util.*;


public class HelloWorld {
    private String[] myArrays;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String, String> myMap;
    private Properties myProps;

    public String[] getMyArrays() {
        return myArrays;
    }

    public void setMyArrays(String[] myArrays) {
        this.myArrays = myArrays;
    }

    public List<String> getMyList() {
        return myList;
    }

    public void setMyList(List<String> myList) {
        this.myList = myList;
    }

    public Set<String> getMySet() {
        return mySet;
    }

    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }

    public Map<String, String> getMyMap() {
        return myMap;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public Properties getMyProps() {
        return myProps;
    }

    public void setMyProps(Properties myProps) {
        this.myProps = myProps;
    }

    public void sayHello() {
        System.out.println("Hello World!");
        System.out.println(Arrays.toString(myArrays));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        System.out.println(myProps);

    }
}

5.2 在applicationContext.xml中装配HelloWorld对象

<?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"
       xmlns:p="http://www.springframework.org/schema/p">

    <!--
        1. spring会通过反射的方式创建对象，并将该对象以key和value的方式存入到IOC容器中。
        2. bean标签的id就是key，vaule就是类的全路径
        3. 通过bean标签将对象创建并存入到IOC容器中的方式，我们可以称之为装配bean
        4. 只要可以正常new出来的对象，都可以通过这种方式装配到IOC容器中
    -->
    <!-- 装配Phone对象到IOC容器中 -->
    <bean id="phone" class="com.demo.domain.Phone"/>

    <!-- 装配Studnt对象到IOC容器中 -->
    <bean id="student" class="com.demo.domain.Student">
        <!--
            constructor-arg标签:
                name属性：指定参数在构造函数中的名称，指定给谁赋值
                value属性：只能是基本数据类型和String类型的
                ref属性：指定其它bean类型，且必须在IOC容器中
        -->
        <constructor-arg name="name" value="zhangsan"/>
        <constructor-arg name="age" value="21"/>
        <constructor-arg name="phone" ref="phone"/>

    </bean>

    <!-- 使用静态工厂方法将Teacher对象装配到IOC容器中 -->
    <bean id="teacher" class="com.demo.factory.StaticFactory" factory-method="createTeacher">
        <!--
             property标签
                name属性：找的类中set方法后面的部分
                value属性：给属性赋值是基本数据类型和String类型的
                ref：给属性赋值是其他bean类型的。
         -->
        <property name="name" value="lisi"/>
        <property name="age" value="25"/>
        <property name="phone" ref="phone"/>
    </bean>

    <!-- 使用实例工厂方法实例化bean -->
    <!-- 1. 装配实例工厂-->
    <bean id="instanceFactory" class="com.demo.factory.InstanceFactory"/>
    <!-- 2. 使用实例工厂创建cat对象-->
    <bean id="cat" factory-bean="instanceFactory" factory-method="createCat" p:name="tom" p:age="21"
          p:phone-ref="phone"/>

    <!-- 装配HelloWorld对象到IOC容器中 -->
    <bean id="helloWorld" class="com.demo.domain.HelloWorld">
        <property name="myArrays">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>
        <property name="myList">
            <list>
                <value>CCC</value>
                <value>DDD</value>
                <value>EEE</value>
            </list>
        </property>
        <property name="mySet">
            <set>
                <value>FFF</value>
                <value>GGG</value>
                <value>HHH</value>
            </set>
        </property>
        <property name="myMap">
            <map>
                <entry key="name1" value="III"/>
                <entry key="name2" value="JJJ"/>
                <entry key="name3" value="KKK"/>
            </map>
        </property>
        <property name="myProps">
            <props>
                <prop key="name1">LLL</prop>
                <prop key="name2">MMM</prop>
                <prop key="name3">NNN</prop>
            </props>
        </property>
    </bean>
</beans>

5.3 测试

    @Test
    public void getHelloWorldObjectFromSrpingIoc() {
        //从SpringIOC容器中获取HelloWorld对象

        //1. 根据bean的id去IOC容器中获取HelloWorld对象
        HelloWorld helloWorld = (HelloWorld) ac.getBean("helloWorld");
        //2. 调用helloWolrd中的sayHello()方法
        helloWorld.sayHello();
    }