Spring-Day02-依赖注入-作业

配置beans约束自动提示
- spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html中打开xsd-configuration.html，拉到最下面，复制以下内容到主配置文件applicationContext.xml中

<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">
</beans>

新建User类

package kong.spring.day02.pojo;

public class User {
    private String username;
    private Integer age;
    
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "User [username=" + username + ", age=" + age + "]";
    }
    
}

在applicationContext.xml文件中将User类对象注入到Spring容器中，并通过set方法注入其属性值，set方式依赖注入标签为：property

<bean name="user" class="kong.spring.day02.pojo.User">
        <property name="username" value="NulluN"/>
        <property name="age" value="18"/>
</bean>

测试通过set方法进行普通值类型注入

package kong.spring.day02.test;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import kong.spring.day02.pojo.User;

//使用RunWith注解帮我们创建用于JUnit测试的Spring容器
@RunWith(SpringJUnit4ClassRunner.class)
//通过注解加载applicationContext.xml文件，就可以省去下面测试中创建ClassPathXmlApplicationContext对象加载applicationContext.xml文件的代码
//指定容器创建时加载哪个配置文件
@ContextConfiguration("classpath:applicationContext.xml")

public class DiTestDemo {
    
    //使用注解手动注入在applicationContext.xml文件中配置的user对象
    @Resource(name = "user")
    private User user;
    
    //使用JUnit测试在applicationContext.xml中配置的user对象的set方式依赖注入
    @Test
    public void testDiSet() {
        // 直接打印user对象，通过调用toString方法即可测试set方式的依赖注入是否正确
        System.out.println(user);
    }
}

测试结果：通过配置文件的set方式注入成功

测试通过构造方法方式进行普通值类型注入，相关配置如下，构造方法依赖注入的标签为：constructor-arg

<bean name="car" class="kong.spring.day02.pojo.Car">
        <constructor-arg name="carName" value="玛莎拉蒂"/>
        <constructor-arg name="carPrice" value="1000000.00"/>
</bean>

测试代码如下：

    // 使用注解自动注入在applicationContext.xml文件中配置的car对象
    @Autowired
    private Car car;

    // 使用JUnit测试在applicationContext.xml中配置的car对象的构造方法方式的依赖注入
    @Test
    public void testDiConstructor() {
        // 直接打印car对象，通过调用toString方法即可测试构造方法方式的依赖注入是否正确
        System.out.println(car);
    }

测试结果：通过配置文件的构造方法方式注入普通值类型成功

Bean的生命周期
- init-method:bean被初始化时执行的方法
- destroy-method:bean被销毁时执行的方法，执行销毁实例的方法，必须关闭ClassPathXmlApplicationContext容器对象时才会执行
- applicationContext.xml配置如下：

　　　<!-- 
        init-method：配置创建实例对象时执行的初始化方法，注意直接配置User类中相应的初始化方法的名字即可，不需要写括号
        destroy-method：配置销毁实例对象时执行的销毁方法，注意直接配置User类中相应的销毁方法的名字即可，不需要写括号
     -->
    <bean name="user" class="kong.spring.day02.pojo.User" init-method="init" destroy-method="destroy">
        <property name="username" value="NulluN"/>
        <property name="age" value="18"/>
    </bean>

- 测试代码如下：

// 使用注解手动注入在applicationContext.xml文件中配置的user对象
@Resource(name = "user")
private User user;

// 测试Bean的生命周期
@Test
public void testBeanLifecycle() {
    // 直接打印user对象
    System.out.println(user);
}

- 测试结果如下：

Bean的作用范围配置：scope属性
- singleton：单例，当没有配置Bean的scope属性时，默认是单例模式
- prototype：多例
- request：在web项目中，创建类的实例保存到request当中
- session：在web项目中，创建类的实例保存到session当中
- globalsession：相当于session（单点登录）
- 关于没有配置Bean的scope属性时，默认单例模式的测试，测试代码如下：

// 使用注解手动注入在applicationContext.xml文件中配置的user对象
@Resource(name = "user")
private User user1;
@Resource(name = "user")
private User user2;
// 测试Bean实例scope属性
@Test
public void testBeanSingletonOrPrototype() {
    // 直接打印user对象
    System.out.println("user1对象地址值：" + user1);
    System.out.println("user2对象地址值：" + user2);
    System.out.println("user1与user2是否为同一对象（单例模式）：" + (user1==user2));
}

- 测试结果如下：

- 测试scope属性配置为prototype时的对象关系，测试代码与上面测试一样，测试结果如下：

引用（对象）类型依赖注入：用ref标签，注入格式为：ref="bean的id或name值"
- set方法引用类型依赖注入的配置如下：

<!-- 通过set方法注入user对象的普通值类型和引用类型 -->
<bean name="user" class="kong.spring.day02.pojo.User">
    <!-- 普通值类型注入 -->
    <property name="username" value="NulluN"/>
    <property name="age" value="18"/>
    <!-- 引用（对象）类型注入 -->
    <property name="car" ref="car"></property>
</bean>

- set方法引用类型依赖注入的测试代码如下：

// 使用注解手动注入在applicationContext.xml文件中通过set方法依赖注入的user对象
@Resource(name = "user")
private User user1;
    
// 测试引用（对象）类型的set方法依赖注入
@Test
public void testRefDi() {
    // 直接打印user对象，看其引用类型属性是否注入成功
    System.out.println(user1);
}

- 测试结果如下：car对象set注入成功

- 构造方法引用类型依赖注入的配置如下：

    <!-- 通过构造方法注入user对象的普通值类型和引用类型 -->
    <bean name="user_constructor" class="kong.spring.day02.pojo.User">
        <!-- 普通值类型注入 -->
        <constructor-arg name="username" value="空空"/>
        <constructor-arg name="age" value="18"/>
        <!-- 引用（对象）类型注入 -->
        <constructor-arg name="car" ref="car"/>
    </bean>

- 构造方法引用类型依赖注入的测试代码如下：

　　 // 使用注解手动注入在applicationContext.xml文件中通过构造方法依赖注入的user_constructor对象
    @Resource(name = "user_constructor")
    private User user_constructor;
    
    // 测试引用（对象）类型的set方法依赖注入
    @Test
    public void testRefConstructorDi() {
        // 直接打印user对象，看其引用类型属性是否注入成功
        System.out.println(user_constructor);
    }

- 测试结果如下：car对象构造方法注入成功

p名称空间注入
- 复制xmlns="http://www.springframework.org/schema/beans" ，将其改成：xmlns:p="http://www.springframework.org/schema/p" ，就可以引入p标签进行p名称空间注入的配置了
- p名称空间的依赖注入配置如下：

    <!-- 通过p名称空间注入user对象的普通值类型和引用类型 -->
    <!-- 
        普通值类型注入格式为：p:类属性="属性值"
        引用类型注入格式为：p:类中引用类型属性-ref="引用类型的name或i"
     -->
    <bean name="user_p" class="kong.spring.day02.pojo.User" p:username="kong" p:age="18" p:car-ref="car"/>

- 测试代码如下：

    // 使用注解手动注入在applicationContext.xml文件中通过p名称空间依赖注入的user_p对象
    @Resource(name = "user_p")
    private User user_p;
    
    // 测试p名称空间依赖注入
    @Test
    public void testPNameSpaceDi() {
        // 直接打印user对象，看其通过p名称空间是否注入成功
        System.out.println(user_p);
    }

- 测试结果如下：p名称空间依赖注入普通值类型和引用类型成功

SPEL（Spring EL表达式）依赖注入
- 不仅可以直接注入普通值类型和引用类型，还可以调用其它对象的属性和方法
- SPEL注入配置如下：

    <bean name="user_p" class="kong.spring.day02.pojo.User" p:username="kong" p:age="18" p:sex="男" p:car-ref="car"/>
    
     <!-- 通过SPEL表达式注入user对象的普通值类型和引用类型 -->
    <bean name="user_spel" class="kong.spring.day02.pojo.User">
        <!-- 普通值类型注入 -->
        <!-- 注意注入String类型时，要在注入值加''，即格式为#{'String类型值'}，不然会报错！ -->
        <!-- 为user_spel对象的username属性直接注入String类型值 -->
        <property name="username" value="#{'NulluN_SPEL'}"/>
        <!-- 通过调用上面user_p对象的returnNumber()方法为user_spel对象注入其age属性-->
        <property name="age" value="#{user_p.returnNumber()}"/>
        <!-- 通过调用上面user_p对象的sex属性为user_spel对象注入其sex属性-->
        <property name="sex" value="#{user_p.sex}"/>
        <!-- 引用（对象）类型注入  注意：引用类型注入不是用ref，还是用value，格式为#{引用类型的name或id值}-->
        <property name="car" value="#{car}"/>
    </bean>
    
    <bean name="car" class="kong.spring.day02.pojo.Car">
        <constructor-arg name="carName" value="玛莎拉蒂"/>
        <constructor-arg name="carPrice" value="1000000.00"/>
    </bean>

- 测试代码如下：

    // 使用注解手动注入在applicationContext.xml文件中通过spel表达式依赖注入的user_spel对象
    @Resource(name = "user_spel")
    private User user_spel;
    
    // 测试SPEL表达式依赖注入
    @Test
    public void testSpelDi() {
        // 直接打印user对象，看其通过spel表达式是否注入成功
        System.out.println(user_spel);
    }

- 测试结果：SPEL表达式注入普通值类型和引用类型、调用其它对象方法和属性都成功

复杂数据类型注入（数组、List、Set、Map）
- 复杂数据类型实体类如下：

package kong.spring.day02.pojo;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class CollectionInfo {
    private String[] ary;
    private List<String> list;
    private Set<String> sets;
    private Map<String, String> map;
    
    public String[] getAry() {
        return ary;
    }
    public void setAry(String[] ary) {
        this.ary = ary;
    }
    public List<String> getList() {
        return list;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public Set<String> getSets() {
        return sets;
    }
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    public Map<String, String> getMap() {
        return map;
    }
    public void setMap(Map<String, String> map) {
        this.map = map;
    }
    
    @Override
    public String toString() {
        return "CollectionInfo [ary=" + Arrays.toString(ary) + ", list=" + list + ", sets=" + sets + ", map=" + map
                + "]";
    }
}

- 配置如下：

    <!-- 复杂数据类型注入 -->
    <bean name="collection" class="kong.spring.day02.pojo.CollectionInfo">
        <!-- 数组注入 -->
        <property name="ary">
            <array>
                <value>曹操</value>
                <value>郭嘉</value>
                <value>曹丕</value>
            </array>
        </property>
        <!-- List注入 -->
        <property name="list">
            <list>
                <value>刘备</value>
                <value>关羽</value>
                <value>张飞</value>
            </list>        
        </property>
        <!-- Set注入 -->
        <property name="sets">
            <set>
                <value>孙权</value>
                <value>孙策</value>
                <value>鲁肃</value>
            </set>
        </property>
        <!-- Map注入 -->
        <property name="map">
            <map>
                <entry key="a" value="袁绍"/>
                <entry key="b" value="袁术"/>
                <entry key="c" value="吕布"/>
            </map>
        </property>
    </bean>

- 测试代码如下：

    // 使用注解手动注入在applicationContext.xml文件中注入的collection对象
    @Resource(name = "collection")
    private CollectionInfo collection;
    
    // 测试复杂数据类型依赖注入
    @Test
    public void testCollectionDi() {
        // 直接打印collection对象，看其是否注入值成功
        System.out.println(collection);
    }

- 测试结果：复杂数据类型值注入成功

Spring的分模块化管理的配置
- 加载多个配置文件方式一：在代码中加载配置文件时加载多个配置文件
  - 测试：将原来的applicationContext.xml文件中的复杂数据类型注入的配置剪切到另外一个中applicationContext2.xml的配置文件中，然后用如下代码同时加载这两个配置文件

//指定容器创建时加载哪个配置文件
@ContextConfiguration({"classpath:applicationContext.xml","classpath:applicationContext2.xml"})

public class DiTestDemo {

    // 使用注解手动注入在applicationContext2.xml文件中注入的collection对象
    @Resource(name = "collection")
    private CollectionInfo collection;

    // 测试复杂数据类型依赖注入
    @Test
    public void testCollectionDi() {
        // 直接打印collection对象，看其是否注入值成功
        System.out.println(collection);
    }
}

- - 测试结果：applicationContext2.xml加载成功

- 加载多个配置文件方式二：使用import标签导入
  - 测试：还是上面一样的两个配置文件，但在代码中还是只显式加载applicationContext.xml文件，而在applicationContext.xml文件在使用<import resource="applicationContext2.xml"/>来加载applicationContext2.xml
  - 在applicationContext.xml配置如下：

<import resource="applicationContext2.xml"/>

- - 测试代码如下：

@ContextConfiguration("classpath:applicationContext.xml")

public class DiTestDemo {

    // 使用注解手动注入在applicationContext2.xml文件中注入的collection对象
    @Resource(name = "collection")
    private CollectionInfo collection;

    // 测试复杂数据类型依赖注入
    @Test
    public void testCollectionDi() {
        // 直接打印collection对象，看其是否注入值成功
        System.out.println(collection);
    }
}

- - 测试结果：applicationContext2.xml加载成功

Spring-Day02-依赖注入-作业

猜你喜欢