Spring Boot（4）使用 IDEA 搭建 Spring Boot+MyBatis 项目全流程实战

一、⚡搞个引言

在当今的 Java 开发领域，Spring Boot 和 MyBatis 是构建企业级应用的一个强大组合，在业界掀起了腥风血雨。Spring Boot 以其快速开发、自动配置等特性，大大简化了 Spring 应用的搭建过程；而 MyBatis 作为优秀的持久层框架，提供了灵活的数据持久化解决方案。

而IntelliJ IDEA 作为一款功能强大的 Java 集成专业开发环境（IDE），为我们搭建和开发 Spring Boot + MyBatis 项目的时候提供了诸多便利。在本文里呀，笔者将详细阐述如何使用 IDEA 一步步搭建一个完整的 Spring Boot + MyBatis 项目，并深入探讨项目中的各个关键环节，以及如何部署和运行。

二、⚡开始搭建 Spring Boot 项目吧！

2.1 启动 IDEA 并创建新项目

1. 打开 IntelliJ IDEA，在欢迎界面点击 “Create New Project”。如果你已经了打开 IDEA，那你也可以通过菜单栏 “File” -> “New” -> “Project” 来创建新项目。
2. 在新建项目对话框的左侧，选择 “Spring Initializr”。这是 IDEA 提供的用于快速初始化 Spring Boot 项目的工具。右侧部分，首先确保选择了正确的 Java 开发工具包（SDK）。如果没有显示合适的 SDK，可以点击 “New” 按钮，在弹出的文件选择对话框中找到你安装的 JDK 目录，完成添加。
3. 点击 “Next” 进入项目元数据配置页面。在这里，需要填写项目的基本信息。“Group” 通常是公司或组织的域名倒序，例如，如果公司域名是example.com，那么 “Group” 可设为 com.example。“Artifact” 是项目的名称，例如设为 my - spring - boot - mybatis - project。版本号 “Version” 一般保持默认，也可根据项目需求进行修改。“Name” 和 “Description” 可以根据实际情况填写，用于描述项目的名称和用途。

2.2 选择项目依赖

1. 在 “Dependencies” 选项卡中，开始添加项目所需的依赖。Spring Initializr 提供了丰富的依赖库供选择，我们首先勾选 “Spring Web”。这个依赖包含了 Spring MVC 等相关组件，用于构建 Web 应用，使我们能够轻松创建 RESTful API 或传统的 Web 页面。
2. 接着，搜索并勾选 “MyBatis Framework”。MyBatis 是我们项目中用于数据库持久化的框架，它提供了强大的 SQL 映射和数据持久化功能。
3. 如果项目使用 MySQL 数据库，还需要搜索并勾选 “MySQL Driver”。这是连接 MySQL 数据库的驱动程序，确保项目能够与 MySQL 数据库建立连接并进行数据交互。
4. 除了上述核心依赖，根据项目实际需求，还可以添加其他依赖，如 “Spring Data Redis” 用于缓存，“Spring Security” 用于安全认证等。在本次示例中，先专注于搭建基础的 Spring Boot + MyBatis 项目，暂不添加其他额外依赖。点击 “Next” 进入下一步。

2.3 完成项目创建

1. 在这一步，选择项目的存储路径。点击 “Browse” 按钮，在文件浏览器中选择一个合适的文件夹来存放项目。
2. 点击 “Finish” 按钮，IDEA 将根据我们的配置，从 Spring Initializr 服务端下载项目的初始结构和依赖，并在 IDEA 中创建项目。这个过程可能需要一些时间，具体取决于网络速度和项目依赖的大小。等待项目创建完成后，我们将看到一个完整的 Spring Boot 项目结构。

三、📘项目结构剖析

1. src/main/java 目录：这是项目的主要 Java 代码源目录。在这个目录下，通常会按照包名进行分层结构组织。例如，我们创建的项目中，默认会有一个以 “Group” 和 “Artifact” 命名的顶级包，如com.example.myspringbootmybatisproject。在这个包下，我们可以进一步创建不同功能的子包，如controller用于存放控制器类，service用于存放业务逻辑类，mapper用于存放 MyBatis 的 Mapper 接口，entity用于存放实体类等。
2. src/main/resources 目录：这个目录用于存放项目的资源文件，如配置文件、静态资源（如 CSS、JavaScript、图片等）、模板文件（如 Thymeleaf 模板）等。其中，application.properties（或application.yml）文件是 Spring Boot 项目的核心配置文件，我们在这里配置数据库连接、服务器端口、日志级别等项目相关的参数。
3. src/test/java 目录：用于存放项目的测试代码。Spring Boot 提供了丰富的测试支持，结合 JUnit、Mockito 等测试框架，我们可以编写单元测试、集成测试等，确保项目的质量和稳定性。
4. pom.xml 文件：这是 Maven 项目的核心配置文件，用于管理项目的依赖、构建配置等。在我们创建的 Spring Boot 项目中，pom.xml文件已经自动添加了我们在创建项目时选择的依赖。例如，<dependency>标签中包含了 Spring Web、MyBatis、MySQL Driver 等依赖的坐标信息，Maven 会根据这些信息从远程仓库下载相应的依赖包。

四、✍配置数据库连接

1. 打开src/main/resources目录下的application.properties文件。如果项目使用application.yml文件进行配置，其语法结构会稍有不同，但实现的功能是一致的。
2. 为了连接 MySQL 数据库，我们需要在application.properties文件中添加以下配置：

spring.datasource.url = jdbc:mysql://localhost:3306/your_database_name?useSSL = false&serverTimezone = UTC
spring.datasource.username = your_username
spring.datasource.password = your_password
spring.datasource.driver - class - name = com.mysql.cj.jdbc.Driver

• spring.datasource.url指定了数据库的连接地址。其中，localhost表示数据库服务器运行在本地，如果数据库部署在远程服务器上，需要将其替换为远程服务器的 IP 地址。3306是 MySQL 数据库的默认端口号。your_database_name需要替换为实际的数据库名称。?useSSL = false&serverTimezone = UTC部分是连接参数，用于关闭 SSL 连接并设置时区为 UTC。
• spring.datasource.username和spring.datasource.password分别指定了连接数据库的用户名和密码，需要替换为你实际的数据库用户名和密码。
• spring.datasource.driver - class - name指定了 MySQL 数据库的驱动类，这里使用的是com.mysql.cj.jdbc.Driver，这是 MySQL 8.0 及以上版本的驱动类。如果使用的是较旧版本的 MySQL 数据库，可能需要使用com.mysql.jdbc.Driver驱动类。

五、✍ 创建 MyBatis 相关组件

5.1 实体类（Entity）

1. 在src/main/java目录下，创建一个用于存放实体类的包，例如com.example.entity。在这个包中，创建一个 Java 类来表示数据库中的表结构。以一个简单的用户表为例，创建User类：

package com.example.entity;

import lombok.Data;

@Data
public class User {
    private Long id;
    private String username;
    private String password;
}

1. 这里使用了 Lombok 库的@Data注解。Lombok 是一个非常实用的 Java 库，它通过注解的方式，在编译期自动生成 Java 类的常用方法，如getter、setter、equals、hashCode、toString等。使用 Lombok 可以大大减少样板代码，提高代码的简洁性和可读性。如果项目中没有添加 Lombok 依赖，需要手动编写这些方法。例如：

package com.example.entity;

public class User {
    private Long id;
    private String username;
    private String password;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass()!= o.getClass()) return false;
        User user = (User) o;
        return id.equals(user.id) && username.equals(user.username) && password.equals(user.password);
    }

    @Override
    public int hashCode() {
        return java.util.Objects.hash(id, username, password);
    }
}

5.2 Mapper 接口

1. 在src/main/java目录下，创建com.example.mapper包，用于存放 MyBatis 的 Mapper 接口。Mapper 接口定义了对数据库的操作方法，通过与 Mapper XML 文件（或使用注解方式）进行映射，实现对数据库的增、删、改、查操作。
2. 在com.example.mapper包中，创建UserMapper接口：

package com.example.mapper;

import com.example.entity.User;
import org.apache.ibatis.annotations.Mapper;
import java.util.List;

@Mapper
public interface UserMapper {
    List<User> findAllUsers();
    User findUserById(Long id);
    int insertUser(User user);
    int updateUser(User user);
    int deleteUserById(Long id);
}

1. @Mapper注解是 MyBatis 提供的，用于将这个接口标记为 Mapper 接口。Spring Boot 在启动时，会自动扫描带有@Mapper注解的接口，并为其创建代理实现类。这样，我们就可以在其他组件中通过依赖注入的方式使用这个接口，而无需手动编写实现类。在这个接口中，定义了五个方法，分别用于查询所有用户、根据用户 ID 查询用户、插入用户、更新用户和根据用户 ID 删除用户。这些方法的名称和参数根据实际的业务需求和数据库操作进行定义。

5.3 Mapper XML 文件

1. 在src/main/resources目录下，创建mapper文件夹，用于存放 Mapper XML 文件。Mapper XML 文件用于定义 SQL 语句，并将其与 Mapper 接口中的方法进行映射。在mapper文件夹中，创建UserMapper.xml文件，文件名需要与 Mapper 接口的名称相对应，只是将接口名中的驼峰命名法改为下划线命名法，并加上.xml后缀。
2. 在UserMapper.xml文件中，编写如下内容：

<?xml version="1.0" encoding="UTF - 8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis - 3 - mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
    <select id="findAllUsers" resultType="com.example.entity.User">
        SELECT * FROM user
    </select>
    <select id="findUserById" resultType="com.example.entity.User">
        SELECT * FROM user WHERE id = #{id}
    </select>
    <insert id="insertUser" parameterType="com.example.entity.User">
        INSERT INTO user (username, password) VALUES (#{username}, #{password})
    </insert>
    <update id="updateUser" parameterType="com.example.entity.User">
        UPDATE user SET username = #{username}, password = #{password} WHERE id = #{id}
    </update>
    <delete id="deleteUserById" parameterType="java.lang.Long">
        DELETE FROM user WHERE id = #{id}
    </delete>
</mapper>

1. 首先，<?xml version="1.0" encoding="UTF - 8"?>声明了 XML 文件的版本和编码格式。<!DOCTYPE mapper...>部分是文档类型定义（DTD），用于指定 Mapper XML 文件的结构和语法规则。<mapper>标签是 Mapper XML 文件的根标签，namespace属性需要设置为 Mapper 接口的全限定名，即com.example.mapper.UserMapper，这是为了将 Mapper XML 文件与对应的 Mapper 接口进行关联。
2. 在<mapper>标签内部，通过<select>、<insert>、<update>、<delete>等标签分别定义了 SQL 查询、插入、更新和删除语句。id属性的值需要与 Mapper 接口中对应的方法名一致，这样 MyBatis 才能正确地将接口方法与 SQL 语句进行映射。resultType属性指定了查询结果映射的 Java 类型，例如com.example.entity.User，表示将查询结果映射为User实体类对象。parameterType属性指定了 SQL 语句所需参数的 Java 类型，例如在插入和更新操作中，参数类型为com.example.entity.User，表示传入的参数是一个User对象；在删除操作中，参数类型为java.lang.Long，表示传入的参数是一个 Long 类型的用户 ID。

六、✍ 创建 Service 层

1. 在src/main/java目录下，创建com.example.service包，用于存放业务逻辑层的代码。业务逻辑层负责处理业务规则、调用数据访问层（Mapper 接口）进行数据操作，并向控制器层提供服务。
2. 在com.example.service包中，创建UserService接口，定义业务逻辑方法：

package com.example.service;

import com.example.entity.User;
import java.util.List;

public interface UserService {
    List<User> findAllUsers();
    User findUserById(Long id);
    int insertUser(User user);
    int updateUser(User user);
    int deleteUserById(Long id);
}

1. 接着，创建UserService接口的实现类UserServiceImpl：

package com.example.service;

import com.example.entity.User;
import com.example.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;

    @Override
    public List<User> findAllUsers() {
        return userMapper.findAllUsers();
    }

    @Override
    public User findUserById(Long id) {
        return userMapper.findUserById(id);
    }

    @Override
    public int insertUser(User user) {
        return userMapper.insertUser(user);
    }

    @Override
    public int updateUser(User user) {
        return userMapper.updateUser(user);
    }

    @Override
    public int deleteUserById(Long id) {
        return userMapper.deleteUserById(id);
    }
}

1. 在UserServiceImpl类中，首先使用@Autowired注解将UserMapper接口注入到类中。@Autowired注解是 Spring 提供的依赖注入注解，通过它，Spring 会在容器中查找UserMapper的实现类，并将其注入到userMapper变量中。然后，实现UserService接口中定义的方法，在这些方法中，调用UserMapper接口的对应方法来完成对数据库的操作。@Service注解用于将这个类标记为一个服务组件，Spring 会在扫描组件时将其注册到容器中。

七、✍ 创建 Controller 层

1. 在src/main/java目录下，创建com.example.controller包，用于存放控制器类。控制器类负责接收客户端的请求，调用业务逻辑层的方法进行处理，并将处理结果返回给客户端。
2. 在com.example.controller包中，创建UserController类：

package com.example.controller;

import com.example.entity.User;
import com.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;

    @GetMapping
    public List<User> findAllUsers() {
        return userService.findAllUsers();
    }

    @GetMapping("/{id}")
    public User findUserById(@PathVariable Long id) {
        return userService.findUserById(id);
    }

    @PostMapping
    public int insertUser(@RequestBody User user) {
        return userService.insertUser(user);
    }

    @PutMapping
    public int updateUser(@RequestBody User user) {
        return userService.updateUser(user);
    }

    @DeleteMapping("/{id}")
    public int deleteUserById(@PathVariable Long id) {
        return userService.deleteUserById(id);
    }
}

1. @RestController注解是 Spring 4.0 引入的一个组合注解，它相当于@Controller和@ResponseBody的组合。@Controller用于标记一个类为控制器组件，@ResponseBody用于将方法的返回值直接作为响应体返回给客户端，而不会进行视图解析。在这个控制器类中，所有的方法都返回数据给客户端，而不是返回视图，所以使用@RestController注解。
2. @RequestMapping("/users")注解用于映射请求路径，将所有以/users开头的请求映射到这个控制器类。在类中的各个方法上，使用@GetMapping、@PostMapping、@PutMapping、@DeleteMapping等注解来映射不同的 HTTP 请求方法。例如，@GetMapping用于映射 HTTP GET 请求，@PostMapping用于映射 HTTP POST 请求等。@PathVariable注解用于从请求路径中获取参数，例如@GetMapping("/{id}")中的{id}，通过@PathVariable Long id将路径中的id参数绑定到方法的id参数上。@RequestBody注解用于将请求体中的数据绑定到方法的参数上。

八、✍ 配置 MyBatis 扫描路径

在 Spring Boot 项目中，需要配置 MyBatis 扫描 Mapper 接口和 Mapper XML 文件的路径，确保 Spring Boot 能够正确加载它们。有多种方式可以实现这一配置，以下介绍两种常见的方法

8.1 在主应用类中配置

打开 Spring Boot 项目的主应用类（通常是带有@SpringBootApplication注解的类），例如MySpringBootMyBatisProjectApplication.java，在类上添加@MapperScan注解来指定 Mapper 接口的扫描路径。代码如下：

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.example.mapper")
public class MySpringBootMyBatisProjectApplication {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootMyBatisProjectApplication.class, args);
    }
}

在上述代码中，@MapperScan("com.example.mapper")指定了 MyBatis 要扫描com.example.mapper包及其子包下的所有 Mapper 接口。这样，Spring Boot 在启动时会自动为这些 Mapper 接口创建代理对象并注册到 Spring 容器中。

8.2 在配置文件中配置

除了在主应用类中配置，还可以在application.properties或application.yml文件中进行配置。在application.properties文件中添加如下配置：

mybatis.mapper - locations=classpath:mapper/*.xml
mybatis.type - aliases - package=com.example.entity

• mybatis.mapper - locations指定了 Mapper XML 文件的位置。classpath:mapper/*.xml表示在类路径下的mapper文件夹中查找所有的 XML 文件。这里的classpath指的是项目的资源目录src/main/resources。
• mybatis.type - aliases - package指定了实体类的别名包。通过设置这个属性，在 Mapper XML 文件中可以直接使用实体类的简单类名，而无需使用全限定名。例如，在UserMapper.xml文件中，resultType可以直接写成User，而不是com.example.entity.User。

如果使用application.yml文件进行配置，配置内容如下：

mybatis:
  mapper - locations: classpath:mapper/*.xml
  type - aliases - package: com.example.entity

这两种配置方式效果是一样的，可以根据项目的实际情况选择使用。

九、✍ 项目测试

9.1 编写单元测试

在src/test/java目录下，创建与src/main/java目录结构相对应的测试类。例如，对于UserService的测试类UserServiceTest.java，创建在com.example.service包下，代码如下：

import com.example.entity.User;
import com.example.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.List;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
public class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    public void testFindAllUsers() {
        List<User> users = userService.findAllUsers();
        assertNotNull(users);
    }

    @Test
    public void testFindUserById() {
        // 假设数据库中存在id为1的用户
        User user = userService.findUserById(1L);
        assertNotNull(user);
    }

    @Test
    public void testInsertUser() {
        User newUser = new User();
        newUser.setUsername("testUser");
        newUser.setPassword("testPassword");
        int result = userService.insertUser(newUser);
        assertEquals(1, result);
    }

    @Test
    public void testUpdateUser() {
        // 假设数据库中存在id为1的用户
        User user = userService.findUserById(1L);
        if (user!= null) {
            user.setPassword("newPassword");
            int result = userService.updateUser(user);
            assertEquals(1, result);
        }
    }

    @Test
    public void testDeleteUserById() {
        // 假设数据库中存在id为1的用户
        int result = userService.deleteUserById(1L);
        assertEquals(1, result);
    }
}

在上述测试类中，使用了 JUnit 5 框架进行单元测试。@SpringBootTest注解用于加载 Spring Boot 应用上下文，这样可以在测试类中使用 Spring 的依赖注入功能，注入UserService实例。每个测试方法对应UserService中的一个业务方法，通过调用这些方法并使用断言（如assertNotNull、assertEquals等）来验证方法的执行结果是否符合预期。

9.2 运行测试

在 IDEA 中，咱们可以通过以下几种方式运行测试：

• 在测试类的编辑器窗口中，点击测试类名或测试方法名左侧的绿色运行图标，选择运行单个测试方法或整个测试类。
• 在Project视图中，右键点击测试类文件，选择Run '测试类名'来运行整个测试类。
• 使用快捷键运行测试，例如在 Windows 系统中，默认快捷键是Ctrl + Shift + F10，在 Mac 系统中是Command + Shift + F10。运行测试后，IDEA 会在Run窗口中显示测试结果。如果所有测试方法都通过，会显示绿色的通过标识；如果有测试方法失败，会显示红色的失败标识，并在控制台输出详细的错误信息，帮助开发者定位问题。

十、📚项目部署

完成项目的开发和测试后，需要将项目部署到生产环境中。Spring Boot 项目可以很方便地部署到各种服务器上，常见的部署方式有以下几种：

10.1 打包成 JAR 文件部署

1. 在 IDEA 的右侧Maven工具窗口中，展开项目的Lifecycle节点，双击package命令。Maven 会根据项目的pom.xml配置，将项目打包成一个可执行的 JAR 文件。打包完成后，在项目的target目录下会生成一个以项目名称和版本号命名的 JAR 文件，例如my - spring - boot - mybatis - project - 0.0.1 - SNAPSHOT.jar。
2. 将生成的 JAR 文件上传到目标服务器上。可以使用工具如scp（在 Linux 系统中）或WinSCP（在 Windows 系统中）进行文件传输。
3. 在服务器上，通过命令行运行 JAR 文件：

java -jar my - spring - boot - mybatis - project - 0.0.1 - SNAPSHOT.jar

Spring Boot 内置了 Tomcat 等 Web 服务器，运行 JAR 文件后，项目会启动并监听配置的端口（默认为 8080）。可以通过访问服务器的 IP 地址和端口号来访问项目的接口。

10.2 部署到容器化环境（如 Docker）

1. 首先，在项目的根目录下创建一个Dockerfile文件，内容如下：

FROM openjdk:11
ADD target/my - spring - boot - mybatis - project - 0.0.1 - SNAPSHOT.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

上述Dockerfile中，FROM openjdk:11指定了基础镜像为 OpenJDK 11。ADD target/my - spring - boot - mybatis - project - 0.0.1 - SNAPSHOT.jar app.jar将本地打包好的 JAR 文件添加到镜像中的app.jar位置。ENTRYPOINT ["java", "-jar", "/app.jar"]定义了容器启动时要执行的命令，即运行 JAR 文件。

2. 在项目根目录下打开命令行，执行以下命令构建 Docker 镜像：

docker build -t my - spring - boot - mybatis - project.

其中，-t参数用于指定镜像的标签，my - spring - boot - mybatis - project是镜像的名称，最后的.表示当前目录，即根据当前目录下的Dockerfile构建镜像。

3. 构建完成后，可以使用以下命令查看本地镜像列表：

docker images

找到刚刚构建的my - spring - boot - mybatis - project镜像。

4. 运行镜像创建容器：

docker run -d -p 8080:8080 my - spring - boot - mybatis - project

-d参数表示在后台运行容器，-p 8080:8080将容器的 8080 端口映射到主机的 8080 端口。这样，通过访问主机的 8080 端口，就可以访问容器中运行的 Spring Boot 项目。

十一、📚搞个总结和展望

通过以上步骤，我们就成功地使用 IDEA 搭建了一个 Spring Boot + MyBatis 项目啦，并完成了从项目创建、配置、开发、测试到部署的全流程。Spring Boot 和 MyBatis 的结合，充分发挥了两者的优势，使得项目开发高效、灵活且易于维护。在实际项目中，还可以根据需求进一步扩展和优化项目，例如：

• 添加缓存：引入 Spring Cache 或 Redis 等缓存技术，提高系统的性能和响应速度。
• 集成安全框架：使用 Spring Security 进行用户认证和授权，确保系统的安全性。
• 日志管理：配置 Logback 或 Log4j 等日志框架，记录系统运行时的日志信息，方便调试和排查问题。
• 性能优化：对数据库查询进行优化，使用索引、分页等技术，提高数据访问效率。

随着现在计算机技术的不断发展，Spring Boot 和 MyBatis 也在持续更新和演进。所以我们需要不断学习和关注新技术的发展趋势，以便在项目中应用最新的技术和最佳实践，提升项目的质量和竞争力。希望本文能为大家在搭建和开发 Spring Boot + MyBatis 项目时提供有益的参考和指导呀。

✍结尾

🀙🀚🀛🀜🀝🀞🀟🀠🀡🀐🀑🀒🀓🀔🀕🀖🀘🀗🀏🀎🀍🀌🀋🀊🀉🀈🀇🀆🀅🀃🀂🀁🀀🀄︎🀢🀣🀥🀤🀦🀧🀨🀩🀪

📘 妹妹听后点了点头，脸上露出了满意的笑容。她轻声说道：“原来如此，谢谢你，鸽鸽。看来我不仅要多读书，还要多动手实践，提升自己才行。”

看着她那充满求知欲的眼神，我不禁感叹，学习之路虽然充满挑战，但有这样一位美丽聪慧的伙伴相伴，一切都变得格外有意义。快去和妹妹一起实践一下吧！

📘相关阅读⚡⚡

笔者 綦枫Maple 的其他作品，欢迎点击查阅哦~：
📚Jmeter性能测试大全：Jmeter性能测试大全系列教程！持续更新中！
📚UI自动化测试系列： Selenium+Java自动化测试系列教程❤
📚移动端自动化测试系列：Appium自动化测试系列教程
📚Postman系列：Postman高级使用技巧系列

👨‍🎓作者：綦枫Maple
🚀博客：CSDN、掘金等
🚀CSDN技术社区：https://bbs.csdn.net/forums/testbean
🚀网易云音乐：https://y.music.163.com/m/user?id=316706413
🚫特别声明：原创不易，转载请附上原文出处链接和本文声明，谢谢配合。
🙏版权声明：文章里可能部分文字或者图片来源于互联网或者百度百科，如有侵权请联系处理。
🀐其他：若有兴趣，可以加文章结尾的Q群，一起探讨学习哦~