后端篇——第一章 Maven基础全面教程

一、初识Maven

[1.1 Maven介绍](#1.1 Maven介绍)

[1.2 Maven的核心作用](#1.2 Maven的核心作用)

[1.2.1 依赖管理](#1.2.1 依赖管理)

[1.2.2 项目构建](#1.2.2 项目构建)

[1.2.3 统一项目结构](#1.2.3 统一项目结构)

二、Maven概述

[2.1 Maven基本介绍](#2.1 Maven基本介绍)

[2.2 Maven核心模型](#2.2 Maven核心模型)

[2.2.1 构建生命周期/阶段](#2.2.1 构建生命周期/阶段)

[2.2.2 项目对象模型（POM）](#2.2.2 项目对象模型（POM）)

[2.2.3 依赖管理模型（Dependency）](#2.2.3 依赖管理模型（Dependency）)

[2.3 Maven仓库](#2.3 Maven仓库)

[2.4 Maven安装与配置](#2.4 Maven安装与配置)

[2.4.1 下载](#2.4.1 下载)

[2.4.2 安装配置步骤](#2.4.2 安装配置步骤)

三、IDEA集成Maven

[3.1 创建Maven项目](#3.1 创建Maven项目)

[3.1.1 全局设置](#3.1.1 全局设置)

[3.1.2 新建Maven项目](#3.1.2 新建Maven项目)

[3.1.3 Maven项目目录结构](#3.1.3 Maven项目目录结构)

[3.1.4 pom文件详解](#3.1.4 pom文件详解)

[3.2 Maven坐标详解](#3.2 Maven坐标详解)

[3.3 导入Maven项目](#3.3 导入Maven项目)

四、依赖管理

[4.1 依赖配置](#4.1 依赖配置)

[4.1.1 基本配置步骤](#4.1.1 基本配置步骤)

[4.1.2 依赖坐标查找方法](#4.1.2 依赖坐标查找方法)

[4.2 Maven生命周期](#4.2 Maven生命周期)

[4.2.1 生命周期介绍](#4.2.1 生命周期介绍)

[4.2.2 生命周期执行方式](#4.2.2 生命周期执行方式)

五、单元测试

[5.1 测试基础概念](#5.1 测试基础概念)

[5.1.1 测试阶段划分](#5.1.1 测试阶段划分)

[5.1.2 测试方法分类](#5.1.2 测试方法分类)

[5.2 JUnit入门](#5.2 JUnit入门)

[5.2.1 JUnit简介](#5.2.1 JUnit简介)

[5.2.2 JUnit入门程序](#5.2.2 JUnit入门程序)

[5.3 断言](#5.3 断言)

[5.4 常见注解](#5.4 常见注解)

[5.5 依赖范围](#5.5 依赖范围)

Maven是一个用于管理和构建Java项目的工具，主要功能包括依赖管理、项目构建和统一项目结构。本文详细介绍了Maven的安装配置、IDEA集成、依赖管理以及单元测试等内容。在依赖管理方面，Maven通过坐标系统自动下载和管理jar包；在项目构建方面，Maven提供了标准化的构建生命周期；在单元测试部分，重点讲解了JUnit框架的使用方法，包括断言和常见注解。通过Maven可以简化Java项目的开发流程，提高开发效率和质量保证。

一、初识Maven

1.1 Maven介绍

Maven 是一款用于管理和构建Java项目的工具，是Apache旗下的一个开源项目。

Apache 软件基金会成立于1999年7月，是目前世界上最大且最受欢迎的开源软件基金会，也是专门为支持开源项目而生的非盈利性组织。其开源项目列表可查看：https://www.apache.org/index.html#projects-list

在JavaSE阶段，即使不使用Maven也能构建Java项目，那为何还要学习Maven呢？接下来我们将详细介绍Maven的核心作用。

1.2 Maven的核心作用

1.2.1 依赖管理

Maven可方便快捷地管理项目依赖的资源（jar包），有效避免版本冲突问题。我们通过对比使用Maven前后的差异来理解这一功能：

使用Maven前

项目中需要使用某个jar包时，需先从官方网站下载该jar包，再手动导入到项目中才能使用。

使用Maven后

只需在Maven项目的pom.xml文件中添加一段配置，Maven就会自动根据配置信息下载对应的依赖，无需手动操作即可直接在项目中使用。

1.2.2 项目构建

Maven提供了标准化的跨平台自动化构建方式。开发一套系统通常需要经历编译、测试、打包、发布等流程，这些重复操作若手动完成会十分繁琐，而Maven通过简单命令即可完成全部构建流程。

通过Maven的命令（如compile、test、package、deploy等），可轻松完成项目的编译、测试、打包、发布等操作，且这些命令支持Windows、Linux、Mac等多种操作系统，具备良好的跨平台性。

1.2.3 统一项目结构

Maven提供了标准、统一的项目结构，解决了不同开发工具创建的项目无法互通的问题：

未使用Maven时

Java开发工具种类繁多（如IDEA、Eclipse、MyEclipse等），不同工具创建的Java项目目录结构存在差异，导致Eclipse创建的项目无法直接导入IDEA，IDEA创建的项目也无法直接导入Eclipse，影响开发效率。

使用Maven后

Maven规定了一套标准的Java项目目录结构，无论使用何种开发工具，基于Maven构建的项目目录结构都完全一致，可直接在不同开发工具间导入使用，极大提升了开发便捷性。

Maven标准项目目录说明：main目录存放项目源代码，test目录存放项目测试代码；main和test目录下均包含java目录（存放源代码文件）和resources目录（存放配置文件）。

总结：Maven是一款用于管理和构建Java项目的工具，其核心价值在于简化项目依赖管理、标准化项目构建流程、统一项目目录结构。

本教程将Maven内容分为核心和进阶两部分，本章先讲解Maven核心内容，Maven进阶内容将在Web开发阶段后续讲解。

二、Maven概述

2.1 Maven基本介绍

Apache Maven是一个项目管理和构建工具，它基于项目对象模型（Project Object Model，简称POM）的概念，通过一小段描述信息来管理项目的构建、报告和文档。

Maven官网：https://maven.apache.org/

Maven核心作用总结：1. 方便的依赖管理；2. 统一的项目结构；3. 标准的项目构建流程。

2.2 Maven核心模型

Maven包含三大核心模型，分别是：

项目对象模型（Project Object Model，POM）

依赖管理模型（Dependency）

构建生命周期/阶段（Build lifecycle & phases）

2.2.1 构建生命周期/阶段

上图中紫色框部分用于完成标准化构建流程。Maven为不同的构建阶段提供了对应的插件，例如编译阶段有编译插件、打包阶段有打包插件等，通过插件实现具体的构建操作。

2.2.2 项目对象模型（POM）

上图中紫色框部分属于项目对象模型，即将项目抽象为一个对象模型，每个Maven项目都有专属的坐标。坐标是资源（jar包）的唯一标识，通过坐标可精准定位所需资源（jar包）的位置。

Maven坐标由三部分组成：

groupId：组织名（通常为域名反写，如com.itheima）

artifactId：模块名（即项目或模块的名称，如order-service、goods-service）

Version：版本号（如1.0-SNAPSHOT、1.0-RELEASE）

2.2.3 依赖管理模型（Dependency）

上图中紫色框部分属于依赖管理模型，通过坐标描述当前项目依赖的第三方jar包。与传统手动复制jar包到lib目录的方式不同，Maven项目只需在pom.xml中配置依赖的坐标信息，对应的jar包会存储在本地Maven仓库中，供项目直接引用。

2.3 Maven仓库

Maven仓库用于存储资源，主要管理各种jar包，其本质是计算机上的一个目录（文件夹），用于存放开发过程中所需的所有依赖（jar包）和插件。

Maven仓库分为三类：

本地仓库：用户计算机上的一个目录，用于存储本地项目所需的jar包

中央仓库：由Maven团队维护的全球唯一仓库，仓库地址：https://repo1.maven.org/maven2/

远程仓库（私服）：通常由公司或团队搭建的私有仓库，用于存储内部项目依赖或共享资源

Maven项目依赖jar包的查找顺序：

当项目通过坐标引入依赖后，首先查找本地仓库是否存在对应jar包：

若存在，直接在项目中引用

若不存在，自动连接中央仓库下载对应jar包到本地仓库，再进行引用

若项目配置了远程仓库（私服），查找顺序变为：本地仓库 → 远程仓库 → 中央仓库

2.4 Maven安装与配置

要使用Maven，需先完成下载与安装配置，具体步骤如下：

2.4.1 下载

Maven官方下载地址：https://maven.apache.org/download.cgi

以下安装步骤是以apache-maven-3.9.4-bin.zip为例子。

2.4.2 安装配置步骤

Maven安装配置需完成4个核心步骤：1. 解压安装；2. 配置本地仓库；3. 配置阿里云私服；4. 配置环境变量。

1) 解压安装

将下载的apache-maven-3.9.4-bin.zip压缩包解压到无中文、无特殊字符的路径下（如E:\develop），解压即完成安装。

解压后目录说明：

bin目录：存放可执行命令（重点关注mvn命令）

conf目录：存放Maven配置文件（后续需修改settings.xml文件）

lib目录：存放Maven运行所需的依赖jar包（Maven基于Java开发，需依赖其他jar包）

2) 配置本地仓库

1.在本地计算机新建一个目录作为本地仓库（用于存储jar包），例如E:\maven-repo

2.进入Maven解压目录的conf文件夹，找到settings.xml配置文件，用记事本或专业编辑工具打开
3.定位到文件第53行左右，复制<localRepository>标签，粘贴到注释外部（如第55行）
将新建的本地仓库路径（如E:\maven-repo）替换掉<localRepository>标签体中的内容，保存文件

3) 配置阿里云私服

由于中央仓库位于国外，下载jar包速度较慢，阿里云提供了开源项目jar包的远程仓库，配置后可大幅提升下载速度。配置步骤：

打开conf目录下的settings.xml文件，定位到第160行左右的<mirrors>标签

在<mirrors>标签内添加如下<mirror>子标签，保存文件：

xml
<mirror>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<mirrorOf>central</mirrorOf>
</mirror>

注意：配置需放在<mirrors>...</mirrors>标签中间，不可放于标签外部。

4) 配置环境变量

Maven环境变量配置类似JDK环境变量配置，具体步骤：

1.打开系统环境变量配置界面（Win10：此电脑→属性→高级系统设置→环境变量）,在系统变量区域点击"新建"，变量名设为MAVEN_HOME，变量值设为Maven解压安装目录

（如E:\develop\apache-maven-3.9.4），点击确定

2.找到系统变量中的Path变量，点击"编辑"，添加%MAVEN_HOME%\bin，点击确定保存

3.验证配置：打开DOS命令提示符（Win+R→cmd），输入mvn -v命令，若显示Maven版本、Java版本等信息，说明配置成功,命令为:

复制代码

mvn -v

5) 配置关联JDK版本（可选）

若需指定Maven项目的JDK版本，可在settings.xml文件的<profiles>标签内添加如下配置（以JDK17为例）：

复制代码

<profile>
        <id>jdk-17</id>
        <activation>
                <activeByDefault>true</activeByDefault>
                <jdk>17</jdk>
        </activation>
        <properties>
                <maven.compiler.source>17</maven.compiler.source>
                <maven.compiler.target>17</maven.compiler.target>
                <maven.compiler.compilerVersion>17</maven.compiler.compilerVersion>
        </properties>
</profile>

三、IDEA集成Maven

要在IDEA中使用Maven进行项目构建，需先完成IDEA与Maven的集成配置，具体包括全局设置、项目创建、坐标使用及项目导入等操作。

3.1 创建Maven项目

3.1.1 全局设置

全局设置可确保后续新建项目默认使用配置好的Maven环境，步骤：

1.进入IDEA欢迎页面，选择File → Close Project → Customize → All settings

2.在打开的All settings页面中，选择Build,Execution,Deployment → Build Tools → Maven

3.配置Maven主目录（Maven解压安装目录）、用户设置文件（conf/settings.xml）、本地仓库（已配置的本地仓库路径）

配置工程编译版本为17（与JDK版本一致）

点击Apply→OK保存配置，此时设置的信息为全局配置，后续新建项目默认使用此配置。

3.1.2 新建Maven项目

1.打开IDEA，创建空项目，命名为web-project01

2.进入项目后，点击小齿轮→Project Structure，设置项目JDK版本为17

3.右键项目，选择New → Module，选择Java语言，勾选Maven，点击Next,填写模块基本信息（GroupId、ArtifactId、Version），点击Finish完成模块创建

4.在Maven模块的src/main/java目录下创建HelloWorld类，编写简单代码并运行，验证项目创建成功

3.1.3 Maven项目目录结构

标准Maven项目目录结构如下：

|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| text maven-project01 |--- src (源代码目录和测试代码目录) |--- main (源代码目录) |--- java (源代码java文件目录) |--- resources (源代码配置文件目录) |--- test (测试代码目录) |--- java (测试代码java目录) |--- resources (测试代码配置文件目录) |--- target (编译、打包生成文件存放目录) |

3.1.4 pom文件详解

POM（Project Object Model）即项目对象模型，通过pom.xml文件描述当前Maven项目的核心信息。标准pom.xml文件内容如下：

XML 复制代码

<?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">
    <!-- POM模型版本 -->
    <modelVersion>4.0.0</modelVersion>

    <!-- 当前项目坐标 -->
    <groupId>com.itheima</groupId>
    <artifactId>maven-project01</artifactId>
    <version>1.0-SNAPSHOT</version>
    
    <!-- 项目的JDK版本及编码 -->
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

</project>

pom.xml标签说明：

<project>：pom文件的根标签，代表当前Maven项目

<modelVersion>：声明项目描述遵循的POM模型版本，目前最新版本为4.0.0，是必选标签

坐标标签（<groupId>、<artifactId>、<version>）：三者组合唯一标识项目在本地仓库中的位置

<maven.compiler.source>：指定编译JDK版本

<maven.compiler.target>：指定运行JDK版本

<project.build.sourceEncoding>：设置项目字符集（如UTF-8）

3.2 Maven坐标详解

Maven坐标是资源的唯一标识，通过坐标可唯一定位资源位置，用于定义项目或引入项目所需依赖。

Maven坐标核心组成（与pom.xml中的坐标标签一致）：

groupId：定义当前Maven项目隶属的组织名称，通常为域名反写（如com.itheima）

artifactId：定义当前Maven项目名称，通常为模块名称（如order-service、goods-service）

version：定义当前项目版本号，常见版本类型：

SNAPSHOT：快照版本，功能不稳定、处于开发中的版本

RELEASE：发行版本，功能趋于稳定、停止更新，可用于正式发布的版本

如下图就是使用坐标表示一个项目：

注意事项：

坐标可标识的资源包括插件、依赖、当前项目等

若当前项目需被其他项目依赖，必须在pom.xml中配置坐标信息。

3.3 导入Maven项目

在IDEA中导入已有的Maven项目有两种常用方式：

方式一：通过Project Structure导入

打开IDEA，选择File → Project Structure → Modules
点击"Import Module"，选择需导入的Maven项目的pom.xml文件
按照向导完成导入，即可在IDEA中打开该Maven项目

方式二：通过Maven面板导入

打开IDEA右侧的Maven面板（若未显示，可通过View → Tool Windows → Maven打开）
点击面板中的"+"（Add Maven Projects）按钮
选择需导入的Maven项目的pom.xml文件，点击OK即可完成导入

四、依赖管理

依赖指当前项目运行所需的jar包，Maven的依赖管理功能可简化jar包的引入、更新及冲突处理流程。本节将详细讲解依赖配置、依赖传递、依赖排除等核心操作。

4.1 依赖配置

4.1.1 基本配置步骤

在Maven项目中引入依赖需完成以下步骤（以引入spring-context依赖为例）：

在pom.xml文件中编写<dependencies>标签（若已存在可直接使用）

在<dependencies>标签内使用<dependency>标签引入具体依赖的坐标（groupId、artifactId、version）

配置示例：

XML 复制代码

<dependencies>
    <!-- 依赖 : spring-context -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.1.4</version>
    </dependency>
</dependencies>

点击IDEA中pom.xml文件右上角的"刷新"按钮，引入最新配置的依赖

依赖刷新说明：每次新增或修改依赖配置后，需点击刷新按钮，确保Maven能加载最新的依赖信息。

注意事项：

若引入的依赖在本地仓库不存在，Maven会自动连接远程仓库/中央仓库下载，下载过程耗时与网络速度相关，需耐心等待

若不清楚依赖的坐标信息，可通过Maven中央仓库（https://mvnrepository.com/）搜索获取。

4.1.2 依赖坐标查找方法

获取依赖坐标有三种常用方式，以查找logback-classic依赖为例：

方式一：通过中央仓库搜索

打开Maven中央仓库官网（https://mvnrepository.com/）
在搜索框输入"logback-classic"，点击搜索
在搜索结果中选择对应版本，复制其坐标配置

方式二：通过IDEA工具搜索

在pom.xml的<dependencies>标签内，输入<dependency>后按快捷键提示
在搜索框输入依赖名称（如logback-classic），选择对应依赖及版本，IDEA会自动补全坐标配置

方式三：熟练使用后的快速导入

对于常用依赖，可直接手动编写坐标配置，无需搜索工具辅助

4.1.3 依赖传递

在pom.xml中配置某个依赖后，通过IDEA右侧的Maven面板会发现，除了配置的依赖外，还会引入多个其他依赖，这是Maven的依赖传递特性导致的。

依赖传递定义：若Maven项目A依赖B，B依赖C，C依赖D，则A项目会自动引入B、C、D的依赖，即依赖会逐级传递。

若传递下来的依赖在项目开发中无需使用，可通过"排除依赖"功能将其移除。

4.1.4 排除依赖

排除依赖指主动断开某个传递依赖的资源，被排除的资源无需指定版本。配置方式如下（以排除spring-context依赖传递的micrometer-observation为例）：

XML 复制代码

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>6.1.4</version>

    <!--排除依赖, 主动断开依赖的资源-->
    <exclusions>
        <exclusion>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-observation</artifactId>
        </exclusion>
    </exclusions>
</dependency>

排除依赖示例效果：

1.默认情况下，通过依赖传递会引入micrometer-observation依赖

2.添加排除依赖配置后，micrometer-observation依赖会被移除

4.2 Maven生命周期

4.2.1 生命周期介绍

Maven的生命周期是对项目构建过程的抽象和统一，描述了一次项目构建需经历的所有阶段。在Maven出现前，不同项目的构建流程不统一，手动完成构建操作繁琐且易出错。

Maven总结了一套通用的、易扩展的项目构建生命周期，包含清理、初始化、编译、测试、打包、集成测试、验证、部署、站点生成等所有构建步骤。

Maven将项目构建生命周期划分为3套相互独立的生命周期：

clean：清理工作，用于移除上一次构建生成的文件

default：核心工作，包含编译、测试、打包、安装、部署等核心构建步骤

site：生成报告、发布站点等辅助工

每套生命周期包含多个有序的阶段（phase），后续阶段依赖于前面阶段的完成。开发中常用的生命周期阶段：

clean：移除上一次构建生成的文件（如target目录）

compile：编译项目源代码，生成class文件

test：使用单元测试框架（如JUnit）运行测试用例

package：将编译后的文件打包为jar、war等格式的归档文件

install：将打包后的归档文件安装到本地仓库，供其他项目依赖

重要说明：

Maven生命周期本身是抽象的，不执行具体构建操作，实际任务由对应的插件完成（如编译由compiler插件完成，打包由jar插件完成）

IDEA右侧的Maven工具栏提供了生命周期的快速访问通道，可直接点击执行对应阶段

生命周期的顺序是：clean --> validate --> compile --> test --> package --> verify --> install --> site --> deploy
我们需要关注的就是：clean --> compile --> test --> package --> install

4.2.2 生命周期执行方式

日常开发中，执行Maven生命周期有两种常用方式：

方式一：通过IDEA工具执行

打开IDEA右侧的Maven面板
展开项目对应的Lifecycle目录，找到需执行的生命周期阶段（如compile、test、package）
双击该阶段，IDEA会自动执行对应的构建操作

方式二：通过命令行执行

1.打开Maven项目对应的磁盘目录（如E:\web-project01\maven-project01）

2.在当前目录下打开CMD命令提示符（按住Shift键+右键，选择"在此处打开命令窗口"）

输入对应的Maven命令，按回车执行：

mvn compile：执行编译阶段

mvn test：执行测试阶段（会先执行compile阶段）

mvn package：执行打包阶段（会先执行compile、test阶段）

mvn install：执行安装阶段（会先执行compile、test、package阶段）

mvn clean：执行清理阶段

五、单元测试

测试是验证软件正确性、完整性、安全性和质量的核心过程。单元测试作为最基础的测试阶段，针对软件的最小功能单元（方法）进行测试，是开发人员保障代码质量的重要手段。本节将讲解单元测试的基础概念及基于JUnit框架的单元测试实现。

5.1 测试基础概念

5.1.1 测试阶段划分

软件测试按阶段可分为单元测试、集成测试、系统测试、验收测试，各阶段特点如下：

1. 单元测试

介绍：对软件的基本组成单位（如方法、类）进行测试，是最小测试单元

目的：检验软件基本组成单位的正确性

测试人员：开发人员

1. 集成测试

介绍：将已通过单元测试的模块，按设计要求组合成系统或子系统后进行的测试

目的：检查模块之间的协作是否正确

测试人员：开发人员

1. 系统测试

介绍：对已集成好的软件系统进行全面、彻底的测试

目的：验证软件系统的正确性、性能是否满足需求规格说明书的要求

测试人员：专业测试人员

1. 验收测试

介绍：交付前的正式测试，针对用户需求、业务流程进行验证

目的：验证软件系统是否满足验收标准，是否可交付给用户使用

测试人员：客户/需求方

5.1.2 测试方法分类

常用的测试方法包括白盒测试、黑盒测试和灰盒测试：

1. 白盒测试

特点：清楚软件内部结构、代码逻辑

用途：验证代码逻辑的正确性，常用于单元测试

1. 黑盒测试

特点：不清楚软件内部结构、代码逻辑，仅关注输入输出结果

用途：验证软件功能、兼容性等，常用于系统测试、验收测试

1. 灰盒测试

特点：结合白盒测试和黑盒测试的特点，既关注软件内部结构，也考虑外部功能表现

用途：适用于集成测试等中间阶段测试

5.2 JUnit入门

5.2.1 JUnit简介

单元测试是针对最小功能单元（方法）编写测试代码验证其正确性的过程。JUnit是最流行的Java单元测试框架之一，由第三方公司提供，可简化单元测试的编写和执行流程。

传统测试方式（main方法测试）的问题：

在JavaSE阶段，我们通常在main方法中编写测试代码，验证程序运行结果。

这种方式存在明显缺陷：

1. 测试代码与源代码混合在一起，难以维护

1. 一个方法测试失败会影响后续方法的执行

1. 无法实现自动化测试，也无法生成测试报告

JUnit框架的优势：

1. 测试代码与源代码分离（测试代码放在test目录），便于维护

1. 支持单个测试方法独立执行，不影响其他方法

1. 可实现自动化测试，自动分析测试结果并生成测试报告

5.2.2 JUnit入门程序

需求：使用JUnit框架对UserService中的getAge方法进行单元测试，验证其正确性。

实现步骤：

步骤1：引入JUnit依赖

在Maven项目的pom.xml文件中，添加JUnit的依赖配置（以JUnit 5为例）：

XML 复制代码

<!--Junit单元测试依赖-->
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.9.1</version>
    <scope>test</scope>
</dependency>

点击刷新按钮，确保依赖成功导入。

步骤2：编写测试类和测试方法

在test/java目录下，创建与main/java中对应的包结构（如com.itheima）

在该包下创建测试类，命名规范为"被测试类名+Test"（如UserServiceTest）

在测试类中编写测试方法，命名规范为"test+被测试方法名"（如testGetAge），方法需满足：public修饰、无返回值、无参数

在测试方法上添加@Test注解，标识该方法为JUnit测试方法

编写测试代码，调用被测试方法并验证结果

测试代码示例：

java 复制代码

package org.example;

import org.junit.jupiter.api.Test;

public class UserServiceTest {
    
    @Test
    public void testGetAge(){
        Integer age = new UserService().getAge("110002200505091218");
        System.out.println(age);
    }
}

步骤3：运行单元测试

在IDEA中运行测试方法的方式：

1. 点击测试方法左侧的运行按钮，选择"Run 'testGetAge()'"

1. 观察运行结果：测试通过时显示绿色，测试失败时显示红色

注意事项：

测试类命名规范：XxxxTest（如UserServiceTest）

测试方法命名规范：public void xxx()（通常为test+被测试方法名，如testGetAge）

5.3 断言

JUnit提供了一些辅助方法，用来帮我们确定被测试的方法是否按照预期的效果正常工作，这种方式称为断言。

示例演示：

java 复制代码

package org.example;

import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

public class UserServiceTest {
    
    @Test
    public void testGetAge2(){
        Integer age = new UserService().getAge("110002200505091218");
        Assertions.assertNotEquals(18, age, "两个值相等");
//        String s1 = new String("Hello");
//        String s2 = "Hello";
//        Assertions.assertSame(s1, s2, "不是同一个对象引用");
    }

    @Test
    public void testGetGender2(){
        String gender = new UserService().getGender("612429198904201611");
        Assertions.assertEquals("男", gender);
    }
}

测试结果输出：

5.4 常见注解

在JUnit中还提供了一些注解，还增强其功能，常见的注解有以下几个：

示例代码，演示@BeforeEach，@AfterEach，@BeforeAll，@AfterAll 注解：

java 复制代码

public class UserServiceTest {

    @BeforeEach
    public void testBefore(){
        System.out.println("before...");
    }

    @AfterEach
    public void testAfter(){
        System.out.println("after...");
    }

    @BeforeAll //该方法必须被static修饰
    public static void testBeforeAll(){ 
        System.out.println("before all ...");
    }

    @AfterAll //该方法必须被static修饰
    public static void testAfterAll(){
        System.out.println("after all...");
    }

    @Test
    public void testGetAge(){
        Integer age = new UserService().getAge("110002200505091218");
        System.out.println(age);
    }
    
    @Test
    public void testGetGender(){
        String gender = new UserService().getGender("612429198904201611");
        System.out.println(gender);
    }
 }

输出结果如下：

示例代码，演示@ParameterizedTest ，@ValueSource ，@DisplayName 注解：

java 复制代码

package org.example;

import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

@DisplayName("测试-学生业务操作")
public class UserServiceTest {

    @DisplayName("测试-获取年龄")
    @Test
    public void testGetAge(){
        Integer age = new UserService().getAge("110002200505091218");
        System.out.println(age);
    }

    @DisplayName("测试-获取性别")
    @Test
    public void testGetGender(){
        String gender = new UserService().getGender("612429198904201611");
        System.out.println(gender);
    }

    @DisplayName("测试-获取性别3")
    @ParameterizedTest
    @ValueSource(strings = {"612429198904201611","612429198904201631","612429198904201626"})
    public void testGetGender3(String idcard){
        String gender = new UserService().getGender(idcard);
         System.out.println(gender);
    }
}

输出结果如下：

5.5 依赖范围

依赖的jar包，默认情况下，可以在任何地方使用，在main目录下，可以使用；在test目录下，也可以使用。

在maven中，如果希望限制依赖的使用范围，可以通过 <scope>...</scope> 设置其作用范围。

作用范围：

主程序范围有效。（main文件夹范围内）
测试程序范围有效。（test文件夹范围内）
是否参与打包运行。（package指令范围内）

可以在pom.xml中配置 <scope></scope> 属性来控制依赖范围。

如果对Junit单元测试的依赖，设置了scope为 test，就代表，该依赖，只是在测试程序中可以使用，在主程序中是无法使用的。所以我们会看到如下现象：

如上图所示，给junit依赖通过scope标签指定依赖的作用范围。那么这个依赖就只能作用在测试环境，其他环境下不能使用。

scope的取值常见的如下：