第二章 SpringFramework

四、SpringIoC 实践和应用

1. SpringIoC / DI 实现步骤

1.1 配置元数据（配置）

配置元数据，既是编写交给SpringIoC容器管理组件的信息，配置方式有三种。
基于 XML 的配置元数据的基本结构：

bash 复制代码

<bean id="..." [1] class="..." [2]>  
    <!-- collaborators and configuration for this bean go here -->
</bean>

xml 复制代码

<?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 id="..." [1] class="..." [2]>  
    <!-- collaborators and configuration for this bean go here -->
  </bean>

  <bean id="..." class="...">
    <!-- collaborators and configuration for this bean go here -->
  </bean>
  <!-- more bean definitions go here -->
</beans>

Spring IoC 容器管理一个或多个组件。这些组件是使用你提供给容器的配置元数据（例如，以 XML <bean/> 定义的形式）创建的。
<bean /> 标签 == 组件信息声明
- id 属性是标识单个 Bean 定义的字符串。
- class 属性定义 Bean 的类型并使用完全限定的类名。

1.2 实例化IoC容器

提供给 ApplicationContext 构造函数的位置路径是资源字符串地址，允许容器从各种外部资源（如本地文件系统、Java CLASSPATH 等）加载配置元数据。
我们应该选择一个合适的容器实现类，进行IoC容器的实例化工作：

java 复制代码

//实例化ioc容器,读取外部配置文件,最终会在容器内进行ioc和di动作
ApplicationContext context = 
           new ClassPathXmlApplicationContext("services.xml", "daos.xml");

1.3 获取Bean（组件）

ApplicationContext 是一个高级工厂的接口，能够维护不同 bean 及其依赖项的注册表。通过使用方法 T getBean(String name, Class<T> requiredType) ，您可以检索 bean 的实例。
允许读取 Bean 定义并访问它们，如以下示例所示：

java 复制代码

//创建ioc容器对象，指定配置文件，ioc也开始实例组件对象
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");
//获取ioc容器的组件对象
PetStoreService service = context.getBean("petStore", PetStoreService.class);
//使用组件对象
List<String> userList = service.getUsernameList();

2. 基于 XML 配置方式组件管理

2.1 实验一：组件（Bean）信息声明配置（IoC）

2.1.1 目标

Spring IoC 容器管理一个或多个 bean。这些 Bean 是使用您提供给容器的配置元数据创建的（例如，以 XML <bean/> 定义的形式）。
如何通过定义XML配置文件，声明组件类信息，交给 Spring 的 IoC 容器进行组件管理？

2.1.2 思路

2.1.3 准备项目

2.1.3.1 创建maven工程（spring-ioc-xml-01）

2.1.3.2 导入SpringIoC相关依赖

pom.xml

xml 复制代码

<dependencies>
    <!--spring context依赖-->
    <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.0.6</version>
    </dependency>
    <!--junit5测试-->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.3.1</version>
    </dependency>
</dependencies>

2.1.4 基于无参数构造函数

当通过构造函数方法创建一个 bean（组件对象）时，所有普通类都可以由 Spring 使用并与之兼容。也就是说，正在开发的类不需要实现任何特定的接口或以特定的方式进行编码。只需指定 Bean 类信息就足够了。但是，默认情况下，我们需要一个默认（空）构造函数。

2.1.4.1 准备组件类

java 复制代码

package com.alex.ioc;


public class HappyComponent {

    //默认包含无参数构造函数

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

2.1.4.2 xml配置文件编写

创建携带spring约束的xml配置文件
编写配置文件：
- 文件：resources/spring-bean-01.xml

java 复制代码

<!-- 实验一 [重要]创建bean -->
<bean id="happyComponent" class="com.alex.ioc.HappyComponent"/>

bean标签：通过配置bean标签告诉IOC容器需要创建对象的组件信息
id属性：bean的唯一标识，方便后期获取Bean！
class属性：组件类的全限定符！
注意：要求当前组件类必须包含无参数构造函数！

2.1.5 基于静态工厂方法实例化

除了使用构造函数实例化对象，还有一类是通过工厂模式实例化对象。如何定义使用静态工厂方法创建Bean的配置？

2.1.5.1 准备组件类

java 复制代码

public class ClientService {
  private static ClientService clientService = new ClientService();
  private ClientService() {}

  public static ClientService createInstance() {
  
    return clientService;
  }
}

2.1.5.2 xml配置文件编写

文件：resources/spring-bean-01.xml

xml 复制代码

<bean id="clientService"
  class="examples.ClientService"
  factory-method="createInstance"/>

class属性：指定工厂类的全限定符！
factory-method: 指定静态工厂方法，注意，该方法必须是static方法。

2.1.6 基于实例工厂方法实例化

2.1.6.1 准备组建类

java 复制代码

public class DefaultServiceLocator {

  private static ClientServiceImplclientService = new ClientServiceImpl();

  public ClientService createClientServiceInstance() {
    return clientService;
  }
}

2.1.6.2 xml配置文件编写

文件：resources/spring-bean-01.xml

xml 复制代码

<!-- 将工厂类进行ioc配置 -->
<bean id="serviceLocator" class="examples.DefaultServiceLocator">
</bean>

<!-- 根据工厂对象的实例工厂方法进行实例化组件对象 -->
<bean id="clientService"
  factory-bean="serviceLocator"
  factory-method="createClientServiceInstance"/>

factory-bean属性：指定当前容器中工厂Bean 的名称。
factory-method: 指定实例工厂方法名。注意，实例方法必须是非static的！

2.1.7 图解IoC配置流程

2.2 实验二：组件（Bean）依赖注入配置（DI）

2.2.1 目标

通过配置文件,实现IoC容器中Bean之间的引用（依赖注入DI配置）。
主要涉及注入场景：基于构造函数的依赖注入和基于 Setter 的依赖注入。

2.2.2 思路

2.2.3 基于构造函数的依赖注入（单个构造参数）

2.2.3.1 介绍

基于构造函数的 DI 是通过容器调用具有多个参数的构造函数来完成的，每个参数表示一个依赖项。
下面的示例演示一个只能通过构造函数注入进行依赖项注入的类！

2.2.3.2 准备组件类

java 复制代码

public class UserDao {
}


public class UserService {
    
    private UserDao userDao;

    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }
}

2.2.3.3 编写配置文件

文件：resources/spring-02.xml

xml 复制代码

<beans>
  <!-- 引用类bean声明 -->
  <bean id="userService" class="x.y.UserService">
   <!-- 构造函数引用 -->
    <constructor-arg ref="userDao"/>
  </bean>
  <!-- 被引用类bean声明 -->
  <bean id="userDao" class="x.y.UserDao"/>
</beans>

constructor-arg标签：可以引用构造参数 ref 引用其他bean的标识。

2.2.4 基于构造函数的依赖注入（多构造参数解析）

2.2.4.1 介绍

基于构造函数的 DI 是通过容器调用具有多个参数的构造函数来完成的，每个参数表示一个依赖项。
下面的示例演示通过构造函数注入多个参数，参数包含其他bean和基本数据类型！

2.2.4.2 准备组件类

java 复制代码

public class UserDao {
}


public class UserService {
    
    private UserDao userDao;
    
    private int age;
    
    private String name;

    public UserService(int age , String name ,UserDao userDao) {
        this.userDao = userDao;
        this.age = age;
        this.name = name;
    }
}

2.2.4.3 编写配置文件

xml 复制代码

<!-- 场景1: 多参数，可以按照相应构造函数的顺序注入数据 -->
<beans>
  <bean id="userService" class="x.y.UserService">
    <!-- value直接注入基本类型值 -->
    <constructor-arg  value="18"/>
    <constructor-arg  value="赵伟风"/>
    
    <constructor-arg  ref="userDao"/>
  </bean>
  <!-- 被引用类bean声明 -->
  <bean id="userDao" class="x.y.UserDao"/>
</beans>


<!-- 场景2: 多参数，可以按照相应构造函数的名称注入数据 -->
<beans>
  <bean id="userService" class="x.y.UserService">
    <!-- value直接注入基本类型值 -->
    <constructor-arg name="name" value="赵伟风"/>
    <constructor-arg name="userDao" ref="userDao"/>
    <constructor-arg name="age"  value="18"/>
  </bean>
  <!-- 被引用类bean声明 -->
  <bean id="userDao" class="x.y.UserDao"/>
</beans>

<!-- 场景2: 多参数，可以按照相应构造函数的角标注入数据 
           index从0开始 构造函数(0,1,2....)
-->
<beans>
    <bean id="userService" class="x.y.UserService">
    <!-- value直接注入基本类型值 -->
    <constructor-arg index="1" value="赵伟风"/>
    <constructor-arg index="2" ref="userDao"/>
    <constructor-arg index="0"  value="18"/>
  </bean>
  <!-- 被引用类bean声明 -->
  <bean id="userDao" class="x.y.UserDao"/>
</beans>

constructor-arg标签：指定构造参数和对应的值
constructor-arg标签：name属性指定参数名、index属性指定参数角标、value属性指定普通属性值

2.2.5 基于Setter方法依赖注入

2.2.5.1 介绍

开发中，除了构造函数注入（DI）更多的使用的Setter方法进行注入！
下面的示例演示一个只能使用纯 setter 注入进行依赖项注入的类。

2.2.5.2 准备组件类

java 复制代码

public Class MovieFinder{

}

public class SimpleMovieLister {

  private MovieFinder movieFinder;
  
  private String movieName;

  public void setMovieFinder(MovieFinder movieFinder) {
    this.movieFinder = movieFinder;
  }
  
  public void setMovieName(String movieName){
    this.movieName = movieName;
  }

  // business logic that actually uses the injected MovieFinder is omitted...
}

2.2.5.3 编写配置文件

xml 复制代码

<bean id="simpleMovieLister" class="examples.SimpleMovieLister">
  <!-- setter方法，注入movieFinder对象的标识id
       name = 属性名  ref = 引用bean的id值
   -->
  <property name="movieFinder" ref="movieFinder" />

  <!-- setter方法，注入基本数据类型movieName
       name = 属性名 value= 基本类型值
   -->
  <property name="movieName" value="消失的她"/>
</bean>

<bean id="movieFinder" class="examples.MovieFinder"/>

property标签：可以给setter方法对应的属性赋值
property标签：name属性代表set方法标识、ref代表引用bean的标识id、value属性代表基本属性值

总结：

依赖注入（DI）包含引用类型和基本数据类型，同时注入的方式也有多种！主流的注入方式为setter方法注入和构造函数注入！
需要特别注意：引用其他bean，使用ref属性。直接注入基本类型值，使用value属性。

2.3 实验三：IoC 容器创建和使用

2.3.1 介绍

上面的实验只是讲解了如何在XML格式的配置文件编写IoC和DI配置！
如图：
想要配置文件中声明组件类信息真正的进行实例化成Bean对象和形成Bean之间的引用关系，我们需要声明IoC容器对象，读取配置文件，实例化组件和关系维护的过程都是在IoC容器中实现的！

2.3.2 容器实例化

java 复制代码

//方式1:实例化并且指定配置文件
//参数：String...locations 传入一个或者多个配置文件
ApplicationContext context = 
           new ClassPathXmlApplicationContext("services.xml", "daos.xml");
           
//方式2:先实例化，再指定配置文件，最后刷新容器触发Bean实例化动作 [springmvc源码和contextLoadListener源码方式]  
ApplicationContext context = 
           new ClassPathXmlApplicationContext();   
//设置配置配置文件,方法参数为可变参数,可以设置一个或者多个配置
context.setConfigLocations("services.xml", "daos.xml");
//后配置的文件,需要调用refresh方法,触发刷新配置
context.refresh();

2.3.3 Bean对象读取

java 复制代码

//方式1: 根据id获取
//没有指定类型,返回为Object,需要类型转化!
HappyComponent happyComponent = 
        (HappyComponent) iocContainer.getBean("bean的id标识");
        
//使用组件对象        
happyComponent.doWork();

//方式2: 根据类型获取
//根据类型获取,但是要求,同类型(当前类,或者之类,或者接口的实现类)只能有一个对象交给IoC容器管理
//配置两个或者以上出现: org.springframework.beans.factory.NoUniqueBeanDefinitionException 问题
HappyComponent happyComponent = iocContainer.getBean(HappyComponent.class);
happyComponent.doWork();

//方式3: 根据id和类型获取
HappyComponent happyComponent = iocContainer.getBean("bean的id标识", HappyComponent.class);
happyComponent.doWork();

// 根据类型来获取bean时，在满足bean唯一性的前提下，其实只是看：『对象 instanceof 指定的类型』的返回结果，
// 只要返回的是true就可以认定为和类型匹配，能够获取到。

2.4 实验四：高级特性：组件（bean）作用域和周期方法配置

2.4.1 组件周期方法配置

2.4.1.1 周期方法概念

我们可以在组件类中定义方法，然后当IoC容器实例化和销毁组件对象的时候进行调用！这两个方法我们成为生命周期方法！
类似于Servlet的init/destroy方法,我们可以在周期方法完成初始化和释放资源等工作。

2.4.1.2 周期方法声明

java 复制代码

public class BeanOne {

  //周期方法要求： 方法命名随意，但是要求方法必须是 public void 无形参列表
  public void init() {
    // 初始化逻辑
  }
}

public class BeanTwo {

  public void cleanup() {
    // 释放资源逻辑
  }
}

2.4.1.3 周期方法配置

xml 复制代码

<beans>
  <bean id="beanOne" class="examples.BeanOne" init-method="init" />
  <bean id="beanTwo" class="examples.BeanTwo" destroy-method="cleanup" />
</beans>

2.4.2 组件作用域配置

2.4.2.1 Bean作用域概念

<bean> 标签声明Bean，只是将Bean的信息配置给SpringIoC容器！
在IoC容器中，这些<bean>标签对应的信息转成Spring内部 BeanDefinition 对象，BeanDefinition 对象内，包含定义的信息（id,class,属性等等）！
这意味着，BeanDefinition与类概念一样，SpringIoC容器可以根据BeanDefinition对象反射创建多个Bean对象实例。
具体创建多少个Bean的实例对象，由Bean的作用域Scope属性指定！

2.4.2.2 作用域可选值

取值	含义	创建对象的时机	默认值
singleton	在 IOC 容器中，这个 bean 的对象始终为单实例	IOC 容器初始化时	是
prototype	这个 bean 在 IOC 容器中有多个实例	获取 bean 时	否

如果是在WebApplicationContext环境下还会有另外两个作用域（但不常用）：

取值	含义	创建对象的时机	默认值
request	请求范围内有效的实例	每次请求	否
session	会话范围内有效的实例	每次会话	否

2.4.2.3 作用域配置

作用域配置

xml 复制代码

<!--bean的作用域 
    准备两个引用关系的组件类即可！！
-->
<!-- scope属性：取值singleton（默认值），bean在IOC容器中只有一个实例，IOC容器初始化时创建对象 -->
<!-- scope属性：取值prototype，bean在IOC容器中可以有多个实例，getBean()时创建对象 -->
<bean id="happyMachine8" scope="prototype" class="com.alex.ioc.HappyMachine">
    <property name="machineName" value="happyMachine"/>
</bean>

<bean id="happyComponent8" scope="singleton" class="com.alex.ioc.HappyComponent">
    <property name="componentName" value="happyComponent"/>
</bean>

2.4.2.4 作用域测试

java 复制代码

@Test
public void testExperiment08()  {
    ApplicationContext iocContainer = new ClassPathXmlApplicationContext("配置文件名");

    HappyMachine bean = iocContainer.getBean(HappyMachine.class);
    HappyMachine bean1 = iocContainer.getBean(HappyMachine.class);
    //多例对比 false
    System.out.println(bean == bean1);

    HappyComponent bean2 = iocContainer.getBean(HappyComponent.class);
    HappyComponent bean3 = iocContainer.getBean(HappyComponent.class);
    //单例对比 true
    System.out.println(bean2 == bean3);
}

SSM - Springboot - MyBatis-Plus 全栈体系（四）

第二章 SpringFramework

四、SpringIoC 实践和应用

1. SpringIoC / DI 实现步骤

1.1 配置元数据（配置）

1.2 实例化IoC容器

1.3 获取Bean（组件）

2. 基于 XML 配置方式组件管理

2.1 实验一：组件（Bean）信息声明配置（IoC）

2.1.1 目标

2.1.2 思路

2.1.3 准备项目

2.1.3.1 创建maven工程（spring-ioc-xml-01）

2.1.3.2 导入SpringIoC相关依赖

2.1.4 基于无参数构造函数

2.1.4.1 准备组件类

2.1.4.2 xml配置文件编写

2.1.5 基于静态工厂方法实例化

2.1.5.1 准备组件类

2.1.5.2 xml配置文件编写

2.1.6 基于实例工厂方法实例化

2.1.6.1 准备组建类

2.1.6.2 xml配置文件编写

2.1.7 图解IoC配置流程

2.2 实验二：组件（Bean）依赖注入配置（DI）

2.2.1 目标

2.2.2 思路

2.2.3 基于构造函数的依赖注入（单个构造参数）

2.2.3.1 介绍

2.2.3.2 准备组件类

2.2.3.3 编写配置文件

2.2.4 基于构造函数的依赖注入（多构造参数解析）

2.2.4.1 介绍

2.2.4.2 准备组件类

2.2.4.3 编写配置文件

2.2.5 基于Setter方法依赖注入

2.2.5.1 介绍

2.2.5.2 准备组件类

2.2.5.3 编写配置文件

2.3 实验三：IoC 容器创建和使用

2.3.1 介绍

2.3.2 容器实例化

2.3.3 Bean对象读取

2.4 实验四：高级特性：组件（bean）作用域和周期方法配置

2.4.1 组件周期方法配置

2.4.1.1 周期方法概念

2.4.1.2 周期方法声明

2.4.1.3 周期方法配置

2.4.2 组件作用域配置

2.4.2.1 Bean作用域概念

2.4.2.2 作用域可选值

2.4.2.3 作用域配置

2.4.2.4 作用域测试