Spring（二）IOC 和依赖注入

朴灿烈づ我的快乐病毒、 2021-06-22 15:37 538阅读 0赞

### 目录 ###

*  一、IOC概念
 *  二、使用Spring的IOC解决程序的耦合
 *   *  1. 案例的前期准备
     *  2. 基于XML的配置
 *  三、Spring基于XML的IOC细节
 *   *  1. Spring中工厂的类结构图
     *   *  ① BeanFactory和ApplicationContext的区别
         *  ② ApplicationContext接口的实现类
     *  2. IOC中bean标签和管理对象的细节
     *   *  ① bean标签
         *  ② 创建bean的三种方式
         *  ③ bean的作用范围
 *  四、spring的依赖注入
 *   *  1. 依赖注入的概念
     *  2. 构造函数注入
     *  3. set方法注入
     *  4. 注入集合数据

# 一、IOC概念 #

我们思考一下上一节最后的案例，

1.  **首先是我们创建的对象存在哪里？**  
    由于我们是有很多对象要创建使用的，**肯定要找个集合来存**。这时候有 Map 和 List 供选择。  
    到底选 Map 还是 List 就看我们有没有查找需求。**因为我们有查找的需求，选 Map。**
    
    所以我们的答案就是**在应用加载时，创建一个Map，用于存放三层对象。**  
    我们把这个 map 称之为容器。
2.  **那么什么是工厂呢？**  
    工厂就是负责给我们从容器中获取指定对象的类。这时候我们获取对象的方式发生了改变。

一开始我们是通过new的方式创建一个对象，例如：

private IAccountDao accountDao = new AccountDaoImpl();

我们需要用到对象的时候，我们就自己创建一个，这个过程 我们是主动的。  
后来，我们通过使用BeanFactory的方式，实现了让工厂给我一个对象的功能。

private IAccountDao accountDao = 
    	(IAccountDao) BeanFactory.getBean("accountDao");

这样我们获取对象的时候，是向工厂“索要”，工厂为我们创建或者查找对象。这个过程我们是被动的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]  
**这种被动接收资源的方式获取对象的思想就是控制反转，它是Spring框架的核心之一。**  
![在这里插入图片描述][20200508174647542.png]  
我们要明确IoC的作用，就是削减计算机程序的耦合（解除我们代码中的依赖关系）。

# 二、使用Spring的IOC解决程序的耦合 #

## 1. 案例的前期准备 ##

我们新建一个maven工程：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]  
导入maven坐标：

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 2]  
然后我们要创建一个简单的三层模型，供我们使用：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 3]  
**业务层接口和实现类：**

package com.veeja.service;
    
    /** * 账户业务层的接口 */
    public interface IAccountService { 
        /** * 模拟保存账户 */
        void saveAccount();
    }

package com.veeja.service.impl;
    
    import com.veeja.dao.IAccountDao;
    import com.veeja.dao.impl.AccountDaoImpl;
    import com.veeja.service.IAccountService;
    
    public class AccountServiceImpl implements IAccountService { 
    
        private IAccountDao accountDao = new AccountDaoImpl();
        
        @Override
        public void saveAccount() { 
            accountDao.saveAccount();
        }
    }

**持久层接口和实现类：**

package com.veeja.dao;
    
    /** * 账户的持久层接口 */
    public interface IAccountDao { 
    
        /** * 模拟保存账户 */
        void saveAccount();
    }

package com.veeja.dao.impl;
    
    import com.veeja.dao.IAccountDao;
    
    public class AccountDaoImpl implements IAccountDao { 
        @Override
        public void saveAccount() { 
            System.out.println("保存用户。");
        }
    }

## 2. 基于XML的配置 ##

在resources文件夹下面新建一个xml文件，名字可以随便起，只要不是中文都可以。  
![在这里插入图片描述][20200508182417768.png]  
内容中上面的约束文件是固定的，下面的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">
        
        
        <bean id="accountService" class="com.veeja.service.impl.AccountServiceImpl"></bean>
        <bean id="accountDao" class="com.veeja.dao.impl.AccountDaoImpl"></bean>
    </beans>

`bean` 标签：用于配置让 spring 创建对象，并且存入 ioc 容器之中  
`id` 属性：对象的唯一标识。  
`class` 属性：指定要创建对象的全限定类名

**我们可以测试一下配置是否成功：**

// 1. 获取核心容器
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    
    // 2. 根据id获取Bean对象（两种方式，用下面的两种方法之一就可以了）
    IAccountService as = (IAccountService) ac.getBean("accountService");
    IAccountDao accountDao = ac.getBean("accountDao", IAccountDao.class);
    
    System.out.println(as);
    System.out.println(accountDao);

我们可以看到，我们得到了相应的对象：  
![在这里插入图片描述][20200508183928558.png]  
这说明，我们的配置就算是成功了。

# 三、Spring基于XML的IOC细节 #

## 1. Spring中工厂的类结构图 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 4]

### ① BeanFactory和ApplicationContext的区别 ###

**BeanFactory 才是 Spring 容器中的顶层接口。**  
**ApplicationContext 是它的子接口。**

BeanFactory 和 ApplicationContext 的区别：创建对象的时间点不一样。  
`ApplicationContext`：它在构建核心容器的时候，创建对象采取的策略是立即加载的方式。也就是只要一读取配置文件，默认情况下就会创建对象。**适用于单例对象。**  
`BeanFactory`：它在构建核心容器的时候，创建对象采取的策略是延迟加载的方式。什么使用什么时候创建对象。**适用于多例对象。**

### ② ApplicationContext接口的实现类 ###

ApplicationContext的三个常用实现类：  
`ClassPathXmlApplicationContext`：可以加载类路径下的配置文件，要求配置文件必须在类路径下面。（推荐使用这种）  
`FileSystemApplicationContext`：可以加载磁盘任意路劲下的配置文件（必须有访问权限）  
`AnnotationConfigApplicationContext`：它可以读取注解创建容器。

## 2. IOC中bean标签和管理对象的细节 ##

### ① bean标签 ###

**作用：**  
用于配置对象让 spring 来创建的。  
默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。

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

### ② 创建bean的三种方式 ###

**第一种：使用默认的无参构造函数**  
在spring的配配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签。  
采用的就是默认的构造函数创建bean对象，此时如果类中没有默认的构造函数，则无法创建对象。

<bean id="accountService" class="com.veeja.service.impl.AccountServiceImpl"></bean>

如果我们覆写了构造函数，加上一个参数，我们在创建对象的时候，就会报错。

public class AccountServiceImpl implements IAccountService { 
        // 覆写了默认的构造函数，添加一个参数
        public AccountServiceImpl(String name) { 
            System.out.println("对象创建了。");
        }
    
        @Override
        public void saveAccount() { 
            System.out.println("执行方法：保存用户！");
        }
    }

![在这里插入图片描述][2020050822484538.png]

**第二种：使用spring管理实例工厂，使用实例工厂的方法创建对象**   
我们先模拟一个实例工厂，创建业务层实现类。  
这个工厂创建对象，必须先有工厂实例对象，再调用方法。  
例如：

package com.veeja.factory;
    
    import com.veeja.service.IAccountService;
    import com.veeja.service.impl.AccountServiceImpl;
    
    /** * 模拟一个实例工厂，创建业务层实现类 * 此工厂创建对象，必须现有工厂实例对象，再调用方法 */
    public class InstanceFactory { 
        public IAccountService getAccountService() { 
            return new AccountServiceImpl();
        }
    }

在需要使用普通工厂中的方法创建对象的时候（使用某个类中的方法创建对象，并存入spring容器）  
我们应该这样配置：

<bean id="instanceFactroy" class="com.veeja.factory.InstanceFactory"></bean>
    <bean id="accountService" factory-bean="instanceFactroy" factory-method="getAccountService"></bean>

**第三种：spring管理静态工厂，使用静态工厂的方法创建对象**   
创建一个工厂类，包含一个静态方法：

package com.veeja.factory;
    
    import com.veeja.service.IAccountService;
    import com.veeja.service.impl.AccountServiceImpl;
    
    /** * 模拟一个静态工厂类，创建业务层实现类 */
    public class StaticFactory { 
        public static IAccountService getAccountService() { 
            return new AccountServiceImpl();
        }
    }

我们应该使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器 。  
配置如下：

<bean id="accountService" class="com.veeja.factory.StaticFactory" factory-method="getAccountService"></bean>

### ③ bean的作用范围 ###

**bean的`scope`属性可以调整bean的作用范围。**

**单例对象：scope="singleton"**  
一个应用只有一个对象的实例。它的作用范围就是整个引用。  
**生命周期：**  
——对象出生：当应用加载，创建容器时，对象就被创建了。  
——对象活着：只要容器在，对象一直活着。  
——对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

**多例对象：scope="prototype"**  
每次访问对象时，都会重新创建对象实例。  
**生命周期：**  
——对象出生：当使用对象时，创建新的对象实例。  
——对象活着：只要对象在使用中，就一直活着。  
——对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

# 四、spring的依赖注入 #

## 1. 依赖注入的概念 ##

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

**依赖注入，能注入的数据有三类：**  
1. 基本类型和String  
2. 其他bean类型（在配置文件中或者注解配置过的bean）  
3. 复杂类型/集合类型  
**注入的方式，有三种：**  
1. 使用构造函数提供  
2. 使用set方法提供  
3. 使用注解提供

## 2. 构造函数注入 ##

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

public class AccountServiceImpl implements IAccountService { 
        // 如果是经常变化的数据，并不适用于注入的方式
        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);
        }
    }

bean.xml：

<bean id="accountService" class="com.veeja.service.impl.AccountServiceImpl">
        <constructor-arg type="java.lang.String" name="name" value="test"/>
        <constructor-arg name="age" value="18"/>
        <constructor-arg name="birthday" ref="now"/>
    </bean>
    
    <bean id="now" class="java.util.Date"></bean>

## 3. set方法注入 ##

顾名思义，就是在类中提供需要注入成员的 set 方法。具体代码如下：

public class AccountServiceImpl2 implements IAccountService { 
        // 如果是经常变化的数据，并不适用于注入的方式
        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.xml：

<bean id="accountService2" class="com.veeja.service.impl.AccountServiceImpl2">
        <property name="name" value="test"></property>
        <property name="age" value="18"></property>
        <property name="birthday" ref="now"></property>
    </bean>

## 4. 注入集合数据 ##

我们在里面创建各种各样的集合类型：

package com.veeja.service.impl;
    
    import com.veeja.service.IAccountService;
    
    import java.util.*;
    
    public class AccountServiceImpl3 implements IAccountService { 
    
        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(Arrays.toString(myStrs));
            System.out.println(myList);
            System.out.println(mySet);
            System.out.println(myMap);
            System.out.println(myProps);
        }
    }

bean.xml：

<bean id="accountService3" class="com.veeja.service.impl.AccountServiceImpl3">
        <property name="myStrs">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>BBB</value>
            </array>
        </property>
        <property name="myList">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>BBB</value>
            </list>
        </property>
        <property name="mySet">
            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>BBB</value>
            </set>
        </property>
        <property name="myMap">
            <map>
                <entry key="a" value="AAA"></entry>
                <entry key="b">
                    <value>BBB</value>
                </entry>
            </map>
        </property>
        <property name="myProps">
            <props>
                <prop key="aaa">AAA</prop>
                <prop key="bbb">BBB</prop>
                <prop key="ccc">CCC</prop>
            </props>
        </property>
    </bean>

--------------------

end.

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]: /images/20210615/24fbc4ff4e47454895893d16a9dd5284.png
[20200508174647542.png]: /images/20210615/902e3e722d6d4c82b099f41baddb7afa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]: /images/20210615/85a2a8f7f17347fc816de1f28095637c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 2]: /images/20210615/aebdd5a0fb3146aaa7fa59a921a39ede.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 3]: /images/20210615/00e1f75643024f11b789167e5bc8db1a.png
[20200508182417768.png]: /images/20210615/037628dccd944a48838f8b05f24b443e.png
[20200508183928558.png]: /images/20210615/6847e11df4844a2fa386581ad4344180.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 4]: /images/20210615/891f40c3ade0493ab28ce734f3d57cd5.png
[2020050822484538.png]: /images/20210615/a848ad92bed049d8909857e6f3e93482.png