没有制作或是没有计划制作详细操作的作业内容将在 快截止提交时 发布在此
👉 仅代码·JavaEE企业级应用课程作业纯实操

前言

必看！请确认完下述注意事项后再开始边看边练！

本文基于学校课程《Java EE 企业级应用》内容编撰，不含IDE编辑器、IDE编辑器插件、环境（Java、MySQL）的安装与破解教程。
另外本文尽量按照课堂教学流程编纂，如您参考本文完成课堂作业请所有操作以本文为主！

本文会以代码框形式附上对应代码并标注注意事项，但仍建议您手动敲写代码并善用 自动补全 功能，因为该功能会在补全后 自动导入 缺少的包，而且手动敲写代码有助于对项目的理解。

本文所有附图看不清可点击图片放大查看
本文所附代码部分未修改部分会使用注释注明省略，例如// 此处省略其他代码 ...
本文所附代码新增部分均有注释标注，例如// <<< 新增 // ↓↓↓ 新增，登录按钮的响应逻辑实现 // ↑↑↑ 新增，登录按钮的响应逻辑实现
请仅敲写或修改带有新增与修改注释或者在新增注释范围内的代码！
另外本文除了Java的 // 注释还会有xml的  注释，注意分辨！
为避免误导，除截图以外的所有代码块都不含首行的 package 包字段，该字段在创建文件时会自动生成！

有关于代码高亮的注意事项

不同编辑器显示代码的格式不同，例如下图中 左是 IntelliJ IDEA 编辑器 右是 VS Code 编辑器 ，本博客使用的代码高亮格式也和下图的两种编辑器 不一样 ，所以在边看边练实操中出现高亮内容不一致是正常的。

本博客使用的代码高亮格式示例代码：

/**
 * @author Yaklo
 */
public class CreateOperFrame extends JFrame {
    public CreateOperFrame() {
        initComponents();
    }

    private void button1(ActionEvent e) {
        // TODO add your code here
        String operNo = txtOperNo.getText();
        String pwd = new String(txtPwd.getPassword());
        String pwdAgain = new String(txtPwdAgain.getPassword());
        String operName = txtOperName.getText();

        //空输入校验检查
        if (StringUtils.isEmpty(operNo)) {
            JOptionPane.showMessageDialog(CreateOperFrame.this,"操作员账号不能为空！");
            txtOperNo.requestFocus();
            return;
        }

此注意事项仅为让您 理解与解惑 什么编辑器里的代码高亮与本篇文章的代码高亮不一致

☆环境要求与文件下载

建议
操作系统：Windows 7
编辑器：IntelliJ IDEA 非社区版
数据库：MySQL 5.x
数据库编辑器：Navicat Premium 15
运行环境：Java 8

本文使用环境
操作系统：Windows 11
编辑器：IntelliJ IDEA 2023.2.8 非社区版
数据库：MySQL 8.2.0
数据库编辑器：Navicat Premium 17
运行环境：Java 8

相关内容链接： 由于所使用环境均为国外产品，下载速度慢请耐心等待
~~IntelliJ IDEA 官网下载页~~*请勿下载社区版，另外2024版可能无法破解！2023下载请见下方！
MySQL 官网下载页 请安装8.x版本
Liberica JDK Java环境，项目使用JDK8
Navicat Premium 17 简体中文官网下载页 需破解，相关文章见下方

相关教程链接：
笨鸟教程：Intellij IDEA 2023.2 版本永久激活破解教程
 CSDN：IntelliJ IDEA设置为中文，中文汉化教程，附详细图解 简单来说就是在Plugins(插件)页面安装中文插件
CSDN：超详细MySQL安装及基本使用教程 请注意：数据库密码请设置为123456
CSDN：启动本地mysql的几种方式
 CSDN：2024最新 Navicat Premium 17.0.8 简体中文版破解激活永久图文详细教程 教程相关文件见下方

相关文件下载：
ideaIU-2023.2.8.exe > 官网下载 文件大小774MB
[Intellij IDEA 2023 破解脚本]激活码.zip > 蓝奏云 | 蓝奏云2 | Yaklo.Sodayo | OneDrive
Navicat16.3补丁.zip > 蓝奏云 | 蓝奏云2 | Yaklo.Sodayo | OneDrive

其他内容查阅：
YakloBlog：MySQL笔记 内容稍欠缺，但可作为参考。

★环境检查单

请确认所有环境以及需破解的都完成后再开始实训！

请确保你已正确安装了 > IntelliJ IDEA 非社区版编辑器、MySQL8版本以上、Navicat Premium15版本或以上、Java8版本
请确保你已经破解了 > Navicat Premium
请确保你已经启动了 > MySQL

除了上述配置你还可以阅读如下文章快速补全其他环境配置
1-2 修改IJ设置 | E1-1 [必看]安装MyBatisX

请确认所有环境以及需破解的都完成后再开始实训！

AI辅助学习方法

个人推荐不是广告

在学习或完成作业的流程中有不懂的地方或BUG冒红等等都可以将有疑问的部分复制下来进行询问
注意在使用AI工具时须甄别AI生成的内容，AI有时也会犯错，感觉不对或没得到想要的答案可以新建一个会话重新问AI或者使用其他AI工具

推荐使用以下AI应用网站
豆包 doubao.com 免登录一个会话交流三句
Kimi.ai 需要登录
国外 · ChatGPT.com 国内与香港IP无法使用，免登录
国外 · Copilot.microsoft.com 原：NewBing，免登录

以下四张图是我随便截的和ai交流的记录：

☆课程关联导览

下述带有底色的字体均为超链接，点击即跳转对应章节

[第一节课]20240903 > 无代码实操
[第二节课]20240905 > 1 初始化项目与修改IDEA配置 2 实现数据库连接与查询
[第三节课]20240910 > 3 添加日志输出
[第四节课]20240912 > 4 chapter02 5 chapter02测试 ←实验1关联的课程
[第五节课]20240919 > E1-2 打开基础环境 E1-3 完成接口如何写映射 5 动态SQL 至 5-3用户查询部分
[第六节课]20240923 > 5-4 动态查询 至 5-7批量删除部分
[第七节课]20240924 > 6 chatper03s

1 初始化项目与修改IDEA配置

1-1 导入项目文件

下载文件 ssm20240903.zip

ssm20240903.zip > 蓝奏云 | 蓝奏云2 | Yaklo.Sodayo | OneDrive

将压缩包 ssm20240903.zip 内容解压至 D盘下的文件夹ssm

在 Intellij IDEA 编辑器关闭的情况下双击打开 proj文件夹 下的 proj.iml 文件，选择 Intellij IDEA 打开

第一次打开项目时会显示是否信任该项目，将 信任 D:\ssm 中的项目 勾选后点击 信任项目 以打开项目。

1-2 修改IJ设置

①先点击 Intellij IDEA 编辑器窗口左上角的 四横杠
②再点击出现的新菜单中的文件选项
③选择设置
④打开编辑器/常规/自动导入 设置项，勾选 动态添加明确的import 和 动态优化import
⑤打开编辑器/常规/代码补全 设置项，取消勾选 区分大小写

打开编辑器/文件编码 设置项，设置 项目编码 和 属性文件的默认编码 为 UTF-8 ,设置好后点击右下角确定以保存刚刚的所有设置

1-3 配置Maven

长按鼠标将 D:/ssm 目录下的 Maven 配置文件 settings.xml 拖动到 Intellij IDEA 编辑器窗口内以打开并编辑

浏览 settings.xml 文件 第159行 修改替换 <mirror> 配置部分

<mirror>
  <id>aliyunmaven</id>
  <mirrorOf>*</mirrorOf>
  <name>阿里云公共仓库</name>
  <url>https://maven.aliyun.com/repository/public</url>
</mirror>

浏览 settings.xml 文件 倒数第二行 在 </setting> 前一行插入 </profiles>
此处为老师提供的文件存在问题，正常的 Maven 配置文件是不会存在此问题的

编辑完成使用 Ctrl S 快捷键进行保存，保存后关闭 settings.xml 文件

①打开构建、执行、部署/构建工具/Maven 设置项
②检查
用户设置文件 D:\ssm\settings.xml
本地仓库路径 D:\ssm\maven_repository
以及是否勾选重写与 使用 .mvn/maven.config 中的设置
正常情况下无需修改，如果设置出现变动与教程不符请进行修改！
③检查完毕后点击确定以保存并关闭设置

2 实现数据库连接与查询

2-1 创建Maven项目

①右键 proj
②选择 新建/模块......，在弹出的新建模块窗口中选择 新建模块
③检查配置
名称修改为 chapter01 构建系统选择 Maven JDK选择 1.8
取消勾选 添加示例代码 组ID修改为 cn.fvti 检查工作ID是否为 chapter01
④点击创建以创建chapter01模块

2-2 修改模块内Maven配置

~~前往 Maven Rapository 寻找要导入的jar包：MySQL 驱动 mybatis 依赖 junit~~
我已经找好并将需要的配置文件放在了下方，打开处于 chapter01 模块下的 pom.xml 文件，将下面的 <dependencies> 配置复制进 第11行

<dependencies>
    <!--1. MySQL 驱动-->
    <!-- https://mvnrepository.com/artifact/com.mysql/mysql-connector-j -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <version>8.4.0</version>
    </dependency>
    <!--2. mybatis 依赖-->
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.16</version>
    </dependency>
    <!--3. junit-->
    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

点击如图所示中的按钮开始导入刚刚配置的jar包

2-3 数据库数据导入

安装mysql后无法连接报错：Can't connect to MySQL server on 'localhost' 或 Can't connect to MySQL server on '数据库IP'
可能是mysql服务端没启动或者被关闭了，查看教程启动一下 > CSDN：启动本地mysql的几种方式

2-3-1 链接数据库

打开Navicat Premium点左上角连接， 连接筛选 选中 MySQL , 连接类型 选中 MySQL 后点击右下角 下一步

在这个新建连接页面 填写数据库密码 后测试链接尝试连接，能连接后点击确定
可以修改 连接名称 取个别名，如果你的数据库 不在本地 可以修改主机为你的数据库服务器地址例如192.168.50.10

2-3-2 数据导入

[数据库文件下载]chapter01.sql > 蓝奏云 | 蓝奏云2 | Yaklo.Sodayo | OneDrive
通过蓝奏云渠道下载的需先解压

双击刚刚通过连接页面创建的数据库以 连接数据库
随后将预先创建好的数据库 文件拖入窗口 以准备导入
请确保你的 我的连接 里 选中了 例如图中的 MySQL 再拖入文件，否则无法导入！
请注意：此处要导入的数据库为chapter01，下图是偷懒用的以前的图

直接点击开始
请注意：此处要导入的数据库为chapter01，下图是偷懒用的以前的图

直接点击关闭
请注意：此处要导入的数据库为chapter01，下图是偷懒用的以前的图

按下键盘按键 F5 刷新数据库，刷新后能看到刚刚的导入的数据库
请注意：此处要导入的数据库为chapter01，下图是偷懒用的以前的图

2-4 创建软件包

从此章节后不再演示如何创建软件包的过程，仅简单提示文件处于何处！
如果看不清图片点击图片即可放大查看

发现了吗，当一个软件包下有至少两个文件的时候就可以更方便的在这个软件包下创建其他软件包了！

请按照如上教程创建如下四个软件包：
cn.fvti.chapter01.controller cn.fvti.chapter01.domain
cn.fvti.chapter01.mapper cn.fvti.chapter01.service

2-5 编写实体类

在软件包 cn.fvti.chapter01.domain 下新建Java类 User

从此章节后不再演示如何创建Java类（包括类下面的接口）的过程，仅简单提示文件处于何处！
如果看不清图片点击图片即可放大查看

将以下内容添加进新建的Java类 User ，可根据注释熟悉部分快捷操作

package cn.fvti.chapter01.domain;

import java.util.Date;

/**
 *  Java中的类和数据库中的表很像
 *  1. Java封装： getter,setter
 */
public class User {
    //此处创建的自变量是数据库中的字段名，详见下图
    private Integer id;
    private String name;
    private String sex;
    private double weight;
    private Date birthday;

    //以下代码可以在编辑器右键选择生成
    //在弹出的生成窗口中选择Getter和Setter去一键生成
    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    //以下代码可以使用生成菜单中的toString()一键生成
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", weight=" + weight +
                ", birthday=" + birthday +
                '}';
    }
}

Java类 User 中，创建的自变量所对应数据库中的字段名

2-6 配置mybatis核心配置文件

在资源文件夹 resources 中新建文件：db.properties mybatis-config.xml

将以下内容添加进文件 db.properties
其中 localhost:3306 是你的数据库服务器IP与端口，chapter01 是你要连接的数据库

mysql.driver=com.mysql.cj.jdbc.Driver
mysql.url=jdbc:mysql://localhost:3306/chapter01?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
mysql.username=root
mysql.password=123456

将以下内容添加进文件 mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

<!-- 环境配置 -->
<!-- 加载类路径下的属性文件 -->
<properties resource="db.properties"/>
<typeAliases>
<!--告诉mybatis，实体类的路径-->
<package name="cn.fvti.chapter01.domain"></package>
</typeAliases>

<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<!-- 数据库连接相关配置 ,db.properties文件中的内容-->
<dataSource type="POOLED">
<property name="driver" value="${mysql.driver}"/>
<property name="url" value="${mysql.url}"/>
<property name="username" value="${mysql.username}"/>
<property name="password" value="${mysql.password}"/>
</dataSource>
</environment>
<environment id="prod">
<transactionManager type="JDBC"/>
<!-- 数据库连接相关配置 ,db.properties文件中的内容-->
<dataSource type="POOLED">
<property name="driver" value="${mysql.driver}"/>
<property name="url" value="${mysql.url}"/>
<property name="username" value="admin"/>
<property name="password" value="admin"/>
</dataSource>
</environment>
</environments>
<!-- mapping文件路径配置 -->
<mappers>
<!--<mapper resource="cn.fvti/chapter01/mapper/UserMapper.xml"/>-->
<!--<mapper resource="cn.fvti/chapter01/mapper/CarMapper.xml"/>-->
<!--<mapper resource="cn.fvti/chapter01/mapper/BookMapper.xml"/>-->
<!--扫包：要求  1. mapper接口和映射xml文件必须拥有相同的目录结构  2. mapper接口和映射xml文件的名字必须是一致-->
<package name="cn.fvti.chapter01.mapper"></package>
</mappers>

</configuration>

2-7 编写mapper接口

在软件包 cn.fvti.chapter01.mapper 下新建Java接口 UserMapper

UserMapper.java 内容为

package cn.fvti.chapter01.mapper;

import cn.fvti.chapter01.domain.User;

/**
 *  1.将来每一个实体类都会写一个mapper文件，这个文件是interface,
 *  文件名取名字的规则是：实体类名+mapper（行业的规范）
 */
public interface UserMapper {
    User getUserById(Integer id);
}

2-8 编写映射文件

在在资源文件夹 resources 中新建目录：cn/fvti/chapter01/mapper
注意这里是创建目录而不是创建软件包不能使用 " . " 进行分隔，需使用 " / "

在目录 cn/fvti/chapter01/mapper 下新建文件：UserMapper.xml
该文件主要用于实现SQL语句和Java对象之间的映射

将以下内容添加进文件 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">
<!--1. 约束头大家都一样-->
<!--2. 全限定类名-->
<!--3. 编写MySQL脚本-->
<mapper namespace="">
</mapper>

右键软件包 cn.fvti.chapter01.mapper 下的Java接口 UserMapper 点击 复制路径/引用 选择 复制引用 将内容复制进 <mapper namespace=""> 的 namespace 中

继续编辑文件 UserMapper.xml 将 <select> 内容添加进 <mapper> 中，如下代码所示

<mapper namespace="cn.fvti.chapter01.mapper.UserMapper">
    <select id="getUserById" resultType="cn.fvti.chapter01.domain.User">
        select * from user where id =#{id}
    </select>
</mapper>

2-9 使用mybatis进行数据库查询

在目录 test/java 中新建软件包 cn.fvti.chapter01.test
并在这个软件包中新建Java类 TestMyBatis 以编写测试代码
小提示：可以在新建类的时候将软件包也打进去会自动创建软件包

在Java类 TestMyBatis 中键入如下代码

package cn.fvti.chapter01.test;

import cn.fvti.chapter01.domain.User;
import cn.fvti.chapter01.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.Reader;

public class TestMyBatis {
    @Test
    public void getUserById() {
        try {
            // 1. 读取mybatis核心文件
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            // 2. 创建SqlSeessionFactoryBuilder
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            // 3. 创建SqlSessionFactory
            SqlSessionFactory sessionFactory = builder.build(reader);
            // 4. 拿到SqlSession
            SqlSession session = sessionFactory.openSession(true);
            // 5. 拿到UserMapper.java这个接口的代理实现类
            UserMapper mapper = session.getMapper(UserMapper.class);

            User userById = mapper.getUserById(1);
            System.out.println(userById);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在有 @Test 的方法中可以使用方法开头左侧的运行按钮单独测试此方法的代码

可以看到原先的测试按钮打上了绿勾显示测试通过，同时编辑器下方也正确输出了数据库中的内容

恭喜完成[第二节课]20240905内容

3 添加日志输出

3-1 导入log4j依赖

①打开处于目录 proj/chapter01 下的 pom.xml 文件
②将log4j的依赖字段添加进倒数第三行， </dependencies> 语句块的前面，代码如下，效果如下图所示

<!--4. log4j-->
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

③点击Maven刷新按钮刷新配置

3-2 添加log4j配置

添加log4j的目的是在项目运行的过程中，可以实时查看sql执行步骤

在资源文件夹 resources 中新建文件：log4j.xml

将以下内容添加进文件 log4j.xml
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"> 爆红是正常的！

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS}%m
(%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

3-3 测试log4j输出

重新运行上一章节结尾的测试代码

日志的级别
FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)
从左到右打印的内容越来越详细

3-4 [可选]插入数据

该部分代码可能不一定要完成，在老师下发的文档中并没有这一部分的关键性代码，但这一部分在课堂上有讲过。

3-3-1 在接口中添加代码

在软件包 cn.fvti.chapter01.mapper 中的Java接口 UserMapper
做如下修改，注意注释！

package cn.fvti.chapter01.mapper;

import cn.fvti.chapter01.domain.User;

import java.util.Date; // <<< 新增，Date数据类型需要引用的软件包

/**
 *  1.将来每一个实体类都会写一个mapper文件，这个文件是interface,
 *  文件名取名字的规则是：实体类名+mapper（行业的规范）
 */
public interface UserMapper {
    User getUserById(Integer id);
    // ↓↓↓ 新增，插入数据部分
    Integer insertUser(String name, String sex, double weight, Date birthday);
}

3-3-2 在映射文件中添加代码

在资源文件夹 resources 中的目录 cn/fvti/chapter01/mapper 下
修改文件 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">
<!--1. 约束头大家都一样-->
<!--2. 全限定类名-->
<!--3. 编写MySQL脚本-->
<mapper namespace="cn.fvti.chapter01.mapper.UserMapper">
    <!-- ↓↓↓ 新增，MySQL插入语句部分 -->
    <insert id="insertUser">
        insert into user (name,sex,weight,birthday)values(#{arg0},#{arg1},#{arg2},#{arg3})
    </insert>
    <!-- ↑↑↑ 新增，MySQL插入语句部分 -->
    <select id="getUserById" resultType="cn.fvti.chapter01.domain.User">
        select * from user where id =#{id}
    </select>
</mapper>

3-3-3 在测试类中添加代码

在测试目录 test/java 中软件包 cn.fvti.chapter01.test 下的
测试类 TestMyBatis 的 public class TestMyBatis 方法里添加如下代码

    @Test
    public void insertUser(){
        try{
            // 1. 读取mybatis核心文件
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            // 2. 创建SqlSeessionFactoryBuilder
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            // 3. 创建SqlSessionFactory
            SqlSessionFactory sessionFactory = builder.build(reader);
            // 4. 拿到SqlSession
            SqlSession session = sessionFactory.openSession(true);
            // 5. 拿到UserMapper.java这个接口的代理实现类
            UserMapper mapper = session.getMapper(UserMapper.class);

            Integer res = mapper.insertUser("小李","男",82,new Date());
            if(res>0){
                System.out.println("插入一条数据成功");
            }else{
                System.out.println("插入数据成功");
            }
            //释放资源
            session.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

运行测试代码，并查看输出的日志

使用F5刷新后能看到数据库中新增了刚刚运行测试类中插入部分添加的数据

恭喜完成[第三节课]20240910内容

4 chapter02

4-1 新建项目

①右键 proj
②选择 新建/模块......，在弹出的新建模块窗口中选择 新建模块
③检查配置
名称修改为 chapter02 构建系统选择 Maven JDK选择 1.8
取消勾选 添加示例代码 组ID修改为 cn.fvti 检查工作ID是否为 chapter02
④点击创建以创建chapter02模块

在包目录 src/main/java 下新建软件包
cn.fvti.chapter02.domain 存放实体类 cn.fvti.chapter02.mapper 存放映射接口类
在资源目录 src/main/resources 下新建目录 cn/fvti/chapter02/mapper 存放映射xml文件
目录使用 " / " 符号分隔！
在测试目录 src/test/java 下新建软件包 cn.fvti.chapter02 存放测试代码

4-2 Maven配置依赖

①打开处于 chapter02 模块下的 pom.xml 文件，将下面的 <dependencies> 配置复制进 第11行
②点击Maven配置刷新按钮以导入依赖
Maven 配置在图片的下方！

<dependencies>
    <!--1. MySQL 驱动-->
    <!-- https://mvnrepository.com/artifact/com.mysql/mysql-connector-j -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <version>8.4.0</version>
    </dependency>
    <!--2. mybatis 依赖-->
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.16</version>
    </dependency>
    <!--3. junit-->
    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!--4. log4j-->
    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
</dependencies>

4-3 添加log4j配置

添加log4j的目的是在项目运行的过程中，可以实时查看sql执行步骤

在 chapter02 资源文件夹 resources 中新建文件：log4j.xml
复用了chapter01的操作图，但是操作是一样的！

将以下内容添加进文件 log4j.xml
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"> 爆红是正常的！

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS}%m
(%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

4-4 创建chapter02数据库

打开Navicat连接MySQL数据库
①右键，新建数据库
②修改数据库名称 chapter02 字符集 utf8mb4
修改好后点新建数据库窗口右下角的确定即可创建数据库

①右键刚刚创建好的数据库 chapter02 点击 新建查询
②在查询编辑区域里将下方SQL语句复制粘贴进去
③点击查询编辑区域上方运行
④运行成功后在编辑区域下方会有OK提示
SQL语句在图片下方

use chapter02;
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for stu
-- ----------------------------
DROP TABLE IF EXISTS `stu`;
CREATE TABLE `stu`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `stu_id` varchar(48) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `name` varchar(48) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `age` int(11) NULL DEFAULT NULL,
  `position` varchar(48) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `sex` char(4) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 21 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of stu
-- ----------------------------
INSERT INTO `stu` VALUES (1, '20226471', '张震南', 19, '普通学生', '男');
INSERT INTO `stu` VALUES (2, '20228202', '莫云熙', 22, '普通学生', '男');
INSERT INTO `stu` VALUES (3, '20226762', '贾晓明', 19, '普通学生', '男');
INSERT INTO `stu` VALUES (4, '20228312', '于璐', 22, '劳动委员', '女');
INSERT INTO `stu` VALUES (5, '20227205', '曹云熙', 20, '劳动委员', '男');
INSERT INTO `stu` VALUES (6, '20222414', '王嘉伦', 19, '副班长', '男');
INSERT INTO `stu` VALUES (7, '20225800', '崔安琪', 22, '劳动委员', '女');
INSERT INTO `stu` VALUES (8, '20229809', '邵震南', 22, '普通学生', '男');
INSERT INTO `stu` VALUES (9, '20228101', '姜嘉伦', 22, '普通学生', '男');
INSERT INTO `stu` VALUES (10, '20223224', '于子异', 20, '普通学生', '男');
INSERT INTO `stu` VALUES (11, '20229660', '方睿', 22, '学习委员', '男');
INSERT INTO `stu` VALUES (12, '20220805', '郭睿', 21, '普通学生', '男');
INSERT INTO `stu` VALUES (13, '20227179', '徐睿', 20, '班长', '男');
INSERT INTO `stu` VALUES (14, '20226612', '邓子韬', 20, '普通学生', '男');
INSERT INTO `stu` VALUES (15, '20224345', '金云熙', 21, '劳动委员', '男');
INSERT INTO `stu` VALUES (16, '20220188', '杨致远', 21, '学习委员', '男');
INSERT INTO `stu` VALUES (17, '20228098', '孔杰宏', 20, '普通学生', '男');
INSERT INTO `stu` VALUES (18, '20226313', '钱云熙', 18, '副班长', '男');
INSERT INTO `stu` VALUES (19, '20227355', '龙杰宏', 21, '普通学生', '男');
INSERT INTO `stu` VALUES (20, '20225418', '任璐', 18, '班长', '女');

SET FOREIGN_KEY_CHECKS = 1;

SQL语句运行完毕后
①使用F5刷新Navicat
②双击打开chapter02数据库stu表
即可查看刚刚使用SQL语句导入的数据

4-5 domain类准备

在目录 src/main/java 软件包 cn.fvti.chapter02.domain 下创建Java类 Student

在Java类 Student 中声明 id（编号）、stu_id（学号）、name（姓名）、age（年龄）、position（学生职位）和sex（性别）属性，以及属性对应的 Getter/Setter 方法。
Getter/Setter方法可以在声明完对应属性后右键编辑器选择生成在生成菜单中快捷生成

package cn.fvti.chapter02.domain;

public class Student {
    /**
     * 主键id
     */
    private Integer id;
    /**
     * 学号
     */
    private String stuId;
    /**
     * 姓名
     */
    private String name;
    /**
     * 年龄
     */
    private Integer age;
    /**
     * 学生职位
     */
    private String position;
    /**
     * 性别
     */
    private String sex;

    public Integer getId() {
        return id;
    }
    
    // ↓↓↓ 以下代码可以在编辑器右键选择生成
    // ↓↓↓ 在弹出的生成窗口中选择Getter和Setter去一键生成
    public void setId(Integer id) {
        this.id = id;
    }

    public String getStuId() {
        return stuId;
    }

    public void setStuId(String stuId) {
        this.stuId = stuId;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getPosition() {
        return position;
    }

    public void setPosition(String position) {
        this.position = position;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

4-6 建立mapper映射

4-6-1 编写mapper接口文件

在目录 src/main/java 软件包 cn.fvti.chapter02.mapper 下创建Java接口 StudentMapper

在Java接口 StudentMapper 中声明方法，如下代码

package cn.fvti.chapter02.mapper;

import cn.fvti.chapter02.domain.Student;

public interface StudentMapper {

    /**
     * 根据stu_id查询学生信息
     * @param student 学生id
     * @return 返回
     */
    public Student findByStuId(Student student);

    /**
     * 新增学生信息
     * @param student
     * @return
     */
    public Integer insertStudent(Student student);

    /**
     * 根据stu_id修改学生信息
     * @param student
     * @return
     */
    public Integer updateStudentByStuId(Student student);

    /**
     * 根据stu_id删除学生信息
     * @param student
     * @return
     */
    public Integer deletStudentByStuId(Student student);
}

4-6-1-1 注释的巧用

小贴士：在方法前面敲写 /** 再回车，编辑器会根据你所写的方法、传参和对应返回值（如果有）生成一个注释模板，编辑模板后将鼠标放在 方法名 上即可显示对应注释。
使用 //注释内容 写的注释无法显示在方法中！

4-6-2 编写mapper映射文件

在资源目录 src/main/resources 中的目录 cn/fvti/chapter02/mapper 下创建文件 StudentMapper.xml
该文件主要用于实现SQL语句和Java对象之间的映射

将以下内容添加进文件 StudentMapper.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为映射的根节点 -->
<!-- mapper为映射的根节点，namespace指定mapper接口的全限定类名
mybais会根据这个接口动态创建一个实现类去实现这个接口，
而这个实现类是一个Mapper对象 -->
<mapper namespace="cn.fvti.chapter02.mapper.StudentMapper">
    <select id="findByStuId" resultType="cn.fvti.chapter02.domain.Student">
        select * from stu where stu_id = #{stuId}
    </select>
    <insert id="insertStudent">
        insert into stu(stu_id, name, age, position, sex)
        values (#{stuId}, #{name}, #{age}, #{position}, #{sex})
    </insert>
    <update id="updateStudentByStuId">
        update stu set name = #{name}, age = #{age}, position = #{position}, sex = #{sex}
        where stu_id = #{stuId}
    </update>
    <delete id="deletStudentByStuId">
        delete from stu where stu_id = #{stuId}
    </delete>
</mapper>

开头 <?xml> <!DOCTYPE> 是xml约束头
<select> 语句块中编写了一条根据stu_id查询学生信息的SQL语句
<insert> 语句块中编写了一条插入学生信息的SQL语句
<update> 语句块中编写了一条根据stu_id修改学生信息的SQL语句
<delete> 语句块中编写了一条根据stu_id删除学生信息的SQL语句。

4-7 配置连接数据库

4-7-1 添加mybatis核心配置文件

在资源目录 src/main/resources 下创建文件
mybatis-config.xml jdbc.properties
注意，是新建以上两个文件不是一个文件！

将以下内容添加进文件 mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!-- 环境配置 -->
    <!-- 加载类路径下的属性文件 -->
    <properties resource="jdbc.properties"/>
    <typeAliases>
        <!--告诉mybatis，实体类的路径-->
        <package name="cn.fvti.chapter02.domain"></package>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <!-- 数据库连接相关配置 ,db.properties文件中的内容-->
            <dataSource type="POOLED">
                <property name="driver" value="${mysql.driver}"/>
                <property name="url" value="${mysql.url}"/>
                <property name="username" value="${mysql.username}"/>
                <property name="password" value="${mysql.password}"/>
            </dataSource>
        </environment>
        <environment id="prod">
            <transactionManager type="JDBC"/>
            <!-- 数据库连接相关配置 ,db.properties文件中的内容-->
            <dataSource type="POOLED">
                <property name="driver" value="${mysql.driver}"/>
                <property name="url" value="${mysql.url}"/>
                <property name="username" value="admin"/>
                <property name="password" value="admin"/>
            </dataSource>
        </environment>
    </environments>
    <!-- mapping文件路径配置 -->
    <mappers>
        <!--<mapper resource="cn/fvti/chapter02/mapper/UserMapper.xml"/>-->
        <!--<mapper resource="cn/fvti/chapter02/mapper/CarMapper.xml"/>-->
        <!--<mapper resource="cn/fvti/chapter02/mapper/BookMapper.xml"/>-->
        <!--扫包：要求  1. mapper接口和映射xml文件必须拥有相同的目录结构  2. mapper接口和映射xml文件的名字必须是一致-->
        <package name="cn.fvti.chapter02.mapper"></package>
    </mappers>

</configuration>

4-7-2 添加jdbc配置

将以下内容添加进文件 jdbc.properties

mysql.driver=com.mysql.cj.jdbc.Driver
mysql.url=jdbc:mysql://localhost:3306/chapter02?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
mysql.username=root
mysql.password=123456

4-8 编写工具类

在目录 src/main/java 新建软件包 cn.fvti.chapter02.utils 并创建Java类 MyBatisUtils
该类用于封装读取配置文件信息的代码

你可以直接在 chapter02 下创建Java类 utils.MyBatisUtils 其中 utils 会自动被创建为软件包
以下展示快捷创建方法

将以下内容添加进Java类 MyBatisUtils

package cn.fvti.chapter02.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.Reader;

public class MyBatisUtils {
    private static SqlSessionFactory sqlSessionFactory = null;

    // 初始化SqlSessionFactory对象
    static {
        try {
            // 使用MyBatis提供的Resources类加载MyBatis的配置文件
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            // 构建SqlSessionFactory工厂
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 获取SqlSession对象的静态方法
    public static SqlSession getSession(){
        return sqlSessionFactory.openSession(true);
    }
}

第17行代码读取mybatis-config.xml文件内容到reader对象中；第19行代码创建SqlSessionFactory类的实例；第26行代码定义一个getSession()静态方法，并在静态方法中通过SqlSessionFactory类的实例创建SqlSession实例。

4-9 测试类

在目录 test/java 的测试软件包 cn.fvti.chapter02
并在这个软件包中新建Java类 MyBatisTest 以编写测试代码

4-9-1 查询数据

在 MyBatisTest 测试类中添加 findByStuId() 方法，该方法可以根据stu_id查询学生信息。 findByStuId() 方法具体代码如下所示。

package cn.fvti.chapter02;

import cn.fvti.chapter02.domain.Student;
import cn.fvti.chapter02.mapper.StudentMapper;
import cn.fvti.chapter02.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class MyBatisTest {
    @Test
    public void findByStuId() {
        // 提供工具类生成SqlSession对象
        SqlSession session = MyBatisUtils.getSession();
        StudentMapper mapper = session.getMapper(StudentMapper.class);
        Student student = new Student();
        student.setStuId("20226471");
        Student byStuId = mapper.findByStuId(student);
        System.out.println(byStuId);
        // 关闭SqlSession
        session.close();
    }
}

上述代码中，第13行代码通过MyBatisUtils工具类获取SqlSession对象；第14行代码获得获取代理实现类，第17行代码根据stu_id查询学生信息，并返回查询到的Student对象；第18行代码打印查询到的Student对象；第20行代码关闭SqlSession，释放资源。

在有 @Test 的方法中可以使用方法开头左侧的运行按钮单独测试此方法的代码
可以看到运行后正常输出了 log4j 和代码中 打印查询到的Student对象 内容

4-9-2 插入数据

在 MyBatisTest 测试类中添加 insertStudent() 方法，该方法用于插入学生信息。 insertStudent() 方法具体代码如下所示。

@Test
public void insertStudent() {
    // 通过工具类生成SqlSession对象
    SqlSession session = MyBatisUtils.getSession();
    StudentMapper mapper = session.getMapper(StudentMapper.class);
    Student student = new Student();
    student.setStuId("20226471");
    student.setName("李平");
    student.setAge(20);
    student.setPosition("普通学生");
    student.setSex("男");
    Integer res = mapper.insertStudent(student);
    if (res > 0) {
        System.out.println("插入数据成功");
    }
    // 关闭SqlSession
    session.close();
}

上述代码中，第4行代码通过MyBatisUtils工具类获取SqlSession对象；第6-11行代码创建了一个Student对象并对其进行赋值；第12行代码执行代理实现类的插入方法insertStudent()，插入新的学生信息，并返回插入记录的条数；第13-15行代码是判断数据是否插入成功；第17行代码关闭SqlSession。

在有 @Test 的方法中可以使用方法开头左侧的运行按钮单独测试此方法的代码
可以看到运行后正常输出了 log4j 和代码中 "插入数据成功" 内容

验证一下数据是否正常插入数据库
打开 Navicat 使用 F5 刷新后即可看到刚刚插入的数据

4-9-3 更新数据

在 MyBatisTest 测试类中添加 updateStudentByStuId() 方法，该方法用于更新学生信息。 updateStudentByStuId() 方法具体代码如下所示。

@Test
public void updateStudentByStuId() {
    // 通过工具类生成SqlSession对象
    SqlSession session = MyBatisUtils.getSession();
    StudentMapper mapper = session.getMapper(StudentMapper.class);
    Student student = new Student();
    student.setStuId("20226471");
    student.setName("张静");
    student.setAge(18);
    student.setPosition("班长");
    student.setSex("女");
    Integer res = mapper.updateStudentByStuId(student);
    if (res > 0) {
        System.out.println("修改数据成功");
    }
    // 关闭SqlSession
    session.close();
}

上述代码中，第4行代码通过MyBatisUtils工具类获取SqlSession对象；第6-11行代码创建一个Student对象并对其进行赋值；第12行代码是执行更新方法updateStudentByStuId()，更新学生信息，并返回更新记录的条数；第13-15行代码判断数据是否更新成功；第17行代码关闭SqlSession。

在有 @Test 的方法中可以使用方法开头左侧的运行按钮单独测试此方法的代码
可以看到运行后正常输出了 log4j 和代码中 "修改数据成功" 内容

验证一下数据是否正常被修改
打开 Navicat 使用 F5 刷新后即可看到刚刚修改的数据

4-9-4 删除数据

在 MyBatisTest 测试类中添加 deleteStudentByStuId() 方法，该方法用于删除学生信息。 deleteStudentByStuId() 方法具体代码如下所示。

@Test
public void deleteStudentByStuId() {
    // 通过工具类生成SqlSession对象
    SqlSession session = MyBatisUtils.getSession();
    StudentMapper mapper = session.getMapper(StudentMapper.class);
    Student student = new Student();
    student.setStuId("20226471");
    Integer res = mapper.deletStudentByStuId(student);
    if (res > 0) {
        System.out.println("删除数据成功");
    }
    // 关闭SqlSession
    session.close();
}

上述代码中，第4行代码通过MyBatisUtils工具类获取SqlSession对象；第8行代码执行代理实现类mapper的删除方法deleteStudentByStuId()，删除学生信息，并返回删除记录的条数；第9~11行代码判断数据是否删除成功；第13行代码关闭SqlSession。

在有 @Test 的方法中可以使用方法开头左侧的运行按钮单独测试此方法的代码
可以看到运行后正常输出了 log4j 和代码中 "删除数据成功" 内容

验证一下数据是否正常被删除
打开 Navicat 使用 F5 刷新后即可看到刚刚删除的数据已经从数据库消失了

恭喜完成[第四节课]20240912内容

E1 间章1-[含必看]

E1-1 [必看]安装MyBatisX

在 IntelliJ IDEA 编辑器中安装插件 MyBatisX 可以自动识别 Mapper 映射文件以及通过快捷键快速创建接口对应映射语句块，以及在相关文件和代码前面标准小蓝鸟或者小红鸟，小鸟图标具体见下图

E1-2 [来自PDF]打开基础环境

本章节内容来自课上讲解的补充部分
与云班课下载ssm20240919.zip压缩包老师的pdf内容相同

①修改文件夹的名称为ssm
2.chapter02-20240919.pdf.图片1.webp
②进入ssm 目录
2.chapter02-20240919.pdf.图片2.webp
③信任项目
2.chapter02-20240919.pdf.图片3.webp
④配置Maven
2.chapter02-20240919.pdf.图片4.webp
2.chapter02-20240919.pdf.图片5.webp
⑤有时候需要进行SDK配置（当你打开java代码发现很多红色报错）
2.chapter02-20240919.pdf.图片6.webp

E1-3 [来自PDF]完成接口如何写映射

编写完mapper接口，怎么写映射文件（xml）

本章节内容来自课上讲解的补充部分
与云班课下载ssm20240919.zip压缩包老师的pdf内容相同

E1-3-1 硬敲

①在xml中编写约束头
②在xml中编写对应的 select,update,delete,update标签，来对应mapper接口中的方法

E1-3-2 使用mybatisX

使用mybatisX优雅的进行xml编写
①下载mybatisX
2.chapter02-20240919.pdf.图片7.webp
②创建映射文件目录
2.chapter02-20240919.pdf.图片8.webp
③生成映射文件
2.chapter02-20240919.pdf.图片9.webp
2.chapter02-20240919.pdf.图片10.webp
④编写接口方法对应的SQL
2.chapter02-20240919.pdf.图片11.webp

5 动态SQL

5-1 快速开始

chapter03 基于 chapter01 编译，需要将 chapter01 内文件复制一份并将所有文件中的 chapter01 字段内容全部 重构/重命名 为 chapter03
如果没有 chapter01 可以下载下方 ssm5.7z 重构 chapter01 后从本章节 6-1-1 重构项目 部分快速开始！

请务必安装MyBatisX插件后再开始👉E1-1 [必看]安装MyBatisX

ssm5.7z > 蓝奏云 | 蓝奏云2 | OneDrive
须解压至D盘下，使用D:\ssm目录，非D盘目录请自行配置 👉 E1-2 打开基础环境

5-2 重构项目

新建项目 chapter03

通过重构功能快速复制模块 chapter01 src目录 至模块 chapter03 下

将以下Maven配置内容添加到模块 chapter03 下文件 pom.xml 中，并 点击Maven刷新按钮刷新配置！

<dependencies>
    <!--1. MySQL 驱动-->
    <!-- https://mvnrepository.com/artifact/com.mysql/mysql-connector-j -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <version>8.4.0</version>
    </dependency>
    <!--2. mybatis 依赖-->
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.16</version>
    </dependency>
    <!--3. junit-->
    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!--4. log4j-->
    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
</dependencies>

①右键模块 chapter03 中的软件包 cn.fvti.chapter01 点击 重构/重命名 ，在新弹出的窗口中点击 当前模块中的所有
②修改重命名内容为 chapter03 ，一定要勾选 在注释和字符中搜索
③修改作用域为 模块 'chapter03' ，点击预览查看即将被修改的文件

点开简单检查一下是不是所有修改都在模块和目录 chapter03 下进行就可以点击重构了

将模块 chapter03 下资源目录 resources 中文件 mybatis-config.xml
第12行和第43行的漏网之鱼 chapter01 修改为 chapter03

最后一步
将模块 chapter03 下资源目录 resources 中数据库连接配置文件 db.properties 的漏网之鱼修改一下
mysql.url=jdbc:mysql://localhost:3306/chapter03?此处省略指令若干...

5-2-1 初始化数据库

使用 Navicat 创建 chapter03 数据库

选择数据库 chapter03 新建查询

将以下初始化SQL指令复制进查询后运行即可，运行后按 F5 刷新一下就可以在Navicat中看到刚刚导入的数据了

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '名字',
  `sex` char(2) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT '未知' COMMENT '性别',
  `weight` double DEFAULT NULL COMMENT '体重',
  `birthday` date DEFAULT NULL COMMENT '生日',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES (1, '张三', '未知', 180, '2000-10-01');
INSERT INTO `user` VALUES (2, '王五', '男', 170, '2024-09-24');
INSERT INTO `user` VALUES (3, '李四', '女', 160, '2024-09-25');

SET FOREIGN_KEY_CHECKS = 1;

5-3 用户查询

在软件包 cn.fvti.chapter03.mapper 中Java接口 UserMapper 添加如下代码

List<User> getUsersByLikeNameAndSex(@Param("name") String name, @Param("sex") String sex);

请注意后期不再详细指导该操作，且该操作较为常用！
使用快捷方法快速创建对应映射：

方法一（本文默认提示本方法）
点击冒红字段 getUsersByLikeNameAndSex 按键盘快捷键 ALT 回车 选择 Generate statement
方法二
鼠标放在冒红字段上 getUsersByLikeNameAndSex 等待一两秒后在出现的界面选择 Generate statement
如果不小心点击了一下就将鼠标挪走再挪回来

现在自动跳转到了资源目录 resources 中目录 cn/yaklo/chapter03/mapper 下的 Mapper 映射文件 UserMapper.xml ，并且自动创建了对应的XML语句块，直接敲回车从下一行开始填入SQL语句

<select id="getUsersByLikeNameAndSex" resultType="cn.fvti.chapter03.domain.User">
    select * from user where name like concat(#{name},"%") and sex = #{sex}
</select>

在目录 test/java 的测试软件包 cn.fvti.chapter03.test 下测试类 TestMyBatis 中添加 getUsersByLikeNameAndSex() 方法查询用户，可以复制类中其他的测试方法进行修改

@Test
public void getUsersByLikeNameAndSex(){
    try{
        // 1. 读取mybatis核心文件
        Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
        // 2. 创建SqlSeessionFactoryBuilder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 3. 创建SqlSessionFactory
        SqlSessionFactory sessionFactory = builder.build(reader);
        // 4. 拿到SqlSession
        SqlSession session = sessionFactory.openSession(true);
        // 5. 拿到UserMapper.java这个接口的代理实现类
        UserMapper mapper = session.getMapper(UserMapper.class);
        List<User> users = mapper.getUsersByLikeNameAndSex("张", "未知");
        System.out.println(users);
        //释放资源
        session.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

运行测试后成功查询到对应用户信息

5-4 动态查询

在软件包 cn.fvti.chapter03.mapper 中Java接口 UserMapper 添加如下代码

List<User> getUsersByNameAndSexAndWeight(User user);

点击冒红字段 getUsersByNameAndSexAndWeight 按键盘快捷键 ALT 回车 选择 Generate statement
现在自动跳转到了资源目录 resources 中目录 cn/yaklo/chapter03/mapper 下的 Mapper 映射文件 UserMapper.xml ，并且自动创建了对应的XML语句块，直接敲回车从下一行开始填入SQL语句

<select id="getUsersByNameAndSexAndWeight" resultType="cn.fvti.chapter03.domain.User">
    select * from user
    <where>
        <if test="name !=null and name!=''">
            and name like concat(#{name},"%")
        </if>
        <if test="sex !=null and sex!=''">
            and sex = #{sex}
        </if>
        <if test="weight !=null and weight!=''">
            and weight > #{weight}
        </if>
    </where>
</select>

在目录 test/java 的测试软件包 cn.fvti.chapter03.test 下测试类 TestMyBatis 中添加 getUsersByNameAndSexAndWeight() 方法查询用户，可以复制类中其他的测试方法进行修改

@Test
public void getUsersByNameAndSexAndWeight(){
    try{
        // 1. 读取mybatis核心文件
        Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
        // 2. 创建SqlSeessionFactoryBuilder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 3. 创建SqlSessionFactory
        SqlSessionFactory sessionFactory = builder.build(reader);
        // 4. 拿到SqlSession
        SqlSession session = sessionFactory.openSession(true);
        // 5. 拿到UserMapper.java这个接口的代理实现类
        UserMapper mapper = session.getMapper(UserMapper.class);

        User user = new User();

        //可以自由修改或注释尝试查询不同字段以及不同值
        //user.setName("王五");
        user.setSex("女");
        //user.setWeight(160.0);

        List<User> users = mapper.getUsersByNameAndSexAndWeight(user);
        System.out.println(users);
        //释放资源
        session.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

运行测试后成功查询到对应用户信息
可以自由修改或注释尝试查询不同字段以及不同值，运行测试后在下方查看查询结果

5-5 不一样的动态查询

在软件包 cn.fvti.chapter03.mapper 中Java接口 UserMapper 添加如下代码

List<User> getUsersByNameOrSexOrWeight(User user);

点击冒红字段 getUsersByNameOrSexOrWeight 按键盘快捷键 ALT 回车 选择 Generate statement
现在自动跳转到了资源目录 resources 中目录 cn/yaklo/chapter03/mapper 下的 Mapper 映射文件 UserMapper.xml ，并且自动创建了对应的XML语句块，直接敲回车从下一行开始填入SQL语句

<select id="getUsersByNameOrSexOrWeight" resultType="cn.fvti.chapter03.domain.User">
    select * from user where 1=1
    <choose>
        <when test="name !=null and name!=''">
            and name like concat(#{name},"%")
        </when>
        <when test="sex !=null and sex!=''">
            and sex = #{sex}
        </when>
        <otherwise>
            and weight > #{weight}
        </otherwise>
    </choose>
</select>

在目录 test/java 的测试软件包 cn.fvti.chapter03.test 下测试类 TestMyBatis 中添加 getUsersByNameOrSexOrWeight() 方法查询用户，可以复制类中其他的测试方法进行修改

@Test
public void getUsersByNameOrSexOrWeight(){
    try{
        // 1. 读取mybatis核心文件
        Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
        // 2. 创建SqlSeessionFactoryBuilder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 3. 创建SqlSessionFactory
        SqlSessionFactory sessionFactory = builder.build(reader);
        // 4. 拿到SqlSession
        SqlSession session = sessionFactory.openSession(true);
        // 5. 拿到UserMapper.java这个接口的代理实现类
        UserMapper mapper = session.getMapper(UserMapper.class);

        User user = new User();

        //根据映射文件得知此处按顺序判断为空则使用下一条进行查询
        user.setName("张");
        user.setSex("未知");
        user.setWeight(60.0); //映射文件得知如果前面两个都为空就会使用此字段进行查询

        List<User> users = mapper.getUsersByNameOrSexOrWeight(user);
        System.out.println(users);
        //释放资源
        session.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

运行测试后成功查询到对应用户信息

5-6 更新数据

在软件包 cn.fvti.chapter03.mapper 中Java接口 UserMapper 添加如下代码

Integer updateUser(User user);

点击冒红字段 updateUser 按键盘快捷键 ALT 回车 选择 Generate statement
现在自动跳转到了资源目录 resources 中目录 cn/yaklo/chapter03/mapper 下的 Mapper 映射文件 UserMapper.xml ，并且自动创建了对应的XML语句块，直接敲回车从下一行开始填入SQL语句

<update id="updateUser">
    update user
    <set>
        <if test="name != null and name != ''">
            name = #{name},
        </if>
        <if test="sex != null and sex != ''">
            sex = #{sex},
        </if>
        <if test="weight != null and weight != ''">
            weight = #{weight},
        </if>
    </set>
    where id = #{id}
</update>

在目录 test/java 的测试软件包 cn.fvti.chapter03.test 下测试类 TestMyBatis 中添加 updateUser() 方法修改用户，可以复制类中其他的测试方法进行修改

@Test
public void updateUser(){
    try{
        // 1. 读取mybatis核心文件
        Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
        // 2. 创建SqlSeessionFactoryBuilder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 3. 创建SqlSessionFactory
        SqlSessionFactory sessionFactory = builder.build(reader);
        // 4. 拿到SqlSession
        SqlSession session = sessionFactory.openSession(true);
        // 5. 拿到UserMapper.java这个接口的代理实现类
        UserMapper mapper = session.getMapper(UserMapper.class);

        User user = new User();
        //user.setName("张");
        //user.setSex("未知");
        user.setWeight(60.0); //被修改字段与修改值
        user.setId(1); //被修改ID

        Integer users = mapper.updateUser(user);
        System.out.println(users);
        //释放资源
        session.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

运行测试后成功修改对应用户信息，在 Navicat 里使用 F5 刷新后即可查看到修改后的数据

5-7 批量删除

尝试从测试类开始编写批量删除

在目录 test/java 的测试软件包 cn.fvti.chapter03.test 下测试类 TestMyBatis 中添加 getUsersByNameAndSexAndWeight() 方法删除用户，可以复制类中其他的测试方法进行修改

@Test
public void deleteUsers(){
    try{
        // 1. 读取mybatis核心文件
        Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
        // 2. 创建SqlSeessionFactoryBuilder
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 3. 创建SqlSessionFactory
        SqlSessionFactory sessionFactory = builder.build(reader);
        // 4. 拿到SqlSession
        SqlSession session = sessionFactory.openSession(true);
        // 5. 拿到UserMapper.java这个接口的代理实现类
        UserMapper mapper = session.getMapper(UserMapper.class);

        List<Integer> idList = new ArrayList<Integer>();
        idList.add(1);
        idList.add(2);
        idList.add(3);

        Integer res = mapper.deleteUsers(idList);

        //释放资源
        session.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

点击这段测试代码中冒红字段 deleteUsers 按键盘快捷键 ALT 回车 选择 在 'UserMapper' 中创建方法 'deleteUsers'

在测试类中使用快捷方法在软件包 cn.fvti.chapter03.mapper 中Java接口 UserMapper 自动创建了如下代码

Integer deleteUsers(List<Integer> idList);

小做一下修改，添加 @Param("idList")

Integer deleteUsers(@Param("idList") List<Integer> idList);

点击冒红字段 deleteUsers 按键盘快捷键 ALT 回车 选择 Generate statement 在新弹出的窗口有两个 Delete Statement 随便选一个就行
现在自动跳转到了资源目录 resources 中目录 cn/yaklo/chapter03/mapper 下的 Mapper 映射文件 UserMapper.xml ，并且自动创建了对应的XML语句块，直接敲回车从下一行开始填入SQL语句

<delete id="deleteUsers">
    delete from user where id in 
    <foreach collection="idList" item="id" open="(" separator="," close=")">
        #{id}
    </foreach>
</delete>

回到测试类 MyBatisTest 进行删除测试
运行测试后成功删除对应用户信息，在 Navicat 里使用 F5 刷新后即可查看到修改后的数据

恭喜完成[第五、六节课]20240923内容

6 chatper03s

找不到工程文件了？没事使用包含本文chapter01与chapter02内容的工程文件快速开始👇

ssm5.7z > 蓝奏云 | 蓝奏云2 | OneDrive
须解压至D盘下，使用D:\ssm目录，非D盘目录请自行配置 👉 E1-2 打开基础环境

因实验与课堂教学模块重名，顾在本文中改名为 chapter03s
如果你没有完成第五章动态SQL可以创建chapter03进行操作

请务必安装MyBatisX插件后再开始👉E1-1 [必看]安装MyBatisX
按照老师的笔记还需安装lombok插件，但一般IJ自带了该插件，你也可以前往设置/插件检查你是否安装了该插件
Lombok作用可以快速生成getter/setter/toString等方法，后续在创建实体类的时候会使用到。

⚠注意⚠ 另外本章节 复用了很多以前截取的操作图，都已进行注释！ ⚠

6-1 新建项目

①右键 proj
②选择 新建/模块......，在弹出的新建模块窗口中选择 新建模块
③检查配置
名称修改为 chapter03s 构建系统选择 Maven JDK选择 1.8
取消勾选 添加示例代码 组ID修改为 cn.fvti 检查工作ID是否为 chapter03s
④点击创建以创建chapter03s模块

在包目录 src/main/java 下新建软件包
cn.fvti.chapter03s.domain 存放实体类 cn.fvti.chapter03s.mapper 存放映射接口类
在资源目录 src/main/resources 下新建目录 cn/fvti/chapter03s/mapper 存放映射xml文件
目录使用 " / " 符号分隔！
在测试目录 src/test/java 下新建软件包 cn.fvti.chapter03s 存放测试代码
请注意此处复用了chapter02的操作图，而你正在完成chapter03s的内容！

6-2 Maven配置依赖

①打开处于 chapter03s 模块下的 pom.xml 文件，将下面的 <dependencies> 配置复制进去
②点击Maven配置刷新按钮以导入依赖
此处不放图，想必你应该知道在哪添加~

<dependencies>
    <!--1. MySQL 驱动-->
    <!-- https://mvnrepository.com/artifact/com.mysql/mysql-connector-j -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <version>8.4.0</version>
    </dependency>
    <!--2. mybatis 依赖-->
    <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.16</version>
    </dependency>
    <!--3. junit-->
    <!-- https://mvnrepository.com/artifact/junit/junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!--4. log4j-->
    <!-- https://mvnrepository.com/artifact/log4j/log4j -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
    <!--5. lombok-->
    <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.34</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

6-3 添加log4j配置

添加log4j的目的是在项目运行的过程中，可以实时查看sql执行步骤

在 chapter03s 资源文件夹 resources 中新建文件：log4j.xml
复用了chapter01的操作图，但是操作是一样的！

将以下内容添加进文件 log4j.xml
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/"> 爆红是正常的！

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8" />
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS}%m
(%F:%L) \n" />
        </layout>
    </appender>
    <logger name="java.sql">
        <level value="debug" />
    </logger>
    <logger name="org.apache.ibatis">
        <level value="info" />
    </logger>
    <root>
        <level value="debug" />
        <appender-ref ref="STDOUT" />
    </root>
</log4j:configuration>

6-4 创建chapter03s数据库

使用 Navicat 创建 chapter03s 数据库
请注意此处复用了chapter03的操作图，而你正在完成chapter03s的内容！

选择数据库 chapter03s 新建查询
请注意此处复用了chapter03的操作图，而你正在完成chapter03s的内容！

将以下初始化SQL指令复制进查询后运行即可，运行后按 F5 刷新一下就可以在Navicat中看到刚刚导入的数据了

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for course
-- ----------------------------
DROP TABLE IF EXISTS `course`;
CREATE TABLE `course`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '书名',
  `teacher` varchar(48) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '作者',
  `room` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '教室',
  `class_hour` int(11) NULL DEFAULT NULL COMMENT '课时',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 61 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of course
-- ----------------------------
INSERT INTO `course` VALUES (1, 'SQL Server2016数据库技术实用教程', '李玉娟', '308', 32);
INSERT INTO `course` VALUES (2, 'Adobe Premiere Pro CS3中文版影视编辑案例教程（含1DVD）', '李伟苑', '307', 32);
INSERT INTO `course` VALUES (3, '鞋产品舒适性设计', '黄君羡', '304', 64);
INSERT INTO `course` VALUES (4, '饭店管理总论', '张澧生', '303', 64);
INSERT INTO `course` VALUES (5, '汽车专业英语图解教程', '杨念福', '303', 64);
INSERT INTO `course` VALUES (6, '铁路施工组织与概预算', '张海燕', '303', 48);
INSERT INTO `course` VALUES (7, '建筑施工测量（第二版）', '黄君羡', '304', 32);
INSERT INTO `course` VALUES (8, 'Android App Inventor项目开发教程', '聂辉海', '306', 48);
INSERT INTO `course` VALUES (9, '电气自动化专业英语', '吴昕', '303', 64);
INSERT INTO `course` VALUES (10, '种子检验技术', '黄君羡', '303', 64);
INSERT INTO `course` VALUES (11, '管理技能与应用', '许玲', '305', 48);
INSERT INTO `course` VALUES (12, '草坪建植与养护', '张澧生', '303', 48);
INSERT INTO `course` VALUES (13, '饭店服务英语(第四版)', '杨念福', '304', 64);
INSERT INTO `course` VALUES (14, '软文营销攻略', '魏衍君', '307', 32);
INSERT INTO `course` VALUES (15, '制冷原理与设备', '刘利杰', '305', 32);
INSERT INTO `course` VALUES (16, '运输作业实务', '卢行芳', '306', 32);
INSERT INTO `course` VALUES (17, '体验生涯', '贺习耀', '308', 64);
INSERT INTO `course` VALUES (18, '通用英语能力训练教程（职业英语技能训练系列教程）', '高扬', '308', 48);
INSERT INTO `course` VALUES (19, '铁道信号专业计算机辅助设计', '王军龙', '308', 32);
INSERT INTO `course` VALUES (20, '铁路行车规章', '李峰', '302', 64);
INSERT INTO `course` VALUES (21, 'C# Windows项目开发案例教程', '蔡艳桃', '307', 48);
INSERT INTO `course` VALUES (22, '统计学', '张澧生', '302', 64);
INSERT INTO `course` VALUES (23, '操作系统（Linux）', '杨念福', '303', 64);
INSERT INTO `course` VALUES (24, '变频器应用与维护', '张海燕', '306', 32);
INSERT INTO `course` VALUES (25, '旅游概论', '孙廷', '305', 48);
INSERT INTO `course` VALUES (26, '办公软件应用教程', '李玉娟', '304', 32);
INSERT INTO `course` VALUES (27, '采购供应物流', '李伟苑', '302', 32);
INSERT INTO `course` VALUES (28, '电子产品模块电路及应用', '戴路玲', '305', 48);
INSERT INTO `course` VALUES (29, '电子测量与智能仪器', '李如姣', '307', 32);
INSERT INTO `course` VALUES (30, '网络存储技术应用项目化教程', '黄天中', '305', 32);
INSERT INTO `course` VALUES (31, '儿科护理学', '江爱云', '306', 64);
INSERT INTO `course` VALUES (32, '计算机应用基础实训指导', '王海艳', '306', 48);
INSERT INTO `course` VALUES (33, '网络营销（21世纪高职高专规划教材·电子商务系列；“十三五”江苏省高等学校重点教材，编号：2019-1-029）', '杨松尧', '308', 32);
INSERT INTO `course` VALUES (34, 'ERP供应链管理系统（现代职业教育体系建设系列教材）（会计专业系列）', '彭顺生', '306', 48);
INSERT INTO `course` VALUES (35, '中医护理学', '肖春来', '303', 32);
INSERT INTO `course` VALUES (36, '沙盘模拟企业经营实训', '王钧', '307', 32);
INSERT INTO `course` VALUES (37, '钢琴基础教程  2 (修订版)', '葛惠民', '303', 64);
INSERT INTO `course` VALUES (38, '公共关系实用教程（第2版）', '钟秋生', '306', 48);
INSERT INTO `course` VALUES (39, '动物营养与饲料', '钟秋生', '305', 64);
INSERT INTO `course` VALUES (40, '开店基础', '戴红萍  ', '302', 48);
INSERT INTO `course` VALUES (41, '管理沟通——理念、技能与实践', '聂辉海', '306', 48);
INSERT INTO `course` VALUES (42, '医学遗传学', '吴昕', '305', 64);
INSERT INTO `course` VALUES (43, '中小学民族民间舞蹈特色教材·初级篇', '黄君羡', '308', 64);
INSERT INTO `course` VALUES (44, '计算机文化基础（Windows 7+Office 2010）', '许玲', '306', 48);
INSERT INTO `course` VALUES (45, '新编商务英语听说 上', '余汉丽', '305', 48);
INSERT INTO `course` VALUES (46, '心理咨询师国家职业资格三级 : 大字版', '庄小将 ', '302', 48);
INSERT INTO `course` VALUES (47, '中文Photoshop CS6案例教程（第四版）', '邹德军', '303', 64);
INSERT INTO `course` VALUES (48, '单片机应用技术', '谢明夫', '308', 64);
INSERT INTO `course` VALUES (49, '游艇专业英语', '王卉芬', '302', 64);
INSERT INTO `course` VALUES (50, '商品流通企业会计核算实务（第3版）', '韩林申', '308', 32);
INSERT INTO `course` VALUES (51, '会计实务信息化操作', '窦红平', '308', 48);
INSERT INTO `course` VALUES (52, '汽车文化', '郑江平 ', '303', 32);
INSERT INTO `course` VALUES (53, '《空调器的安装与检修（含工作页）》', '京慧越商学院', '306', 32);
INSERT INTO `course` VALUES (54, '激光基础  理实一体化教程', '裴芸', '302', 64);
INSERT INTO `course` VALUES (55, '基础护理实训指导', '祝继英', '306', 32);
INSERT INTO `course` VALUES (56, '发酵技术', '杨敏', '302', 48);
INSERT INTO `course` VALUES (57, '护理礼仪（第二版）', '万雅静', '303', 48);
INSERT INTO `course` VALUES (58, '优秀歌词赏析', '陆勤超', '308', 32);
INSERT INTO `course` VALUES (59, '车载网络系统原理与检修', '人力资源和社会保障部教材办公室', '303', 32);
INSERT INTO `course` VALUES (60, '二胡演奏教程', '沈昕', '307', 32);

SET FOREIGN_KEY_CHECKS = 1;

6-5 domain类准备

在目录 src/main/java 软件包 cn.fvti.chapter03s.domain 下创建Java类 Course

在Java类 Course 中声明 id（编号）、name（课程名称）、teacher（授课老师）、room（上课教室）和class_hour（课时）属性，以及属性对应的 Getter/Setter 方法。
将@Data注解加在类的上方，就可以利用lombok自动生成getter/setter/toString

package cn.fvti.chapter03s.domain;

import lombok.Data;

@Data //利用lombok自动生成getter/setter/toString
public class Course {

    /**
     * 主键
     */
    private Integer id;
    /**
     * 课程名称
     */
    private String name;
    /**
     * 授课老师
     */
    private String teacher;
    /**
     * 上课教师
     */
    private String room;
    /**
     * 课时
     */
    private Integer classhour;
}

6-6 建立mapper映射

6-6-1 编写mapper接口文件

在目录 src/main/java 软件包 cn.fvti.chapter03s.mapper 下创建Java接口 CourseMapper

在Java接口 CourseMapper 中声明方法，如下代码

package cn.fvti.chapter03s.mapper;

import cn.fvti.chapter03s.domain.Course;
import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface CourseMapper {
    /**
     * 多条件查询
     * @param course
     * @return
     */
    public List<Course> getCourseListByCondition(Course course);

    /**
     * 依据id批量删除数据
     * @param ids
     * @return
     */
    public Integer deleteCourseByIds(@Param("ids") List<Integer> ids);
}

关于此处代码的注释如有需求可以参考 👉 4-6-1-1 注释的巧用
此章节不再赘述

6-6-2 编写mapper映射文件

在资源目录 src/main/resources 中的目录 cn/fvti/chapter03s/mapper 下创建文件 CourseMapper.xml
该文件主要用于实现SQL语句和Java对象之间的映射

将以下内容添加进文件 CourseMapper.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为映射的根节点 -->
<!-- mapper为映射的根节点，namespace指定mapper接口的全限定类名
mybais会根据这个接口动态创建一个实现类去实现这个接口，
而这个实现类是一个Mapper对象 -->
<mapper namespace="cn.fvti.chapter03s.mapper.CourseMapper"></mapper>

6-6-3 使用MyBatisX快捷映射

在mapper映射文件 CourseMapper.xml 中点击
①MyBatis小蓝鸟 或文件列表中的 ②mapper接口文件
返回mapper接口 CourseMapper

看不懂下面的快捷创建接口对应映射？
前往 👉 5-2 用户查询学习一下~

点击冒红字段 getCourseListByCondition 按键盘快捷键 ALT 回车 选择 Generate statement
现在自动跳转到了资源目录 resources 中目录 cn/fvti/chapter03s/mapper 下的 Mapper 映射文件 CourseMapper.xml ，并且自动创建了对应的XML语句块，直接敲回车从下一行开始填入SQL语句

<select id="getCourseListByCondition" resultType="cn.fvti.chapter03s.domain.Course">
    select * from course
    <where>
        <if test="name !=null and name!=''">
            and name like concat("%",#{name},"%")
        </if>
        <if test="teacher !=null and teacher!=''">
            and teacher like concat("%",#{teacher},"%")
        </if>
        <if test="room !=null and room!=''">
            and room > #{room}
        </if>
        <if test="classhour !=null and classhour!=''">
            and class_hour > #{classhour}
        </if>
    </where>
</select>

返回mapper接口 CourseMapper

点击冒红字段 deleteCourseByIds 按键盘快捷键 ALT 回车 选择 Generate statement 在新弹出的窗口有两个 Delete Statement 随便选一个就行
现在自动跳转到了资源目录 resources 中目录 cn/fvti/chapter03s/mapper 下的 Mapper 映射文件 CourseMapper.xml ，并且自动创建了对应的XML语句块，直接敲回车从下一行开始填入SQL语句

<delete id="deleteCourseByIds">
    delete from course where id in
    <foreach collection="ids" item="id" open="(" separator="," close=")">
        #{id}
    </foreach>
</delete>

6-7 配置连接数据库

6-7-1 添加mybatis核心配置文件

在资源目录 src/main/resources 下创建文件
mybatis-config.xml jdbc.properties
注意，是新建以上两个文件不是一个文件！
请注意此处复用了chapter02的操作图，而你正在完成chapter03s的内容！

将以下内容添加进文件 mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!-- 环境配置 -->
    <!-- 加载类路径下的属性文件 -->
    <properties resource="jdbc.properties"/>
    <typeAliases>
        <!--告诉mybatis，实体类的路径-->
        <package name="cn.fvti.chapter03s.domain"></package>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <!-- 数据库连接相关配置 ,db.properties文件中的内容-->
            <dataSource type="POOLED">
                <!-- 设置连接数据库的驱动 -->
                <property name="driver" value="${mysql.driver}"/>
                <!-- 设置连接数据库的连接地址 -->
                <property name="url" value="${mysql.url}"/>
                <!-- 设置连接数据库的用户名 -->
                <property name="username" value="${mysql.username}"/>
                <!-- 设置连接数据库的密码 -->
                <property name="password" value="${mysql.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- mapping文件路径配置 -->
    <mappers>
        <!--扫包：要求  1. mapper接口和映射xml文件必须拥有相同的目录结构  2. mapper接口和映射xml文件的名字必须是一致-->
        <package name="cn.fvti.chapter03s.mapper"></package>
    </mappers>
</configuration>

6-7-2 添加jdbc配置

将以下内容添加进文件 jdbc.properties

mysql.driver=com.mysql.cj.jdbc.Driver
mysql.url=jdbc:mysql://localhost:3306/chapter03s?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=false
mysql.username=root
mysql.password=123456

6-8 编写工具类

在目录 src/main/java 新建软件包 cn.fvti.chapter03s.utils 并创建Java类 MyBatisUtils
该类用于封装读取配置文件信息的代码

你可以直接在 chapter03s 下创建Java类 utils.MyBatisUtils 其中 utils 会自动被创建为软件包
以下展示快捷创建方法
请注意此处复用了chapter02的操作图，而你正在完成chapter03s的内容！

将以下内容添加进Java类 MyBatisUtils

package cn.fvti.chapter03s.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.Reader;

public class MyBatisUtils {
    private static SqlSessionFactory sqlSessionFactory = null;

    // 初始化SqlSessionFactory对象
    static {
        try {
            // 使用MyBatis提供的Resources类加载MyBatis的配置文件
            Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
            // 构建SqlSessionFactory工厂
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 获取SqlSession对象的静态方法
    public static SqlSession getSession(){
        return sqlSessionFactory.openSession(true);
    }
}

第17行代码读取mybatis-config.xml文件内容到reader对象中；第19行代码创建SqlSessionFactory类的实例；第26行代码定义一个getSession()静态方法，并在静态方法中通过SqlSessionFactory类的实例创建SqlSession实例。

6-9 测试类

在目录 test/java 的测试软件包 cn.fvti.chapter03s
并在这个软件包中新建Java类 MyBatisTest 以编写测试代码
请注意此处复用了chapter02的操作图，而你正在完成chapter03s的内容！

在编写或运行测试类过程中可能IJ编辑器会提示 Lombok 要求已启用的注解处理 ，直接选择启用即可

如果忘记或忽略点启用了可以参考这篇教程启用 👇
CSDN：idea运行项目时右下角弹出“Lombok 要求已启用的注解处理”却正常运行的解决方法

6-9-1 多条件组合查询课程信息

在 MyBatisTest 测试类中添加 getCourseListByCondition() 方法，该方法可以根据 name,teacher,room,classHour 多条件组合查询课程信息。 getCourseListByCondition() 方法具体代码如下所示。

package cn.fvti.chapter03s;

import cn.fvti.chapter03s.domain.Course;
import cn.fvti.chapter03s.mapper.CourseMapper;
import cn.fvti.chapter03s.utils.MyBatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class MyBatisTest {
    @Test
    public void getCourseListByCondition() {
        // 提供工具类生成SqlSession对象
        SqlSession session = MyBatisUtils.getSession();
        CourseMapper mapper = session.getMapper(CourseMapper.class);
        Course course = new Course();
        course.setName("电子");
        course.setRoom("305");

        List<Course> courseListByCondition = mapper.getCourseListByCondition(course);
        System.out.println(courseListByCondition);
        // 关闭SqlSession
        session.close();
    }
}

上述代码中，第15行代码通过MyBatisUtils工具类获取SqlSession对象；第16行代码用于获取代理实现类，第17-19行代码构建查询对象，第21行代码通过传入查询参数获取课程信息，并返回查询到的结果集；第22行代码打印查询符合条件的结果集；第24行代码关闭SqlSession，释放资源。

在有 @Test 的方法中可以使用方法开头左侧的运行按钮单独测试此方法的代码
可以看到运行后正常输出了 log4j 和代码中 多条件组合查询课程信息 内容

6-9-2 批量删除课程信息

在 MyBatisTest 测试类中添加 deleteCourseByIds() 方法，该方法用于依据id批量删除课程信息。 deleteCourseByIds() 方法具体代码如下所示。

@Test
public void deleteCourseByIds() {
    // 提供工具类生成SqlSession对象
    SqlSession session = MyBatisUtils.getSession();
    CourseMapper mapper = session.getMapper(CourseMapper.class);
    List<Integer> ids = new ArrayList<>();
    ids.add(1);
    ids.add(2);
    Integer res = mapper.deleteCourseByIds(ids);
    if (res > 0) {
        System.out.println("成功删除" + res + "条数据");
    }
    // 关闭SqlSession
    session.close();
}

上述代码中，第4行代码通过MyBatisUtils工具类获取SqlSession对象；第5行代码用于获取代理实现类，第6-8行代码用于初始化需要删除的id列表，第9行代码执行代理实现类mapper的删除方法deleteCourseByIds()，批量删除课程信息，并返回删除记录的条数；第10-12行代码判断数据是否删除成功；第14行代码关闭SqlSession。

在有 @Test 的方法中可以使用方法开头左侧的运行按钮单独测试此方法的代码
可以看到运行后正常输出了 log4j 和代码中 成功删除几条数据 内容

打开 Navicat 使用 F5 刷新后即可看到刚刚删除的数据已经从数据库中消失了

恭喜完成[第七节课]20240924内容