Spring简介

Spring是一个开源框架，为简化企业级开发而生。它以IOC（控制反转）和AOP（面向切面）为思想内核，提供了控制层 SpringMVC、数据层SpringData、服务层事务管理等众多技术，并可以整合众多第三方框架。 Spring将很多复杂的代码变得优雅简洁，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。

Spring官网地址：https://spring.io/

Spring体系结构

Spring框架根据不同的功能被划分成了多个模块，这些模块可以满足一切企业级应用开发的需求，在开发过程中可以根据需求有选择性地使用所需要的模块。

1、Core Container：Spring核心模块，任何功能的使用都离不开该模块，是其他模块建立的基础。
2、Data Access/Integration：该模块提供了数据持久化的相应功能。3、Web：该模块提供了web开发的相应功能。4、AOP：提供了面向切面编程实现5、Aspects：提供与AspectJ框架的集成，该框架是一个面向切面编程框架。6、Instrumentation：提供了类工具的支持和类加载器的实现，可以在特定的应用服务器中使用。7、Messaging：为Spring框架集成一些基础的报文传送应用8、Test：提供与测试框架的集成

IOC_控制反转思想

IOC(Inversion of Control) ：程序将创建对象的权利交给框架。之前在开发过程中，对象实例的创建是由调用者管理的，代码如下：

public interface StudentDao {
    // 根据id查询学生
    Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟从数据库查找出学生
        return new Student(1,"程序员","北京");
   }
}
public class StudentService {
    public Student findStudentById(int id){
        // 此处就是调用者在创建对象
        StudentDao studentDao = new StudentDaoImpl();
        return studentDao.findById(1);
   }
}

这种写法有两个缺点：

1 浪费资源：StudentService调用方法时即会创建一个对象，如果不断调用方法则会创建大量StudentDao对象。

2 代码耦合度高：假设随着开发，我们创建了StudentDao另一个更加完善的实现类StudentDaoImpl2，如果在StudentService 中想使用StudentDaoImpl2，则必须修改源码。

而IOC思想是将创建对象的权利交给框架，框架会帮助我们创建对象，分配对象的使用，控制权由程序代码转移到了框架中，控制权发生了反转，这就是Spring的IOC思想。而IOC思想可以完美的解决以上两个问题。

IOC_自定义对象容器

接下来我们通过一段代码模拟IOC思想。创建一个集合容器，先将对象创建出来放到容器中，需要使用对象时，只需要从容器中获取对象即可，而不需要重新创建，此时容器就是对象的管理者。

创建实体类

public class Student {
    private int id;
    private String name;
    private String address;
 // 省略getter/setter/构造方法/tostring
}

创建Dao接口和实现类

public interface StudentDao {
    // 根据id查询学生
    Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟从数据库查找出学生
        return new Student(1,"程序员","北京");
   }
}
public class StudentDaoImpl2 implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟根据id查询学生
        System.out.println("新方法！！！");
        return new Student(1,"程序员","北京");
   }
}

创建配置文件bean.properties，该文件中定义管理的对象

studentDao=com.itbaizhan.dao.StudentDaoImpl

创建容器管理类，该类在类加载时读取配置文件，将配置文件中配置的对象全部创建并放入容器中。

public class Container {
    static Map<String,Object> map = new HashMap();
    static {
        // 读取配置文件
        InputStream is = Container.class.getClassLoader().getResourceAsStream("bean.properties");
        Properties properties = new Properties();
        try {
            properties.load(is);
       } catch (IOException e) {
            e.printStackTrace();
       }
        // 遍历配置文件的所有配置
        Enumeration<Object> keys = properties.keys();
        while (keys.hasMoreElements()){
            String key = keys.nextElement().toString();
            String value = properties.getProperty(key);
            try {
                // 创建对象
                Object o = Class.forName(value).newInstance();
                // 将对象放入集合中
                map.put(key,o);
           } catch (Exception e) {
                e.printStackTrace();
           }
       }
   }
    // 从容器中获取对象
 public static Object getBean(String key){
        return map.get(key);
   }
}

创建Dao对象的调用者StudentService

public class StudentService {
    public Student findStudentById(int id)
     {
        // 从容器中获取对象
        StudentDao studentDao = (StudentDao) Container.getBean("studentDao");
        System.out.println(studentDao.hashCode());
        return studentDao.findById(id);
   }
}

测试StudentService

public class Test {
    public static void main(String[] args)
    {
      StudentService studentService = new StudentService();
      System.out.println(studentService.findStudentById(1));
      System.out.println(studentService.findStudentById(1));
   }
}

IOC_Spring实现IOC

接下来我们使用Spring实现IOC，Spring内部也有一个容器用来管理对象。

创建Maven工程，引入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.13</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

创建POJO类、Dao类和接口

public class Student {
    private int id;
    private String name;
    private String address;
  // 省略getter/setter/构造方法/tostring
}
public interface StudentDao {
    // 根据id查询学生
    Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟从数据库查找出学生
        return new Student(1,"程序员","北京");
   }
}

编写xml配置文件，配置文件中配置需要Spring帮我们创建的对象。

<?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="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>     
</beans>

测试从Spring容器中获取对象。

public class TestContainer {
    @Test
    public void t1(){
        // 创建Spring容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        // 从容器获取对象
        StudentDao studentDao1 = (StudentDao) ac.getBean("studentDao");
        StudentDao studentDao2 = (StudentDao) ac.getBean("studentDao");
        System.out.println(studentDao1.hashCode());
        System.out.println(studentDao2.hashCode());
        System.out.println(studentDao1.findById(1));
   }
}

IOC_Spring容器类型

容器接口

1、BeanFactory：BeanFactory是Spring容器中的顶层接口，它可以对Bean对象进行管理。

2、ApplicationContext：ApplicationContext是BeanFactory的子接口。它除了继承 BeanFactory的所有功能外，还添加了对国际化、资源访问、事件传播等方面的良好支持。

ApplicationContext有以下三个常用实现类：、

容器实现类

1、ClassPathXmlApplicationContext：该类可以从项目中读取配置文件

2、FileSystemXmlApplicationContext：该类从磁盘中读取配置文件

3、AnnotationConfigApplicationContext：使用该类不读取配置文件，而是会读取注解

@Test
public void t2(){
    // 创建spring容器
    //       ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    ApplicationContext ac = new FileSystemXmlApplicationContext("C:\\Users\\a\\IdeaProjects\\spring_demo\\src\\main\\resources\\bean.xml");
    // 从容器中获取对象
    StudentDao userDao = (StudentDao)ac.getBean("studentDao");
    System.out.println(userDao);
    System.out.println(userDao.findById(1));
}

IOC_对象的创建方式

Spring会帮助我们创建bean，那么它底层是调用什么方法进行创建的呢？

使用构造方法

Spring默认使用类的空参构造方法创建bean：

// 假如类没有空参构造方法，将无法完成bean的创建
public class StudentDaoImpl implements StudentDao{
    public StudentDaoImpl(int a){}    
    @Override
    public Student findById(int id) {
        // 模拟根据id查询学生
        return new Student(1,"程序员","北京");
   }
}

使用工厂类的方法

Spring可以调用工厂类的方法创建bean：

1、创建工厂类，工厂类提供创建对象的方法：

public class StudentDaoFactory {
    public StudentDao getStudentDao(){
        return new StudentDaoImpl(1);
   }
}

2 在配置文件中配置创建bean的方式为工厂方式。

<!-- id：工厂对象的id，class：工厂类 -->
<bean id="studentDaoFactory" class="com.itbaizhan.dao.StudentDaoFactory"></bean>
<!-- id：bean对象的id，factory-bean：工厂对象 的id，factory-method：工厂方法 -->
<bean id="studentDao" factorybean="studentDaoFactory" factory-method="getStudentDao"></bean>

3 测试

使用工厂类的静态方法

Spring可以调用工厂类的静态方法创建bean：

1 创建工厂类，工厂提供创建对象的静态方法。

public class StudentDaoFactory2 {
    public static StudentDao getStudentDao2() {
        return new StudentDaoImpl();
   }
}

2 在配置文件中配置创建bean的方式为工厂静态方法。

<!-- id:bean的id class:工厂全类名 factory-method:工厂静态方法   -->
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoFactory2" factory-method="getStudentDao2"></bean>

3 测试

IOC_对象的创建策略

Spring通过配置中的 scope 属性设置对象的创建策略，共有五种创建策略

1、singleton：单例，默认策略。整个项目只会创建一个对象，通过中的 lazy-init 属性可以设置单例对象的创建时机：

lazy-init="false"(默认)：立即创建，在容器启动时会创建配置文件中的所有Bean对象。 lazy-init="true"：延迟创建，第一次使用Bean对象时才会创建。

配置单例策略：

<!--   <bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2" scope="singleton" lazy-init="true"> </bean>-->
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2" scope="singleton" lazy-init="false">
</bean>

测试单例策略：

// 为Bean对象的类添加构造方法
public StudentDaoImpl2(){
    System.out.println("创建 StudentDao！！！");
}
@Test
public void t2(){
    // 创建Spring容器
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml");
    // 从容器获取对象
    StudentDao studentDao1 = (StudentDao)ac.getBean("studentDao");
    StudentDao studentDao2 = (StudentDao)ac.getBean("studentDao");
    StudentDao studentDao3 = (StudentDao)ac.getBean("studentDao");
    System.out.println(studentDao1.hashCode());
    System.out.println(studentDao2.hashCode());
    System.out.println(studentDao3.hashCode());
}

2、prototype：多例，每次从容器中获取时都会创建对象。

<!-- 配置多例策略 -->
<bean id="studentDao"  class="com.itbaizhan.dao.StudentDaoImpl2" scope="prototype"></bean>

3、request：每次请求创建一个对象，只在web环境有效。

4、session：每次会话创建一个对象，只在web环境有效。

5、gloabal-session：一次集群环境的会话创建一个对象，只在web 环境有效。

IOC_对象的销毁时机

对象的创建策略不同，销毁时机也不同：

singleton：对象随着容器的销毁而销毁。

prototype：使用JAVA垃圾回收机制销毁对象。

request：当处理请求结束，bean实例将被销毁。

session：当HTTP Session最终被废弃的时候，bean也会被销毁掉。

gloabal-session：集群环境下的session销毁，bean实例也将被销毁。

IOC_生命周期方法

Bean对象的生命周期包含创建——使用——销毁，Spring可以配置 Bean对象在创建和销毁时自动执行的方法：

1 定义生命周期方法

public class StudentDaoImpl2 implements StudentDao{
     // 创建时自动执行的方法
    public void init(){
        System.out.println("创建StudentDao！！！");
   }
    // 销毁时自动执行的方法
    public void destory(){
        System.out.println("销毁StudentDao！！！");
   }
}

2 配置生命周期方法

<!-- init-method:创建对象时执行的方法  destroy-method:销毁对象时执行的方法 -->
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2" scope="singleton"
      init-method="init" destroy-method="destory"></bean>

3 测试

@Test
public void t3(){
    // 创建Spring容器
    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean1.xml");
    // 销毁Spring容器，ClassPathXmlApplicationContext才有销毁容器的方法
    ac.close();
}

IOC_获取Bean对象的方式

Spring有多种获取容器中对象的方式：

通过id/name获取

配置文件

<bean name="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2"></bean>
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2"></bean>

获取对象

StudentDao studentDao = (StudentDao) ac.getBean("studentDao");

通过类型获取

配置文件

<bean name="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2"></bean>

获取对象

StudentDao studentDao2 = ac.getBean(StudentDao.class);

通过类型+id/name获取

虽然使用类型获取不需要强转，但如果在容器中有一个接口的多个实现类对象，则获取时会报错，此时需要使用类型+id/name获取

配置文件

<bean name="studentDao" class="com.itbaizhan.dao.StudentDaoImpl2"></bean>
<bean name="studentDao1" class="com.itbaizhan.dao.StudentDaoImpl"></bean>

获取对象

StudentDao studentDao2 = ac.getBean("studentDao",StudentDao.class);

DI_什么是依赖注入

依赖注入（Dependency Injection，简称DI），它是Spring控制反转思想的具体实现。控制反转将对象的创建交给了Spring，但是对象中可能会依赖其他对象。比如service类中要有dao类的属性，我们称service依赖于 dao。之前需要手动注入属性值，代码如下：

public interface StudentDao {
    Student findById(int id);
}
public class StudentDaoImpl implements StudentDao{
    @Override
    public Student findById(int id) {
        // 模拟根据id查询学生
        return new Student(1,"程序员","北京");
   }
}
public class StudentService {
  // service依赖dao，手动注入属性值，即手动维护依赖关系
    private StudentDao studentDao = new StudentDaoImpl();
    public Student findStudentById(int id){
        return studentDao.findById(id);
   }
}

此时，当StudentService的想要使用StudentDao的另一个实现类如 StudentDaoImpl2时，则需要修改Java源码，造成代码的可维护性降低。而使用Spring框架后，Spring管理Service对象与Dao对象，此时它能够为Service对象注入依赖的Dao属性值。这就是Spring的依赖注入。简单来说，控制反转是创建对象，依赖注入是为对象的属性赋值。

DI_依赖注入方式

在之前开发中，可以通过setter方法或构造方法设置对象属性值：

// setter方法设置属性
StudentService studentService = new StudentService();
StudentDao studentDao = new StudentDao();
studentService.setStudentDao(studentDao);
// 构造方法设置属性
StudentDao studentDao = new StudentDao();
StudentService studentService = new StudentService(studentDao);

Spring可以通过调用setter方法或构造方法给属性赋值

Setter注入

被注入类编写属性的setter方法

public class StudentService {
    private StudentDao studentDao;
    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
   }
}

配置文件中，给需要注入属性值的<bean> 中设置<property>

<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService">
    <!--依赖注入-->
    <!--name:对象的属性名 ref:容器中对象的id值-->
    <property name="studentDao" ref="studentDao"></property>
</bean>

测试是否注入成功

@Test
public void t2(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    StudentService studentService = (StudentService) ac.getBean("studentService");
    System.out.println(studentService.findStudentById(1));
}

构造方法注入

被注入类编写有参的构造方法

public class StudentService {
    private StudentDao studentDao;
    public StudentService(StudentDao studentDao) {
        this.studentDao = studentDao;
   }
}

给需要注入属性值的<bean> 中设置<constructor-arg>

<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService">
    <!-- 依赖注入 -->
    <!-- name:对象的属性名 ref：配置文件中注入对象的id值 -->
    <constructor-arg name="studentDao" ref="studentDao"></constructor-arg>
</bean>

测试是否注入成功

@Test
public void t2(){
    ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
    StudentService studentService =(StudentService) ac.getBean("studentService");
  System.out.println(studentService.findStudentById(1));
}

自动注入

自动注入不需要在标签中添加其他标签注入属性值，而是自动从容器中找到相应的bean对象设置为属性值。

测试自动注入：

1、为依赖的对象提供setter和构造方法：

public class StudentService {
     // 依赖
     private StudentDao studentDao;
     // 构造方法
     public StudentService() { }
    public StudentService(StudentDao studentDao) {
        this.studentDao = studentDao;
   }
    // setter方法
    public void setStudentDao(StudentDao studentDao) {
        this.studentDao = studentDao;
   }
    // 调用依赖的方法
    public Student findStudentById(int id)
      {
        return studentDao.findById(id);
      }
}

2、配置自动注入：

<!-- 根据beanId等于属性名自动注入 -->
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService" autowire="byName"></bean>

<!-- 根据bean类型等于属性类型自动注入 -->
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService" autowire="byType"></bean>

<!-- 利用构造方法自动注入 -->
<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService" autowire="constructor"></bean>

<!-- 配置全局自动注入 -->
<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"
        default-autowire="constructor">

DI_依赖注入类型

DI支持注入bean类型、基本数据类型和字符串、List集合、Set集合、Map集合、Properties对象类型等，他们的写法如下：

1、准备注入属性的类

public class StudentService {
    private StudentDao studentDao; // bean属性
    private String name; //字符串类型
    private int count; //基本数据类型
    private List<String> names; // 字符串类型List集合
    private List<Student> students1; // 对象类型List集合
    private Set<Student> students2; // 对象类型Set集合
    private Map<String,String> names2; //字符串类型Map集合
    private Map<String,Student> students3;// 对象类型Map集合
    private Properties properties;//Properties类型
    // 省略getter/setter/toString
}

2、准备测试方法

@Test
public void t3(){
    ApplicationContext ac = newClassPathXmlApplicationContext("bean.xml");
    StudentService studentService =(StudentService)ac.getBean("studentService");
    System.out.println(studentService);
}

注入bean类型

写法一：

<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService">
    <property name="studentDao" ref="studentDao"></property>
</bean>

写法二：

<bean id="studentDao" class="com.itbaizhan.dao.StudentDaoImpl"></bean>
<bean id="studentService" class="com.itbaizhan.service.StudentService">
    <property name="studentDao" >
        <ref bean="studentDao"></ref>
    </property>
</bean>

注入基本数据类型

<bean id="studentService" class="com.itbaizhan.service.StudentService">
    <!-- 写法一 name：属性名 value：属性值-->
    <property name="name" value="百百">
</property>
    <!-- 写法二 name：属性名 value：属性值-->
    <property name="count">
        <value>10</value>
    </property>
</bean>

注入List集合

<bean id="studentService"
class="com.itbaizhan.service.StudentService">
    <!-- 简单数据类型List集合 name：属性名 -->
    <property name="names">
        <list>
            <value>强学堂</value>
            <value>程序员</value>
        </list>
    </property>
    <!-- 对象类型List集合 name：属性名 -->
    <property name="students1">
        <list>
            <bean class="com.itbaizhan.domain.Student">
                <property name="id" value="1"/>
                <property name="name" value="强学堂"/>
                <property name="address" value="北京"/>
            </bean>
            <bean class="com.itbaizhan.domain.Student">
                <property name="id" value="2"/>
                <property name="name" value="百战不败"/>
                <property name="address" value="北京"/>
            </bean>
        </list>
    </property>
</bean>

注入Set集合

<bean id="studentService" class="com.itbaizhan.service.StudentService">
    <!-- Set集合 -->
    <property name="students2">
        <set>
            <bean class="com.itbaizhan.domain.Student">
                <property name="id" value="1"/>
                <property name="name" value="强学堂"/>
                <property name="address" value="北京"/>
            </bean>
            <bean class="com.itbaizhan.domain.Student">
                <property name="id" value="2"/>
                <property name="name" value="百战不败"/>
                <property name="address" value="北京"/>
            </bean>
        </set>
    </property>
</bean>

注入Map集合

简单数据类型Map集合：

<bean id="studentService" class="com.itbaizhan.service.StudentService">
    <property name="names2">
        <map>
            <entry key="student1" value="bz"/>
            <entry key="student2" value="sxt"/>
        </map>
    </property>
</bean>

对象类型Map集合：

<bean id="studentService" class="com.itbaizhan.service.StudentService">
    <property name="students3">
        <map>
            <entry key="student1" value-ref="s1"/>
            <entry key="student2" value-ref="s2"/>
        </map>
    </property>
</bean>
<bean id="s1" class="com.itbaizhan.domain.Student">
    <property name="id" value="1"/>
    <property name="name" value="强学堂"/>
    <property name="address" value="北京"/>
</bean>
<bean id="s2" class="com.itbaizhan.domain.Student">
    <property name="id" value="2"/>
    <property name="name" value="百战不败"/>
    <property name="address" value="北京"/>
</bean>

注入Properties对象

<bean id="studentService" class="com.itbaizhan.service.StudentService">
    <property name="properties">
        <props>
            <prop key="配置1">值1</prop>
            <prop key="配置2">值2</prop>
        </props>
    </property>
</bean>

Spring-全面详解（学习总结---从入门到深化）（上）

Spring简介

Spring体系结构

IOC_控制反转思想

IOC_自定义对象容器

IOC_Spring实现IOC

IOC_Spring容器类型

容器接口

容器实现类

IOC_对象的创建方式

使用构造方法

使用工厂类的方法

使用工厂类的静态方法

IOC_对象的创建策略

IOC_对象的销毁时机

IOC_生命周期方法

IOC_获取Bean对象的方式

通过id/name获取

通过类型获取

通过类型+id/name获取

DI_什么是依赖注入

DI_依赖注入方式

Setter注入

构造方法注入

自动注入

DI_依赖注入类型

注入bean类型

注入基本数据类型

注入List集合

注入Set集合

注入Map集合

注入Properties对象

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Spring-全面详解（学习总结---从入门到深化）（上）

Spring简介

Spring体系结构

IOC_控制反转思想

IOC_自定义对象容器

IOC_Spring实现IOC

IOC_Spring容器类型

容器接口

容器实现类

IOC_对象的创建方式

使用构造方法

使用工厂类的方法

使用工厂类的静态方法

IOC_对象的创建策略

IOC_对象的销毁时机

IOC_生命周期方法

IOC_获取Bean对象的方式

通过id/name获取

通过类型获取

通过类型+id/name获取

DI_什么是依赖注入

DI_依赖注入方式

Setter注入

构造方法注入

自动注入

DI_依赖注入类型

注入bean类型

注入基本数据类型

注入List集合

注入Set集合

注入Map集合

注入Properties对象

热门文章

最新文章

相关课程

相关电子书

相关实验场景