第二章 SpringFramework

四、SpringIoC 实践和应用

1. SpringIoC / DI 实现步骤

1.1 配置元数据（配置）

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

<bean id="..." [1] class="..." [2]>  <!-- collaborators and configuration for this bean go here -->
</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/beanshttps://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容器的实例化工作：

//实例化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 定义并访问它们，如以下示例所示：

//创建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

<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 准备组件类

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

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

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

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

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

2.1.5.1 准备组件类

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

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

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

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

2.1.6.1 准备组建类

public class DefaultServiceLocator {private static ClientServiceImplclientService = new ClientServiceImpl();public ClientService createClientServiceInstance() {return clientService;}
}

2.1.6.2 xml配置文件编写

文件：resources/spring-bean-01.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 准备组件类

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

2.2.3.3 编写配置文件

文件：resources/spring-02.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 准备组件类

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 编写配置文件

<!-- 场景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 准备组件类

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 编写配置文件

<bean id="simpleMovieLister" class="examples.SimpleMovieLister"><!-- setter方法，注入movieFinder对象的标识idname = 属性名  ref = 引用bean的id值--><property name="movieFinder" ref="movieFinder" /><!-- setter方法，注入基本数据类型movieNamename = 属性名 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 容器实例化

//方式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对象读取

//方式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 周期方法声明

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

2.4.1.3 周期方法配置

<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 作用域配置

作用域配置

<!--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 作用域测试

@Test
public void testExperiment08()  {ApplicationContext iocContainer = new ClassPathXmlApplicationContext("配置文件名");HappyMachine bean = iocContainer.getBean(HappyMachine.class);HappyMachine bean1 = iocContainer.getBean(HappyMachine.class);//多例对比 falseSystem.out.println(bean == bean1);HappyComponent bean2 = iocContainer.getBean(HappyComponent.class);HappyComponent bean3 = iocContainer.getBean(HappyComponent.class);//单例对比 trueSystem.out.println(bean2 == bean3);
}