文章目录

零、本讲学习目标
一、Web开发技术
二、Spring框架
- （一）Spring官网
- （二）Spring框架优点
- （三）为什么要选择Spring？
- （四） Spring框架因何而来
- （五）Spring框架核心概念
- - 1、IoC（Inversion of Control）和容器
  - 2、AOP（Aspect-Oriented Programming）框架
- （六）Spring Framework架构图
- （七）Spring框架主要组件及其功能
- （八）Spring框架的价值与意义
三、Spring容器演示——采用Spring配置文件管理Bean
- （一）创建Maven项目
- （二）添加Spring依赖
- （三）创建杀龙任务类
- （四）创建勇敢骑士类
- （五）采用传统方式让勇敢骑士完成杀龙任务
- （六）采用Spring容器让勇敢骑士完成杀龙任务
- - 1、创建日志属性文件
  - 2、创建Spring配置文件
  - 3、在Spring配置文件里创建Bean
  - - （1）创建杀龙任务Bean
    - （2）创建勇敢骑士Bean
  - 4、创建新勇敢骑士测试类
  - 5、创建两个勇敢骑士Bean
  - 6、修改新勇敢骑士测试类
- （七）采用构造方法注入方式注入属性值
- - 1、创建救美任务类
  - 2、创建救美骑士类
  - 3、配置救美骑士Bean
  - 4、创建旧救美骑士测试类
  - 5、创建新救美骑士测试类

零、本讲学习目标

了解Web开发技术
了解Java Web开发进化史
了解Spring框架的作用
掌握采用Spring配置文件管理Bean

一、Web开发技术

Web开发技术思维导图
从学习角度来说，理解技术问题要越透彻越好，被屏蔽或被封装起来的信息要越少越好。从工程实现角度来说，要尽量高效地使用现成框架和现成工具——这是“学习”和“工程实现”的差别，但这两件事并不矛盾，我们学习得越透彻，在工程实现时，对框架和工具的使用就越高效。
Java Web开发进化史

二、Spring框架

（一）Spring官网

网址：https://spring.io
Spring Framework - https://spring.io/projects/spring-framework

在这里插入图片描述

目前（2023-2-13）Spring Framework版本是6.0.4

（二）Spring框架优点

Spring makes Java productive.
Spring makes Java reactive.
Spring makes Java cloud-ready.
Spring makes Java simple.
Spring makes Java modern.

（三）为什么要选择Spring？

Spring makes programming Java quicker, easier, and safer for everybody. Spring’s focus on speed, simplicity, and productivity has made it the world's most popular Java framework.
“We use a lot of the tools that come with the Spring framework and reap the benefits of having a lot of the out of the box solutions, and not having to worry about writing a ton of additional code—so that really saves us some time and energy.” —— SEAN GRAHAM, APPLICATION TRANSFORMATION LEAD, DICK’S SPORTING GOODS

在这里插入图片描述

（四） Spring框架因何而来

Spring Framework的发明与Java规范的变迁有着千丝万缕的联系，在Java规范的早期版本中，Sun公司针对不同的开发场景创建了不同的规范，以此帮助Java开发者更高效、更专注地开发业务逻辑，这些规范包括J2SE、J2ME及专门为企业级应用打造的J2EE，而EJB规范又是当时J2EE规范中最核心的部分。
EJB 1.0发布于1999年，它最初由IBM提出，之后由Sun公司（Java语言创建公司，现已由Oracle收购）将其吸收进Java官方体系，最后由JCP（Java Community Process，是一个开放的国际组织，主要由Java开发者及被授权者组成）正式将其规范化。由于当时Java在业界风头正劲，各大公司都广泛地使用EJB规范来进行应用开发，在这种环境下，EJB规范几乎成了Java企业级应用开发的代名词。
但是任何技术都不是完美的，EJB自身存在各种问题，要求革新EJB技术的呼声一浪高过一浪，无论是当时的学术界还是企业界都没有符合要求的技术出现。一位名为Rod Johnson的开发者，结合自己扎实的理论知识和丰富的实践经验写出了对当时及后来的Java开发者影响深远的两本著作Expert One-on-One J2EE Design andDevelopment和J2EE without EJB，他通过这两本书阐述了一种与当时主流EJB截然不同的开发方式，这两本书也可以视为Spring Framework的起源。
从设计思想来看，Rod Johnson认为当时的EJB框架太过繁重，程序员需要花费大量的时间和精力来实现EJB规范所要求的各种类，并且还要管理他们的生命周期，这完全违背了EJB提出时的初衷——“让大部分程序员把精力都用在业务功能本身上”。为了解决这种本末倒置的问题，RodJohnson提出了轻量级框架的概念，并将这种思想完全贯彻于Spring Framework。这也是此框架被称为Spring的原因：传统的J2EE开发让开发者走进了冬天（Winter），而春天（Spring）将会是一个全新的开始。
Spring公开可查的最初版本成型于RodJohnson的Expert One-on-One J2EE Designand Development一书，其1.0版本于2004年正式开源（其开源许可证为Apache 2.0 License），正式开源版本的Spring Framework以其独特的开发方式和全新的设计理念震撼了整个Java开发者生态圈。

（五）Spring框架核心概念

1、IoC（Inversion of Control）和容器

理解IoC的概念对掌握Spring Framework而言是十分重要的，因为所有Spring对象的组装都基于此。在IoC概念中，控制是指依赖者和被依赖者的关系控制。在传统的Java应用开发中，如果A类依赖于B类，那么B类对象的生命周期都由A类对象控制，从而形成A类与B类的强耦合关系。 然而，在面向对象的编程体系中，强耦合是应当极力避免的，如果可以将B对象生命周期的控制从A对象中剥离，那么强依赖关系也不再成立，整体系统也更加符合面向对象的设计原则。
IoC的核心思想是，被依赖者不再由依赖者直接创建，而是交由专门的组装者来控制，在组装者创建出被依赖的对象之后，将其注入依赖者。通过这样的设计，可以达到松散耦合和接口与实现分离的目的。如果读者熟悉经典的GoF设计模式，那么在传统的实现中，这种需求都将通过工厂模式来实现。熟悉工厂模式对理解SpringFramework和阅读其源代码都有很好的帮助。 因此，建议大家在学习Spring Framework之前，花一点时间了解设计模式中的工厂模式。
从实现的角度来理解IoC，它与依赖注入（DI，Dependency Injection）密不可分。假设A类依赖于B类（B类并不是一个实现类，只是一个实现声明的接口，真正的实现类并不会直接暴露给A类），而且实现类的生命周期也由容器（组装者）控制，B类的实现对象将由容器注入A类对象。则根据面向对象的设计理论，此时的A类依赖于接口B，而非依赖于接口B的实现类，从而使A类获得了不再依赖于实现细节的能力，实现了松耦合的设计目标，A类不再控制B类的生命周期，而且根据业务需求，还可以切换接口B的实现类，以此满足不同功能。
Spring Framework的作用是将普通的Java类经过一系列配置，再利用IoC容器将不同对象组装在一起，最终形成一个可以运行的系统。

2、AOP（Aspect-Oriented Programming）框架

要深入理解AOP，需要先从面向对象编程谈起。Java是典型的面向对象编程语言，面向对象强调的是继承和封装，也是现实世界在程序的投影。如果有些代码逻辑需要在很多类（class）中反复出现而且又与主干业务逻辑并无强关联（比如应用开发中常见的日志，事务控制和审计功能等），那么应该如何设计呢？例如一台机器肯定不会有打印日志这样的功能，但从应用开发的角度来审视系统，这些功能又是不可或缺的。在AOP出现之前，通常使用经典设计模式来解决这类问题，设计师可以采用代理（Proxy）模式，Java语言也提供了动态代理的实现，尽管这些技术可以解决一部分组件间的强依赖问题，但是解决方案却不够优雅灵活，而且有很强的局限性。比如，最初的原生Java只能代理接口（interface）而无法代理类（class）。了解了面向对象编程和原生Java的短板之后，作为全新的技术，AOP又提供了哪些新思路和新方法呢？在深入细节之前，我们需要先了解AOP的几个关键点。
切面（Aspect）是一组模块化的且可以被多个类（class）复用的逻辑，当目标对象（TargetObject）的一段程序在某个执行点（Join-Point）的切入点（Pointcut）判定为真时，切面逻辑（Advice）会被触发执行，并将Aspect和TargetObject连接在一起，形成一个真正可执行的切面逻辑，这个过程被称为织入（Weaving）。开发者可以通过AOP的方式将业务逻辑和非业务逻辑进行分离，使二者的代码组织和职责都更集中、更清晰。
常用的Spring AOP和AspectJ技术都是AOP理论的一种实现，但是二者的实现目标却是各不相同。Spring AOP只针对SpringFramework需要的AOP功能提供简单有效的实现，而AspectJ是一个大而全的AOP Java实现。不过，Spring Framework也提供了对AspectJ的支持，因此在使用Spring时也可以同时使用AspectJ的功能。此外二者的织入（Weaving）技术也是完全不同的，AspectJ采用了编译（compile）期织入和类装载期（classload）织入，而Spring AOP的织入技术则根据运行期的不同状态可以在Java的动态代理技术或CGLIB代理技术之间切换，其具体实现方式如下图所示。

（六）Spring Framework架构图

Spring Framework的架构图
基于IoC（DI）和AOP两大强力支柱，Spring Framework提供给Java开发者一种全新的（就当时而言）开发体验。与当时的其他框架都不同，Spring Framework并不只是一种通用框架，更多时候Spring Framework在充当一种类似于胶水的角色，将不同的组件整合在一起最终形成完备的系统。所以，它不仅为开发者提供各种便利性，而且具备将Java生态中的主流开源框架（如Hibernate、iBatis等）和Java语言规范（如JDBC、JMX、JMS等）融合的能力。此外，Spring Framework提倡无侵入式编程，既可以让开发者享受使用框架的好处，又省却了与框架代码过度耦合的烦恼。 典型的Spring应用有两部分组成：一部分是与系统功能强相关的业务逻辑，另一部分是与业务无关的框架代码，但此类框架代码大部分已经被Spring简化，开发者只需利用IoC和AOP技术，通过简单的配置（前期以XML为主，在JDK 1.5之后以注释（Annotation）为主）将二者融合在一起形成功能完整的Java应用。

（七）Spring框架主要组件及其功能

在这里插入图片描述

（八）Spring框架的价值与意义

在Spring Framework问世之后，因其风格优雅、简洁易用，以及对RESTful等功能的良好支持，迅速地成为Java开发的事实标准，而EJB却被开发者遗忘了。各大Web容器厂商也在重新评估，在Web容器中是否还需要继续支持EJB。总而言之，Spring让广大Java应用开发者从复杂的框架代码中解脱出来，更加专注于应用的业务逻辑，这一点广阔而深远地影响了整个Java生态圈。
虽然Spring公司（由Rod Johnson创建最初名为Interface 21，后改名为SpringSource）经过一系列资本运作已于2009年被VMware收购，而Rod Johnson本人也于2012年正式离开了VMware，但是Rod Johnson对整个Java生态圈的卓越贡献将被永远铭记。

三、Spring容器演示——采用Spring配置文件管理Bean

Spring容器其实就是一个Bean工厂，在工厂里通过配置文件或配置类创建各种各样的Bean，然后在Spring应用程序就可以按照名称或类型获取工厂里已经配置好的Bean。下面我们就通过一个具体的案例来了解Spring容器是如何工作的。创建Spring应用程序 - 骑士完成任务。

（一）创建Maven项目

创建Maven项目 - SpringDemo，设置项目位置以及组ID
单击【Finish】按钮，pom（project object model）对项目的版本、依赖与插件进行管理
修改项目的Maven配置

（二）添加Spring依赖

在Maven仓库里查找Spring框架（https://mvnrepository.com）
查看Spring Core
选择最新版本 - 6.0.4
添加到pom.xml文件的<dependencies>元素里
同理添加其他依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>net.huawei.spring</groupId>
    <artifactId>SpringDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!--Spring核心-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>6.0.4</version>
        </dependency>
        <!--Spring实体-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>6.0.4</version>
        </dependency>
        <!--Spring容器-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.4</version>
        </dependency>
        <!--Spring Web-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>6.0.4</version>
        </dependency>
        <!--Spring MVC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>6.0.4</version>
        </dependency>
        <!--Spring测试-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>6.0.4</version>
        </dependency>
        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

但是大家可以看到版本号是红色的，说明这些依赖包还没有下载
打开Maven窗口
单击刷新按钮，就开始下载依赖包，等待插件与依赖下载完成（第一次下载有点慢，需要耐心等待）
可以查看本地Maven仓库里当前项目下载的有关Spring框架的依赖

（三）创建杀龙任务类

创建net.huawei.spring.day01包，然后在包里面创建SlayDragonQuest类

package net.huawei.spring.day01;

/**
 * 功能：杀龙任务类
 * 作者：华卫
 * 日期：2023年02月13日
 */
public class SlayDragonQuest {
    public void embark() {
        System.out.println("执行杀龙任务……");
    }
}

（四）创建勇敢骑士类

在net.huawei.spring.day01包里创建BraveKnight类

package net.huawei.spring.day01;

/**
 * 功能：勇敢骑士类
 * 作者：华卫
 * 日期：2023年02月13日
 */
public class BraveKnight {
    private String name; // 骑士姓名
    private SlayDragonQuest slayDragonQuest; // 杀龙任务

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * 设置杀龙任务
     *
     * @param slayDragonQuest
     */
    public void setSlayDragonQuest(SlayDragonQuest slayDragonQuest) {
        this.slayDragonQuest = slayDragonQuest;
    }

    /**
     * 勇敢骑士执行任务
     */
    public void embarkOnQuest() {
        System.out.print("勇敢骑士[" + name + "]"); // 骑士留名
        slayDragonQuest.embark(); // 执行杀龙任务
    }
}

回顾一下传统方式怎么使用这两个类。需要我们自己通过new实例化两个类，然后设置勇敢骑士对象的姓名和杀龙任务属性，然后调用勇敢骑士执行任务的方法。

（五）采用传统方式让勇敢骑士完成杀龙任务

在test/java里创建net.huawei.spring.day01包，然后在包里面创建TestBraveKnightOld类

package net.huawei.spring.day01;

import org.junit.Test;

/**
 * 功能：采用传统方式测试勇敢骑士类
 * 作者：华卫
 * 日期：2023年02月13日
 */
public class TestBraveKnightOld {
    @Test
    public void testBraveKnight() {
        // 创建杀龙任务对象
        SlayDragonQuest slayDragonQuest = new SlayDragonQuest();
        // 创建勇敢骑士对象
        BraveKnight braveKnight = new BraveKnight();
        // 设置勇敢骑士属性
        braveKnight.setName("罗宾汉");
        braveKnight.setSlayDragonQuest(slayDragonQuest);
        // 调用勇敢骑士执行任务方法
        braveKnight.embarkOnQuest();
    }
}

运行测试方法testBraveKnight()
查看程序运行结果
出现这个问题怎么办？要设置Java版本
三个地方的设置要保持一致，然后再运行程序，查看结果

（六）采用Spring容器让勇敢骑士完成杀龙任务

1、创建日志属性文件

在resources目录里创建log4j.properties

log4j.rootLogger=WARN, stdout, logfile
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spring.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

2、创建Spring配置文件

在resources里创建xmlconfig目录，然后在里面创建spring-config.xml
输入Spring配置文件名
单击【Configure application context】（配置应用上下文）
单击【Create new application context…】（创建新的应用上下文），注意应用上下文名称是可以修改的
单击【OK】按钮
在项目结构窗口里查看配置好的spring-config.xml
现在我们有了生产Bean的车间，下面我们就要在车间里配置产品

3、在Spring配置文件里创建Bean

（1）创建杀龙任务Bean

<!--配置杀龙任务Bean-->
<bean id="slayDragonQuest" class="net.huawei.spring.day01.SlayDragonQuest"/>

id属性 ：对应对象名，可以任取，然后在应用程序里我们可以通过这个id值从Spring容器中获取Bean对象。
class属性 ：表明Bean对象是基于哪个类来实例化，注意一定要包含包名。

（2）创建勇敢骑士Bean

<!--配置勇敢骑士Bean-->                                                 
<bean id="braveKnight" class="net.huawei.spring.day01.BraveKnight"> 
    <property name="name" value="罗宾汉"/>  <!-- RobinHood.setName("罗宾汉")-->                        
    <property name="slayDragonQuest" ref="slayDragonQuest"/>  <!--RobinHood.setSlayDragonQuest(slayDragonQuest)-->  
</bean>

property元素：给对象设置属性值
name属性：Bean对象的属性名
ref属性：Bean对象的属性值（引用另一个Bean对象）
勇敢骑士Bean通过<property>元素将杀龙任务Bean注入作为其属性。注意，name属性值一定是BraveKnight类的属性名，ref属性值是已定义的杀龙任务Bean的id值。

<?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-->
    <bean id="slayDragonQuest" class="net.huawei.spring.day01.SlayDragonQuest"/>

    <!--配置勇敢骑士Bean-->
    <bean id="braveKnight" class="net.huawei.spring.day01.BraveKnight">
        <property name="name" value="罗宾汉"/> <!--braveKnight.setName("罗宾汉");-->
        <property name="slayDragonQuest" ref="slayDragonQuest"/> <!--braveKnight.setSlayDragonQuest(slayDragonQuest);-->
    </bean>
</beans>

通过Spring配置文件，创建了两个Bean对象，它们之间存在依赖关系，第一个Bean对象是第二个Bean对象的任务属性值。

4、创建新勇敢骑士测试类

在test/java/net.huawei.spring.day01里创建TestBraveKnightNew测试类
采用基于类路径的应用容器类 - ClassPathXmlApplicationContext

package net.huawei.spring.day01;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 功能：采用Spring容器测试勇敢骑士类
 * 作者：华卫
 * 日期：2023年02月13日
 */
public class TestBraveKnightNew {
    private ClassPathXmlApplicationContext context; // 基于类路径XML配置文件的应用容器（Bean工厂）

    @Before // 每次测试方法执行前都要执行的代码就放在此方法里
    public void init() {
        // 基于Spring配置文件创建应用容器
        context = new ClassPathXmlApplicationContext("xmlconfig/spring-config.xml");
        // 提示用户
        System.out.println("Spring应用容器已创建~");
    }

    @Test
    public void testBraveKnight() {
        // 根据名称从应用容器中获取勇敢骑士对象
        BraveKnight braveKnight = (BraveKnight) context.getBean("braveKnight");
        // 勇敢骑士执行任务
        braveKnight.embarkOnQuest();
    }

    @After // 每次测试方法执行后都要执行的代码就放在此方法里
    public void destroy() {
        // 关闭应用容器
        context.close();
        // 提示用户
        System.out.println("Spring应用容器已关闭~");
    }
}

代码说明：首先通过Spring配置文件创建Spring应用容器，然后就可以利用容器的getBean方法通过名称获取容器里的Bean对象，然后调用该对象的方法。
运行测试方法testBraveKnight()，查看结果
问题出在Spring版本与JDK版本不匹配，有两种解决方法。一个是降低Spring版本，一个是提高JDK版本。
我们将Spring版本降低到5.3.25
再次运行程序，查看结果
根据名称从应用容器中获取勇敢骑士对象可能会报错，因为配置文件里没有定义那个名称的Bean

5、创建两个勇敢骑士Bean

基于一个类可以创建多个对象，因此，在spring-config.xml文件里，也可以基于同一个类创建多个Bean。
基于BraveKnight类再创建两个Bean，id值分别为knight1和knight2。
在Spring配置文件里，同一个Bean不能重复定义，也就是说不允许两个Bean有相同的id值

6、修改新勇敢骑士测试类

获取新建的两个勇敢骑士Bean，调用执行任务方法
执行testBraveKnight()测试方法，查看结果
勇敢骑士Bean采用属性注入方式将杀龙任务Bean注入作为其属性。
初始化对象其实可以调用有参构造方法来设置属性的初始值，对应到Spring的Bean工厂，就还有一种注入方式，叫做构造方法注入。同样地，我们还是通过案例来演示如何通过构造方法来注入属性值。

（七）采用构造方法注入方式注入属性值

1、创建救美任务类

在net.huawei.spring.day01包里创建RescueDamselQuest类
Rescue Damsel - 拯救少女

package net.huawei.spring.day01;

/**
 * 功能：救美任务类
 * 作者：华卫
 * 日期：2022年05月29日
 */
public class RescueDamselQuest {
    public void embark() {
        System.out.println("执行救美任务……");
    }
}

2、创建救美骑士类

在net.huawei.spring.day01包里创建DamselRescuingKnight类

package net.huawei.spring.day01;

/**
 * 功能：救美骑士类
 * 作者：华卫
 * 日期：2022年05月29日
 */
public class RescueDamselKnight {
    private String name;
    private RescueDamselQuest rescueDamselQuest;

    /**
     * 有参构造方法
     *
     * @param name
     * @param rescueDamselQuest
     */
    public RescueDamselKnight(String name, RescueDamselQuest rescueDamselQuest) {
        this.name = name;
        this.rescueDamselQuest = rescueDamselQuest;
    }

    public void embarkOnQuest() {
        System.out.print("救美骑士[" + name + ']');
        rescueDamselQuest.embark();
    }
}

代码说明：通过构造方法来设置骑士的姓名与要执行的任务。

3、配置救美骑士Bean

在Spring配置文件里创建救美骑士Bean
arg: argument 参数

<!--救美任务Bean-->                                                                  
<bean id="rescueDamselQuest" class="net.huawei.spring.day01.RescueDamselQuest"/> 
<!--创建救美骑士Bean-->                                                                
<bean id="Galahad" class="net.huawei.spring.day01.RescueDamselKnight">           
    <constructor-arg value="格拉海德"/>                                              
    <constructor-arg ref="rescueDamselQuest"/>                                   
</bean>

4、创建旧救美骑士测试类

在test/java/net.huawei.spring.day01包里创建TestRescueDamselKnightOld类

package net.huawei.spring.day01;

import org.junit.Test;

/**
 * 功能：传统方式测试救美骑士类
 * 作者：华卫
 * 日期：2022年05月29日
 */
public class TestRescueDamselKnightOld {
    @Test
    public void testRescueDamselKnight() {
        // 创建救美任务对象
        RescueDamselQuest rescueDamselQuest = new RescueDamselQuest();
        // 创建救美骑士对象
        RescueDamselKnight rescueDamselKnight = new RescueDamselKnight("格拉海德", rescueDamselQuest);
        // 救美骑士执行任务
        rescueDamselKnight.embarkOnQuest();
    }
}

运行testRescueDamselKnight()测试方法，查看结果

5、创建新救美骑士测试类

在test/java/net.huawei.spring.day01包里创建TestRescueDamselKnightNew类

package net.huawei.spring.day01;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 功能：采用Spring容器测试救美骑士类
 * 作者：华卫
 * 日期：2022年05月29日
 */
public class TestRescueDamselKnightNew {
    private ClassPathXmlApplicationContext context; // 基于类路径XML配置文件的应用容器

    @Before // 每次测试方法执行前都要执行的代码
    public void init() {
        // 基于Spring配置文件创建应用容器
        context = new ClassPathXmlApplicationContext("xmlconfig/spring-config.xml");
        // 提示用户
        System.out.println("Spring应用容器已创建~");
    }

    @Test
    public void testRescueDamselKnight() {
        // 根据名称从应用容器里获取救美骑士对象
        RescueDamselKnight rescueDamselKnight = (RescueDamselKnight) context.getBean("Galahad");
        // 救美骑士执行任务
        rescueDamselKnight.embarkOnQuest();
    }

    @After // 每次测试方法执行后都要执行的代码
    public void destroy() {
        // 关闭应用容器
        context.close();
        // 提示用户
        System.out.println("Spring应用容器已关闭~");
    }
}