Spring IoC DI 从入门到入坑。

Spring

---

---

Spring IoC。

IoC ——> Inversion of Control，控制反转
～
inverse
a. （数量、位置）相反的，反向的；反面；相反的事物
vt. 使倒转；使颠倒
~
control
n. （对国家、地区、机构等）管理权，控制权，支配权；控制（或操纵）能力；限制；限定；约束；管理；管制
v. 指挥；控制；掌管；支配；限定；阻止蔓延（或恶化）

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。
—— 百科。

Spring Bean 的三种创建方式。

<!-- 创建 bean 的三种方式。
    在 Spring 的配置文件中使用 bean 标签，配置 id 和 class 之后，且没有其他属性和标签时，
    使用的就是默认构造函数创建 bean 对象。此时如果类中没有默认构造函数则对象无法创建。
-->
<!--<bean id="accountService" class="com.geek.service.impl.AccountServiceImpl"></bean>-->

此时要求 class AccountServiceImpl 有默认构造函数。

package com.geek.service.impl;

import com.geek.service.IAccountService;

/**
 * 账户的业务层实现类。
 */
public class AccountServiceImpl implements IAccountService {

    public AccountServiceImpl() {
        System.out.println("默认构造方法。");
    }

    public void saveAccount() {
        System.out.println("service 中的 saveAccount()方法 执行了。");
    }
}

    <!--  * 模拟一个工厂类。（该类可能是存在于 jar 包中的，我们无法通过修改源码的方式来提供默认构造函数）。
    使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入 Spring 容器中）。
-->
    <bean id="instanceFactory" class="com.geek.factory.InstanceFactory"/>
    <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"/>

factory-bean 指定使用哪个类作为工厂类。
factory-method 指定使用工厂类的哪个方法。

工厂类。

package com.geek.factory;

import com.geek.service.IAccountService;
import com.geek.service.impl.AccountServiceImpl;

/**
 * 模拟一个工厂类。（该类可能是存在于 jar 包中的，我们无法通过修改源码的方式来提供默认构造函数）。
 */
public class InstanceFactory {

    public IAccountService getAccountService() {
        return new AccountServiceImpl();
    }
}

    <!-- 方法 3。
        使用工厂中的静态方法创建对象。（使用某个类中的静态方法创建对象，并存入 Spring 容器）。
    -->
    <bean id="accountService" class="com.geek.factory.StaticInstanceFactory" factory-method="getAccountService"/>

package com.geek.factory;

import com.geek.service.IAccountService;
import com.geek.service.impl.AccountServiceImpl;

/**
 * 模拟一个工厂类。（该类可能是存在于 jar 包中的，我们无法通过修改源码的方式来提供默认构造函数）。
 */
public class StaticInstanceFactory {

    public static IAccountService getAccountService() {
        return new AccountServiceImpl();
    }
}

bean 的作用范围。

    <!-- bean 的作用范围。
        使用 bean 标签的 scope 属性指定。
    -->
    <bean id="accountService" class="com.geek.service.impl.AccountServiceImpl"
          scope="singleton"
    />

scope 取值。

• singleton —— 单例（默认）。
• prototype —— 多例。
• request —— 作用于 Web 应用的请求范围。
• session —— 作用于 Web 应用的会话范围。
• global-session —— 作用于集群环境的会话范围。（全局会话范围）。如果还是集群环境，和 session 一样。（5.0 版本已不再支持）。（负载均衡使用）。

使用 singleton —> 单例模式。—> true。（默认）。
使用 prototype —> 多例模式。—> false。

package com.geek.ui;

import com.geek.service.IAccountService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 模拟一个表现层，用于调用业务层。
 */
public class Client {

    /**
     * 获取 SpringIoC 核心容器，并根据 id 获取对象。
     *
     * @param args
     */
    public static void main(String[] args) {

        // 创建核心容器对象。
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
        // 根据 id 获取 Bean 对象。
        IAccountService accountService1 = (IAccountService) applicationContext.getBean("accountService");
        IAccountService accountService2 = (IAccountService) applicationContext.getBean("accountService");

        System.out.println(accountService1 == accountService2);
    }
}

bean 对象生命周期。

单例对象。

出生：容器创建时。
活着：容器 ing。
死亡：容器销毁，对象消亡。
（调用）

   // 手动关闭容器。
   applicationContext.close();

就会 destroy-method="destroy"。

多例对象。

出生：当使用对象时，Spring 才为我们创建。
活着：对象在使用过程中就一直活着。
死亡：当对象长时间不使用且没有引用，gc 回收。

    <bean id="accountService" class="com.geek.service.impl.AccountServiceImpl"
          scope="singleton" init-method="init" destroy-method="destroy"/>
    />

package com.geek.service.impl;

import com.geek.service.IAccountService;

/**
 * 账户的业务层实现类。
 */
public class AccountServiceImpl implements IAccountService {

    public AccountServiceImpl() {
        System.out.println("默认构造方法。（对象创建了）。");
    }

    public void saveAccount() {
        System.out.println("service 中的 saveAccount()方法 执行了。");
    }

    public void init() {
        System.out.println("init...");
    }

    public void destroy() {
        System.out.println("destroy...");
    }
}

想要容器销毁，要手动关闭容器。

package com.geek.ui;

import com.geek.service.IAccountService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 模拟一个表现层，用于调用业务层。
 */
public class Client {

    /**
     * 获取 SpringIoC 核心容器，并根据 id 获取对象。
     *
     * @param args
     */
    public static void main(String[] args) {

        // 创建核心容器对象。
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
        // 根据 id 获取 Bean 对象。
        IAccountService accountService1 = (IAccountService) applicationContext.getBean("accountService");
//        IAccountService accountService2 = (IAccountService) applicationContext.getBean("accountService");

        System.out.println(accountService1);

        // 手动关闭容器。
        applicationContext.close();
    }
}

Spring DI。

DI ——> dependency injection
～
dependency
n. （尤指不正常或不必要的）依靠，依赖；附属国；附属地
～
injection
注射；大量资金的投入；（液体）注入，喷入

IOC 的作用：降低程序间的耦合（依赖关系）。
依赖关系的管理以后交给 Spring 来维护。
在当前类要用到的其他类的对象，由 Spring 为我们提供，我们只要在配置文件中说明。

依赖关系的维护
称之为依赖注入。

依赖注入：
能注入的数据有 3 类。

• 基本类型和 String。
• 其他 bean 类型（在配置文件中或注解配置过的 bean）。
• 复杂类型 / 集合类型。
  ～
  注入的方式有 3 种。
• 构造函数。
• set() 方法。
• 注解。

package com.geek.ui;

import com.geek.service.IAccountService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 模拟一个表现层，用于调用业务层。
 */
public class Client {

    /**
     * 获取 SpringIoC 核心容器，并根据 id 获取对象。
     *
     * @param args
     */
    public static void main(String[] args) {

        // 创建核心容器对象。
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
        // 根据 id 获取 Bean 对象。
        IAccountService accountService = (IAccountService) applicationContext.getBean("accountService");

        accountService.saveAccount();

    }
}

使用构造函数注入。

    <!-- 构造函数注入。-->
    <!--<bean id="accountService" class="com.geek.service.impl.AccountServiceImpl"/>-->
    <!-- 此方法是用默认构造函数。-->
    <!-- bean 标签中使用标签：constructor-arg。-->

标签中的属性。

    <!-- 构造函数注入。-->
    <!--<bean id="accountService" class="com.geek.service.impl.AccountServiceImpl"/>-->
    <!-- 此方法是用默认构造函数。-->
    <!-- bean 标签中使用标签：constructor-arg。-->
    <bean id="accountService" class="com.geek.service.impl.AccountServiceImpl">
        <!--
            标签中的属性。
                type ——> 用于指定要注入的数据的数据类型，该数据类型是构造函数中某个或某些参数的类型。
                index ——> 用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引从 0 开始。
                name ——> 用于指定给构造函数中指定名称的参数赋值。——> 常用。
                ～ ～ ～ ～ ～ ～ 以上三个用于指定给构造函数中哪个参数赋值。
                value ——> 用于提供基本类型和 String 类型的数据。
                ref ——> 用于指定其他的 bean 类型数据。ta 指的就是在 Spring 的 IoC 核心容器中出现过的 bean 对象 。
        -->
        <constructor-arg name="name" value="test"/>
        <constructor-arg name="age" value="25"/>
        <!--<constructor-arg name="birthday" value="1970-01-01"/>&lt;!&ndash; 'java.util.Date'&ndash;&gt;-->
        <constructor-arg name="birthday" ref="now"/><!-- 'java.util.Date'-->
    </bean>

    <!-- 配置一个日期对象。-->
    <bean id="now" class="java.util.Date"/>

运行效果。

service 中的 saveAccount()方法 执行了。, test, 25, Thu Mar 12 23:42:11 CST 2020

优势。

在获取 bean 对象时，注入数据必须的操作，否则对象无法成功创建。

弊端。

改变了 bean 对象实例化的方式，使我们在创建对象时，如果用不到这些数据，也必须提供。

set(); 方法注入。

    <!-- set(); 方法注入。-->
    <bean id="accountServiceImpl02" class="com.geek.service.impl.AccountServiceImpl02">
        <!-- 标签的属性。
                name ——> 用于指定注入时所调用的 set(); 方法名称。
                value ——> 用于提供基本类型和 String 类型的数据。
                ref ——> 用于指定其他的 bean 类型数据。ta 指的就是在 Spring 的 IoC 核心容器中出现过的 bean 对象 。
        -->
        <property name="name" value="泰斯特"/>
        <property name="age" value="21"/>
        <property name="birthday" ref="now"/>

    </bean>

service 中的 saveAccount()方法 执行了。, 泰斯特, 21, Fri Mar 13 00:01:54 CST 2020

优势。

创建对象时没有明确的限制，可以直接使用默认构造函数。

弊端。

如果有某个成员变量必须有值，则获取对象时 set(); 方法有可能没有执行。

注入集合数据。

package com.geek.service.impl;

import com.geek.service.IAccountService;

import java.util.*;

/**
 * 账户的业务层实现类。
 */
public class AccountServiceImpl03 implements IAccountService {

    // 如果是经常变化的数据，并不适用于注入的方式。
    private String[] myStrings;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String, String> myMap;
    private Properties myProps;

    public void setMyStrings(String[] myStrings) {
        this.myStrings = myStrings;
    }

    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(myStrings));
        System.out.println("myList = " + myList);
        System.out.println("mySet = " + mySet);
        System.out.println("myMap = " + myMap);
        System.out.println("myProps = " + myProps);
    }
}

复杂类型的注入。

• 用于给 list 结构注入的标签有。

list
array
set

• 用于给 map 结构注入的标签有。

map
props

• => 结构相同，标签可以互换。

    <!-- 复杂类型的注入。（集合类型）。-->
    <bean id="accountService03" class="com.geek.service.impl.AccountServiceImpl03">
        <property name="myStrings">
            <array>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </array>
        </property>

        <property name="myList">
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>

        <property name="mySet">
            <set>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </set>
        </property>

        <!--        <property name="myMap">
                    <map>
                        <entry key="test" value="aaa"/>
                    </map>
                </property>-->
        <property name="myMap">
            <map>
                <entry key="test">
                    <value>bbb</value>
                </entry>
            </map>
        </property>

        <property name="myProps">
            <props>
                <prop key="testC">ccc</prop>
                <prop key="testD">ddd</prop>
            </props>
        </property>
    </bean>