Spring 笔记（三）：使用 spring 的 IOC 解决程序耦合

✎例子

✎问题

一个程序过度耦合的例子：账户的业务层和持久层的依赖关系；

创建持久层接口和实现类

/**
* 账户的持久层接口
*/
public interface AccountDao {
    //保存账户
    void saveAccount();
}

/**
* 账户的持久层实现类
*/
public class AccountDaoImpl implements AccountDao {
    @Override
    public void saveAccount() {
    	System.out.println("保存了账户");
    }
}

创建业务层接口和实现类

/**
* 账户的业务层接口
*/
public interface AccountService {
    //保存账户（此处只是模拟，并不是真的要保存）
    void saveAccount();
}
/**
* 账户的业务层实现类

*/
public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao = new AccountDaoImpl();//此处的依赖关系有待解决
    @Override
    public void saveAccount() {
    	accountDao.saveAccount();
    }
}

上述例子中账户的业务层严重依赖于持久层，造成程序过度耦合；

✎如何解决？

使用以下方法创建 service 和 dao 对象：

需要一个配置文件来配置我们的 service 和 dao
- 配置的内容：唯一标识，全限定类名 (key, value)
- 配置文件可以是 xml 也可以是 properties
通过读取配置文件中配置的内容，反射创建对象

✎spring 基于 XML 的配置

项目结构

在 pom.xml 文件中添加如下依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.7.RELEASE</version>
</dependency>

在 resources 目录下创建 xml 配置文件 bean.xml，给配置文件导入约束，参考 spring 官方文档

让 spring 管理资源，在配置文件中配置 service 和 dao

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- bean 标签：用于配置让 spring 创建对象，并且存入 ioc 容器之中，Bean 在计算机英语中，有可重用组件的含义
        id 属性：对象的唯一标识。
        class 属性：指定要创建对象的全限定类名
    -->
    <!-- 配置 service -->
    <bean id="accountService" class="com.ourzh.service.impl.AccountServiceImpl"></bean>
    <!-- 配置 dao -->
    <bean id="accountDao" class="com.ourzh.dao.impl.AccountDaoImpl"></bean>
</beans>

测试配置是否成功

/**
* 模拟一个表现层
*/
public class Client {
    public static void main(String[] args) {
        //1.使用 ApplicationContext 接口，就是在获取 spring 容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        
        //2.根据 bean 的 id 获取对象
        AccountService aService = (AccountService) ac.getBean("accountService");
        System.out.println(aService);
        AccountDao aDao = (AccountDao) ac.getBean("accountDao");
        System.out.println(aDao);
    }
}

运行后能获取对象，则配置成功

✎细节讲解

✎spring 工厂的类结构

BeanFactory 和 ApplicationContext 的区别

BeanFactory 是 spring 容器中的顶层接口，ApplicationContext 是它的子接口。
主要区别：创建对象的时间点不一样。

ApplicationContext：在构建核心容器时，创建对象采取的策略是立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。适用于单例对象，常采用此接口；
BeanFactory：在构建核心容器时，创建对象采取的策略是延迟加载的方式。也就是说，什么时候根据 id 获取对象了，什么时候才真正的创建对象。适用于多例对象。

ApplicationContext 接口的实现类

ClassPathXmlApplicationContext：从类的根路径下加载配置文件，推荐使用；
FileSystemXmlApplicationContext：从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置（必须有访问权限）；
AnnotationConfigApplicationContext：使用注解配置容器对象。

✎bean 标签详解

✎bean 标签

作用：用于配置对象让 spring 来创建，并存入 IoC 容器之中。

默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

属性：

id：给对象在容器中提供一个唯一标识，用于获取对象。
class：指定类的全限定类名，用于反射创建对象。默认情况下调用无参构造函数。
scope：指定对象的作用范围。
- singleton : 单例的（默认值）
- prototype : 多例的
- request : WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
- session : WEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
- global session : WEB 项目中，应用在 Portlet（集群）环境。如果没有 Portlet 环境，那么 globalSession 相当于 session。
init-method：指定类中的初始化方法名称。
destroy-method：指定类中销毁方法名称。

✎bean 的作用范围和生命周期

单例对象： scope="singleton"，一个应用只有一个对象的实例，它的作用范围就是整个应用。
生命周期：
- 出生：当应用加载，创建容器时，对象就被创建了。
- 活着：只要容器在，对象一直活着。
- 死亡：当应用卸载，销毁容器时，对象就被销毁了。
- 总结：单例对象的生命周期和容器相同；
多例对象： scope="prototype"，每次访问对象时，都会重新创建对象实例。
生命周期：
- 出生：当使用对象时，创建新的对象实例。
- 活着：只要对象在使用中，就一直活着。
- 死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

✎实例化 Bean 的三种方式

使用默认无参构造函数（如果 bean 中没有默认无参构造函数，将会创建失败）
1
<bean id="accountService" class="com.ourzh.service.impl.AccountServiceImpl"></bean>

使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）

/**
* 模拟一个实例工厂，创建业务层实现类
* 此工厂创建对象，必须现有工厂实例对象，再调用方法
*/
public class InstanceFactory {
    public AccountService createAccountService(){
    	return new AccountServiceImpl();
    }
}

<!-- 
    factory-bean 属性：用于指定实例工厂 bean 的 id。
    factory-method 属性：用于指定实例工厂中创建对象的方法。
-->
<bean id="instancFactory" class="com.ourzh.factory.InstanceFactory"></bean>
<bean id="accountService" factory-bean="instancFactory" factory-method="createAccountService"></bean>

使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)

/**
* 模拟一个静态工厂，创建业务层实现类
*/
public class StaticFactory {
    public static AccountService createAccountService(){
    	return new AccountServiceImpl();
    }
}

<!-- 此种方式是:
    使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器
    id 属性：指定 bean 的 id，用于从容器中获取对象
    class 属性：指定静态工厂的全限定类名
    factory-method 属性：指定生产对象的静态方法
-->
<bean id="accountService" class="com.ourzh.factory.StaticFactory" factory-method="createAccountService"></bean>

✎spring 的依赖注入

我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

✎构造函数注入

顾名思义，就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让 spring 框架来为我们注入。

优势：在获取 bean 对象时，注入数据是必须的操作，否则对象无法创建成功。
弊端：改变了 bean 对象的实例化方式，使我们在创建对象时，即使用不到这些数据，也必须提供。

具体代码如下：

public class AccountServiceImpl implements AccountService {
    private String name;
    private Integer age;
    private Date birthday;
    public AccountServiceImpl(String name, Integer age, Date birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }
    
    @Override
    public void saveAccount() {
    	System.out.println(name+","+age+","+birthday);
    }
}

<!-- 使用构造函数的方式，给 service 中的属性传值
    要求：类中需要提供一个对应参数列表的构造函数。
    涉及的标签：
        constructor-arg
        	属性：
                index:指定参数在构造函数参数列表的索引位置
                type:指定参数在构造函数中的数据类型
                name:指定参数在构造函数中的名称 用这个找给谁赋值（常用）
                =======上面三个都是找给谁赋值，下面两个指的是赋什么值的==============
                value:它能赋的值是基本数据类型和 String 类型
                ref:它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中配置过的 bean
-->
<bean id="accountService" class="com.ourzh.service.impl.AccountServiceImpl">
    <constructor-arg name="name" value="张三"></constructor-arg>
    <constructor-arg name="age" value="18"></constructor-arg>
    <constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>

<bean id="now" class="java.util.Date"></bean>

✎set 方法注入

顾名思义，就是在类中提供需要注入成员的 set 方法。

优势：创建对象时没有明确的限制，可以直接使用默认构造函数；
弊端：如果有某个成员必须有值，则获取对象时有可能 set 方法没有执行。

具体代码如下：

public class AccountServiceImpl implements AccountService {
    private String name;
    private Integer age;
    private Date birthday;
    
    public void setName(String name) {
    	this.name = name;
    }
    
    public void setAge(Integer age) {
    	this.age = age;
    }
    
    public void setBirthday(Date birthday) {
    	this.birthday = birthday;
    }
    
    @Override
    public void saveAccount() {
    System.out.println(name+","+age+","+birthday);
    }
}

<!-- 通过配置文件给 bean 中的属性传值：使用 set 方法的方式
    涉及的标签：
        property
            属性：
                name：用于指定注入时所调用的 set 方法名称（找的是类中 set 方法后面的部分）
                value：给属性赋值是基本数据类型和 string 类型的
                ref：给属性赋值是其他 bean 类型的
    实际开发中，此种方式用的较多。
-->
<bean id="accountService" class="com.ourzh.service.impl.AccountServiceImpl">
    <property name="name" value="test"></property>
    <property name="age" value="21"></property>
    <property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>

<!-- 通过在导入 p 名称空间，使用 p:propertyName 来注入数据 -->
<bean id="accountService"
    class="com.itheima.service.impl.AccountServiceImpl"
    p:name="test" p:age="21" p:birthday-ref="now"/>

✎注入集合属性

顾名思义，就是给类中的集合成员传值，它用的也是 set 方法注入的方式，只不过变量的数据类型都是集合。

具体代码如下：

public class AccountServiceImpl implements AccountService {
    private String[] myStrs;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProps;
    
    public void setMyStrs(String[] myStrs) {
    	this.myStrs = myStrs;
    }
    
    public void setMyList(List<String> myList) {
    	this.myList = myList;
    }
    
    public void setMySet(Set<String> mySet) {
    	this.mySet = mySet;
    }
    
    public void setMyMap(Map<String, String> myMap) {
    	this.myMap = myMap;
    }
    
    public void setMyProps(Properties myProps) {
    this.myProps = myProps;
    }
    
    @Override
    public void saveAccount() {
        System.out.println(this.toString());
    }

    @Override
    public String toString() {
        return "AccountServiceImpl3{" +
                "myStrs=" + Arrays.toString(myStrs) +
                ", myList=" + myList +
                ", mySet=" + mySet +
                ", myMap=" + myMap +
                ", myProps=" + myProps +
                '}';
    }
}

<!-- 注入集合数据
    List 结构的：
    	array,list,set
    Map 结构的
    	map,entry,props,prop
-->
<bean id="accountService" class="com.ourzh.service.impl.AccountServiceImpl">
    <!-- 在注入集合数据时，只要结构相同，标签可以互换 -->
    <!-- 给数组注入数据 -->
    <property name="myStrs">
        <set>
            <value>AAA</value>
            <value>BBB</value>
            <value>CCC</value>
        </set>
    </property>
    <!-- 注入 list 集合数据 -->
    <property name="myList">
        <array>
            <value>AAA</value>
            <value>BBB</value>
            <value>CCC</value>
        </array>
    </property>
    <!-- 注入 set 集合数据 -->
    <property name="mySet">
        <list>
            <value>AAA</value>
            <value>BBB</value>
            <value>CCC</value>
        </list>
    </property>
    <!-- 注入 Map 数据 -->
    <property name="myMap">
        <props>
            <prop key="testA">aaa</prop>
            <prop key="testB">bbb</prop>
        </props>
    </property>
    <!-- 注入 properties 数据 -->
    <property name="myProps">
        <map>
            <entry key="testA" value="aaa"></entry>
            <entry key="testB">
            	<value>bbb</value>
            </entry>
        </map>
    </property>
</bean>